From 40485d69656cca89417b0c7104f10ad55d817fc8 Mon Sep 17 00:00:00 2001 From: Sethyrial <116576676+LoveS0ph1e@users.noreply.github.com> Date: Fri, 23 Oct 2026 00:58:55 +0800 Subject: [PATCH] feat(antigravity): add Google Antigravity cognitive memory plugin --- README.md | 1 + antigravity/.gitignore | 23 + antigravity/LICENSE | 201 +++++++ antigravity/README.md | 252 +++++++++ antigravity/README_zh.md | 259 +++++++++ antigravity/hooks.json | 25 + antigravity/hooks/scripts/capture.js | 134 +++++ antigravity/hooks/scripts/flush.js | 98 ++++ antigravity/hooks/scripts/lib/config.js | 230 ++++++++ antigravity/hooks/scripts/lib/constants.js | 53 ++ antigravity/hooks/scripts/lib/everos.js | 150 +++++ antigravity/hooks/scripts/lib/hook-io.js | 106 ++++ antigravity/hooks/scripts/lib/identity.js | 189 +++++++ antigravity/hooks/scripts/lib/provision.js | 120 ++++ antigravity/hooks/scripts/lib/query.js | 70 +++ antigravity/hooks/scripts/lib/render.js | 270 +++++++++ .../hooks/scripts/lib/search-tracks.js | 129 +++++ antigravity/hooks/scripts/lib/state.js | 497 +++++++++++++++++ antigravity/hooks/scripts/lib/transcript.js | 372 +++++++++++++ antigravity/hooks/scripts/recall.js | 138 +++++ antigravity/hooks/scripts/session-start.js | 134 +++++ antigravity/mcp/server.js | 347 ++++++++++++ antigravity/mcp_config.json | 9 + antigravity/package.json | 24 + antigravity/plugin.json | 10 + antigravity/scripts/check-manifests.mjs | 152 ++++++ antigravity/scripts/install.mjs | 315 +++++++++++ antigravity/scripts/live-verify.js | 447 +++++++++++++++ antigravity/scripts/seed-demo.js | 69 +++ antigravity/skills/everos-flush/SKILL.md | 17 + antigravity/skills/everos-search/SKILL.md | 18 + antigravity/skills/everos-status/SKILL.md | 17 + antigravity/skills/everos/SKILL.md | 41 ++ antigravity/skills/everos/cli.js | 237 ++++++++ antigravity/tests/capture-chunk.test.js | 87 +++ antigravity/tests/config.test.js | 129 +++++ antigravity/tests/everos.test.js | 164 ++++++ antigravity/tests/failure-branches.test.js | 137 +++++ antigravity/tests/fake-everos.test.js | 207 +++++++ .../fixtures/live-sandbox/.agents/hooks.json | 25 + .../live-sandbox/.agents/mcp_config.json | 9 + .../tests/fixtures/live-sandbox/package.json | 7 + .../tests/fixtures/live-sandbox/src/index.js | 18 + .../fixtures/transcript-antigravity.jsonl | 10 + antigravity/tests/helpers/contract.js | 169 ++++++ antigravity/tests/helpers/fake-everos.js | 131 +++++ antigravity/tests/helpers/run-hook.js | 88 +++ antigravity/tests/hook-io.test.js | 112 ++++ antigravity/tests/identity.test.js | 161 ++++++ antigravity/tests/lifecycle.test.js | 516 ++++++++++++++++++ antigravity/tests/manifests.test.js | 101 ++++ antigravity/tests/mcp-server.test.js | 406 ++++++++++++++ antigravity/tests/provision.test.js | 187 +++++++ antigravity/tests/query.test.js | 60 ++ antigravity/tests/recall-turnid.test.js | 130 +++++ antigravity/tests/render.test.js | 127 +++++ antigravity/tests/search-tracks.test.js | 65 +++ .../tests/session-start-detached.test.js | 120 ++++ antigravity/tests/skills.test.js | 232 ++++++++ antigravity/tests/state-collision.test.js | 19 + antigravity/tests/state-concurrency.test.js | 56 ++ antigravity/tests/state.test.js | 265 +++++++++ antigravity/tests/transcript.test.js | 316 +++++++++++ 63 files changed, 9208 insertions(+) create mode 100644 antigravity/.gitignore create mode 100644 antigravity/LICENSE create mode 100644 antigravity/README.md create mode 100644 antigravity/README_zh.md create mode 100644 antigravity/hooks.json create mode 100644 antigravity/hooks/scripts/capture.js create mode 100644 antigravity/hooks/scripts/flush.js create mode 100644 antigravity/hooks/scripts/lib/config.js create mode 100644 antigravity/hooks/scripts/lib/constants.js create mode 100644 antigravity/hooks/scripts/lib/everos.js create mode 100644 antigravity/hooks/scripts/lib/hook-io.js create mode 100644 antigravity/hooks/scripts/lib/identity.js create mode 100644 antigravity/hooks/scripts/lib/provision.js create mode 100644 antigravity/hooks/scripts/lib/query.js create mode 100644 antigravity/hooks/scripts/lib/render.js create mode 100644 antigravity/hooks/scripts/lib/search-tracks.js create mode 100644 antigravity/hooks/scripts/lib/state.js create mode 100644 antigravity/hooks/scripts/lib/transcript.js create mode 100644 antigravity/hooks/scripts/recall.js create mode 100644 antigravity/hooks/scripts/session-start.js create mode 100644 antigravity/mcp/server.js create mode 100644 antigravity/mcp_config.json create mode 100644 antigravity/package.json create mode 100644 antigravity/plugin.json create mode 100644 antigravity/scripts/check-manifests.mjs create mode 100644 antigravity/scripts/install.mjs create mode 100644 antigravity/scripts/live-verify.js create mode 100644 antigravity/scripts/seed-demo.js create mode 100644 antigravity/skills/everos-flush/SKILL.md create mode 100644 antigravity/skills/everos-search/SKILL.md create mode 100644 antigravity/skills/everos-status/SKILL.md create mode 100644 antigravity/skills/everos/SKILL.md create mode 100644 antigravity/skills/everos/cli.js create mode 100644 antigravity/tests/capture-chunk.test.js create mode 100644 antigravity/tests/config.test.js create mode 100644 antigravity/tests/everos.test.js create mode 100644 antigravity/tests/failure-branches.test.js create mode 100644 antigravity/tests/fake-everos.test.js create mode 100644 antigravity/tests/fixtures/live-sandbox/.agents/hooks.json create mode 100644 antigravity/tests/fixtures/live-sandbox/.agents/mcp_config.json create mode 100644 antigravity/tests/fixtures/live-sandbox/package.json create mode 100644 antigravity/tests/fixtures/live-sandbox/src/index.js create mode 100644 antigravity/tests/fixtures/transcript-antigravity.jsonl create mode 100644 antigravity/tests/helpers/contract.js create mode 100644 antigravity/tests/helpers/fake-everos.js create mode 100644 antigravity/tests/helpers/run-hook.js create mode 100644 antigravity/tests/hook-io.test.js create mode 100644 antigravity/tests/identity.test.js create mode 100644 antigravity/tests/lifecycle.test.js create mode 100644 antigravity/tests/manifests.test.js create mode 100644 antigravity/tests/mcp-server.test.js create mode 100644 antigravity/tests/provision.test.js create mode 100644 antigravity/tests/query.test.js create mode 100644 antigravity/tests/recall-turnid.test.js create mode 100644 antigravity/tests/render.test.js create mode 100644 antigravity/tests/search-tracks.test.js create mode 100644 antigravity/tests/session-start-detached.test.js create mode 100644 antigravity/tests/skills.test.js create mode 100644 antigravity/tests/state-collision.test.js create mode 100644 antigravity/tests/state-concurrency.test.js create mode 100644 antigravity/tests/state.test.js create mode 100644 antigravity/tests/transcript.test.js diff --git a/README.md b/README.md index c18304d..402c2d1 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ app. | [`openclaw/`](./openclaw) | [OpenClaw](https://docs.openclaw.ai) | [`@everos-ai/openclaw-plugin`](https://www.npmjs.com/package/@everos-ai/openclaw-plugin) on npm — one-command setup: `npx --yes --package @everos-ai/openclaw-plugin everos-setup` | 🚚 scope move — first `@everos-ai` publish pending (previously `@evermind-ai/openclaw-plugin`, 3.0.2) | | [`claude-code/`](./claude-code) | [Claude Code](https://code.claude.com) | `claude plugin marketplace add EverMind-AI/Plugins` then `claude plugin install everos@everos --scope user` | 🧪 built — pre-release verification | | [`codex/`](./codex) | [Codex](https://developers.openai.com/codex) | `codex plugin marketplace add EverMind-AI/Plugins` then `codex plugin add everos@everos` | 🧪 built — pre-release verification | +| [`antigravity/`](./antigravity) | [Google Antigravity](https://github.com/LoveS0ph1e/ArtEmis) | `node scripts/install.mjs -g -s` | 🧪 built — pre-release verification | | [`hermes/`](./hermes) | [Hermes Agent](https://github.com/NousResearch/hermes-agent) | `hermes plugins install EverMind-AI/plugins/hermes` | 🧪 built — pre-release verification | | [`dsh/`](./dsh) | [DeepSeek Harness](https://github.com/deepseek-ai/DeepSeek-Harness) | `dsh plugin --profile web add @everos-ai/dsh-plugin` | 🧪 built — pre-release verification | | [`dify/`](./dify) | [Dify](https://dify.ai) | Package with the Dify CLI, then upload the `.difypkg` in Dify | 🧪 built — Marketplace submission pending | diff --git a/antigravity/.gitignore b/antigravity/.gitignore new file mode 100644 index 0000000..ffad12c --- /dev/null +++ b/antigravity/.gitignore @@ -0,0 +1,23 @@ +# Node.js dependencies +node_modules/ +package-lock.json + +# Logs and runtime artifacts +*.log +*.tmp +*.zip +.DS_Store +Thumbs.db + +# Environment variables and secrets +.env +.env.* +!.env.example + +# Test temporary sandboxes +tests/fixtures/live-sandbox/live_transcript.jsonl + +# Internal development notes & scratch docs +docs/ +*.bak + diff --git a/antigravity/LICENSE b/antigravity/LICENSE new file mode 100644 index 0000000..1ff191e --- /dev/null +++ b/antigravity/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2026 Sethyrial + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/antigravity/README.md b/antigravity/README.md new file mode 100644 index 0000000..b68b4ab --- /dev/null +++ b/antigravity/README.md @@ -0,0 +1,252 @@ +# ArtEmis: EverOS Memory Plugin for Google Antigravity + +Persistent, cross-session, self-evolving memory for **Google Antigravity**, backed by the [EverOS](https://github.com/EverMind-AI/EverOS) cognitive memory engine (`http://127.0.0.1:8000`). + +Strictly compliant with the EverOS v2 backend protocol (`/api/v2/memory/*`), built with a **pure ESM architecture and zero runtime dependencies (Zero-Dep)**, fully resilient on Windows 11, and featuring an advanced **Three-Tier Progressive Disclosure** context assembly pipeline. + +--- + +## Table of Contents + +- [1. Cognitive Model Prerequisites (Important!)](#1-cognitive-model-prerequisites-important) +- [2. One-Click AI Agent Deployment Prompt](#2-one-click-ai-agent-deployment-prompt) +- [3. Manual Installation & Setup](#3-manual-installation--setup) +- [4. Key Highlights & Architectural Invariants](#4-key-highlights--architectural-invariants) +- [5. Dual-Language Semantic Anchors](#5-dual-language-semantic-anchors) +- [6. Native MCP Server Tools & Skills Console](#6-native-mcp-server-tools--skills-console) +- [7. Configuration Reference](#7-configuration-reference) +- [8. Verification & Test Suite](#8-verification--test-suite) +- [License](#license) + +--- + +## 1. Cognitive Model Prerequisites (Important!) + +> [!IMPORTANT] +> **Dual-Model Cognitive Engine Dependency**: +> This plugin (client adapter layer) is strictly pure ESM with **zero runtime dependencies** and built-in fail-open resilience. +> However, the underlying **EverOS backend engine requires two distinct AI model services** configured to extract memories and power dense vector retrieval: +> 1. **Extractor LLM (Inference Model)**: Distills raw conversation transcripts, extracts coding conventions, records architectural decisions, and evolves the developer profile. +> 2. **Dense Embedding Model (Vector Model)**: Computes dense semantic vectors for user prompts and memory collections, enabling sub-second hybrid and semantic search. +> +> Without configuring these models, EverOS cannot construct vector indexes or extract cognitive memories. + +### Recommended Configuration Template (`~/.everos/everos.toml`) + +Create or update `~/.everos/everos.toml` (or `%USERPROFILE%\.everos\everos.toml` on Windows): + +```toml +[server] +host = "127.0.0.1" +port = 8000 + +# 1. Extractor LLM: Distills transcripts, extracts entities, and evolves user profile +[llm] +provider = "openai" +base_url = "https://api.example.com/v1" # Endpoint for your inference model +api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxx" +model = "your-chat-model-name" +temperature = 0.2 + +# 2. Dense Embedding Model: Vectorizes memory collections for semantic retrieval +[embedding] +provider = "openai" +base_url = "https://api.example.com/v1" # Endpoint for your embedding model +api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxx" +model = "your-embedding-model-name" +dimension = 4096 # Must strictly match the model dimension +query_max_concurrent = 8 # Concurrent search slots (default 16) + +[storage] +backend = "lancedb" # Default vector storage backend +``` + +### Health Verification +Start your EverOS server and verify readiness: +```bash +curl http://127.0.0.1:8000/health +``` +**Expected response**: +```json +{ + "healthy": true, + "embed": true, + "version": "1.5.1" +} +``` +> Ensure both `"healthy": true` and `"embed": true` are returned to activate full semantic retrieval and memory ingestion. + +--- + +## 2. One-Click AI Agent Deployment Prompt + +If you use an AI Agent (e.g., Antigravity, Codex, Claude Code, Deepseek Harness, etc.), **copy and paste the prompt below directly to your Agent**. It will automatically inspect the environment, configure prerequisites, and register the plugin: + +````markdown +# ArtEmis Automated Deployment Task + +Please execute the automated configuration, deployment, and verification of the ArtEmis (EverOS Google Antigravity) memory plugin on this machine. +The plugin root is the current directory (if not located here, please prompt me for or locate the plugin repository path). + +Execute the workflow sequentially through the following five phases: + +## Phase 1: Runtime & Dependency Discovery +- Verify that Node.js runtime version satisfies `>= 20.0.0`; +- Inspect system Python `>= 3.10` and EverOS package status (`everos --version` or in the active virtual environment); guide or run `pip install everos` if uninstalled. + +## Phase 2: Dual-Model Cognitive Configuration Verification +- Check if `~/.everos/everos.toml` (or `%USERPROFILE%\.everos\everos.toml` on Windows) exists with valid `[llm]` and `[embedding]` sections; +- If missing or unconfigured, prompt me for the following two sets of credentials: + 1. **Extractor LLM**: Base URL, API Key, Model Name (for transcript distillation, rule extraction, and developer profile evolution); + 2. **Embedding Model**: Base URL, API Key, Model Name, and Output Dimension (for dense vector indexing and semantic recall); +- Automatically generate and atomically write the standard `~/.everos/everos.toml`. + +## Phase 3: Daemon Launch & Health Deep Check +- Start or verify the running EverOS daemon (`http://127.0.0.1:8000`); +- Probe `http://127.0.0.1:8000/health` and verify the JSON response strictly satisfies: + * `healthy === true` + * `embed === true` + Confirming both dense embedding and LLM backend pipelines are fully operational. + +## Phase 4: Global Deployment, Native Sidecar Registration & Test Gates +- In the plugin repository root, run manifest security gates: + `node scripts/check-manifests.mjs` (ensure all 16 checks pass with 0 FAIL); +- Deploy as a global plugin and register the native Antigravity Sidecar daemon: + `node scripts/install.mjs -g -s` (installs to `~/.gemini/config/plugins/everos/` and registers `~/.gemini/config/sidecars/everos/`); +- Execute full test suite to guarantee environment resilience: + `npm test` (verify all 120 tests pass). + +## Phase 5: Handoff & Verification Summary +- Render a structured diagnostic summary (EverOS endpoint, dual-model connection status, plugin and sidecar registration paths); +- Advise me to restart or reload Antigravity and inspect status via `/everos status`. +```` + +--- + +## 3. Manual Installation & Setup + +### 1. Global Plugin & Native Sidecar Registration (Recommended) +From the plugin repository directory, run: +```bash +# -g: Deploy as a global plugin (~/.gemini/config/plugins/everos) +# -s: Register Antigravity native persistent Sidecar daemon +node scripts/install.mjs -g -s +``` + +### 2. Workspace-Level Setup +To mount the plugin only for a specific project: +```bash +node scripts/install.mjs --workspace /path/to/your/workspace +``` +The installer automatically links hooks and MCP tools into `/.agents/hooks.json` and `/.agents/mcp_config.json`, safely creating `.bak` backups of any existing configurations. + +### 3. Uninstall & Rollback +```bash +node scripts/install.mjs -g --uninstall +``` + +--- + +## 4. Key Highlights & Architectural Invariants + +``` + Google Antigravity IDE (Host) +┌───────────────────────────────────────────────┐ +│ System Context: (L1 Profile) │ ─── Prescriptive Covenants & Tacit Affinities +│ History Trajectory │ +│ Ephemeral Turn: (L2 Ephemeral)│ ─── Erstwhile Exemplars & Interwoven Vestiges +│ Current User Prompt │ +└───────────────────────────────────────────────┘ + ▲ + │ stdio JSON-RPC 2.0 / Hook Ingestion + ▼ +┌───────────────────────────────────────────────┐ +│ everos-antigravity (Pure ESM, Zero-Dep) │ +│ - Hook IO & Windows 11 Natural Drain Protocol │ +│ - Detached Worker Dispatch (~300ms startup) │ +│ - Two-Phase Commit (2PC) State Ledger │ +│ - Chunk Idempotency (acked_chunks tracking) │ +│ - Dummy Tool Synth & Anti-Recursive Defense │ +│ - Native stdio MCP Server & Unified /everos │ +└───────────────────────────────────────────────┘ + ▲ + │ HTTP REST (Loopback) + ▼ +┌───────────────────────────────────────────────┐ +│ EverOS Cognitive Memory Runtime (:8000) │ +│ - LLM Distillation + LanceDB Vector Index │ +└───────────────────────────────────────────────┘ +``` + +- **Zero Runtime Dependencies**: Strictly built on Node.js `>=20.0.0` built-in standard libraries (`node:fs`, `node:child_process`, `node:readline`, native `fetch` and `crypto`). No third-party npm packages to audit. +- **Fail-Open by Design**: If EverOS is offline, unreachable, or encounters an internal fault, hooks exit in milliseconds returning `{}`. Antigravity operates uninterrupted. +- **Two-Phase Commit (2PC) Ledger**: Local observation (`observed_turn_index`) advances independently of settlement (`settled_turn_index`). Includes client-side `acked_chunks` tracking to eliminate chunk duplication during retries. +- **Detached Startup Dispatch**: Replaces synchronous SessionStart blocking with an asynchronous detached worker process, reducing SessionStart execution from >15s to **~300ms**. +- **Windows 11 Natural Drain Protocol**: Strictly enforces `process.exitCode = 0` exit semantics over `process.exit(0)`, preventing stdout pipe truncation and empty JSON parse crashes on Windows. +- **Code Generic & JSX Safety**: Uses targeted regex stripping exclusively for `` and ``, preserving TypeScript generics (`Array`) and JSX tags. + +--- + +## 5. Dual-Language Semantic Anchors + +The rendering engine features a dual-language anchor registry (toggled via `EVEROS_AG_LOCALE=zh` or `en`): + +| Data Bucket | Chinese Anchor | English Anchor | Purpose | +|---|---|---|---| +| `explicit_info` | **【既定规约】** | **[Prescriptive Covenants]** | Hard architectural constraints and tech stack mandates (L1 Profile) | +| `implicit_traits` | **【意趣默契】** | **[Tacit Affinities]** | Inferred engineering style and coding habits (L1 Profile) | +| `agent_cases` | **【曾有范例】** | **[Erstwhile Exemplars]** | Troubleshooting postmortems and breakthrough solutions (L2 Ephemeral) | +| `episodes` | **【交互脉络】** | **[Interwoven Vestiges]** | Cross-session architectural evolution and decision history (L2 Ephemeral) | + +--- + +## 6. Native MCP Server Tools & Skills Console + +### 1. Autonomous Agent Tools (MCP Tools) +- `everos_search_memory`: Search historical engineering memories and troubleshooting cases. +- `everos_get_profile`: Retrieve developer profile (covenants and tacit affinities). +- `everos_add_memory`: Explicitly record a critical postmortem, decision, or convention. +- *(Note: Flush/Seal permissions are withheld from the LLM; sealing is reserved for lifecycle hooks and human developers).* + +### 2. Unified Skills Console (`/everos`) +- **/everos status** (or bare `/everos`): Run diagnostics and inspect connection status, project partition, and active sessions. +- **/everos flush** (or `/everos-flush`): Manually trigger a 2PC seal on the most recent session for knowledge distillation. +- **/everos search **: Interactively search engineering memory directly from the prompt line. + +--- + +## 7. Configuration Reference + +The plugin client adapter supports optional overrides via environment variables: + +| Variable | Default | Description | +|---|---|---| +| `EVEROS_AG_BASE_URL` | `http://127.0.0.1:8000` | HTTP URL of the EverOS backend server | +| `EVEROS_AG_SEARCH_METHOD` | `keyword` | Retrieval mode (`keyword`, `vector`, `hybrid`) | +| `EVEROS_AG_PROJECT_ID` | Derived from Git Remote | Canonical project partition (Agent Track) | +| `EVEROS_AG_USER_ID` | System Username (`USERNAME`) | User identity partition (User Track) | +| `EVEROS_AG_LOCALE` | `zh` | Language for semantic anchors (`zh` or `en`) | +| `EVEROS_AG_DATA_DIR` | `~/.everos/antigravity` | Path for 2PC session state and index | +| `EVEROS_AG_RECALL_TIMEOUT_MS` | `5000` | Retrieval timeout ceiling (500~10000ms) | + +--- + +## 8. Verification & Test Suite + +The repository includes a comprehensive, dependency-free test harness: + +```bash +# Run 16 manifest gate checks and 120 unit/integration tests +npm test + +# Run isolated live verification suite simulating full IDE lifecycle +npm run verify:live +``` + +The test suite covers monotonic state merges, chunk retry ledgers, Windows path casing, pipe drain semantics, detached dispatch, and dual-track search fairness. + +--- + +## License + +Apache-2.0 © 2026 Sethyrial diff --git a/antigravity/README_zh.md b/antigravity/README_zh.md new file mode 100644 index 0000000..91fad17 --- /dev/null +++ b/antigravity/README_zh.md @@ -0,0 +1,259 @@ +# ArtEmis：面向 Google Antigravity 的 EverOS 记忆插件 + +为 **Google Antigravity** 打造的跨会话、自进化长期认知记忆插件，底层对接 [EverOS](https://github.com/EverMind-AI/EverOS) 认知记忆引擎（本地默认 `http://127.0.0.1:8000`）。 + +严格遵循 EverOS v2 后端协议（`/api/v2/memory/*`），采用**纯 ESM 架构、零第三方运行时依赖（Zero-Dependency）**，深度兼容 Windows 11 环境，并引入首创的**三层渐进式披露（Three-Tier Progressive Disclosure）**上下文组装机制。 + +--- + +## 目录 + +- [一、 认知动力源：双模型前置配置（重要！）](#一-认知动力源双模型前置配置重要) +- [二、 部署指南：AI Agent 一键式自动装配 Prompt](#二-部署指南ai-agent-一键式自动装配-prompt) +- [三、 手动安装指南](#三-手动安装指南) +- [四、 核心功能与架构特性](#四-核心功能与架构特性) +- [五、 四大分类锚点（中英双语自适应）](#五-四大分类锚点中英双语自适应) +- [六、 原生 MCP 工具与统一运维控制台](#六-原生-mcp-工具与统一运维控制台) +- [七、 环境变量配置参考](#七-环境变量配置参考) +- [八、 自动化验收套件与实证](#八-自动化验收套件与实证) +- [开源协议](#开源协议) + +--- + +## 一、 认知动力源：双模型前置配置（重要！） + +> [!IMPORTANT] +> **认知引擎双模型依赖说明**： +> 本插件（前端适配层）遵循纯 ESM 架构，**没有任何第三方运行时依赖**且原生具备 Fail-Open 容灾能力； +> 但底层的 **EverOS 认知引擎必须同时接入两套模型服务**，才能真正完成知识提炼与语义检索： +> 1. **归纳推理模型 (Extractor LLM)**：用于从长对话中提取关键事实、代码规约、归纳决策纪事并演进用户画像； +> 2. **密集嵌入模型 (Dense Embedding Model)**：用于对用户提问和记忆库执行稠密向量化，驱动毫秒级语义与混合检索。 +> +> 若未配置上述模型，EverOS 无法生成向量索引或萃取记忆。 + +### 推荐配置模板（`~/.everos/everos.toml`） + +在用户主目录下创建或编辑 `~/.everos/everos.toml`（Windows 下对应 `%USERPROFILE%\.everos\everos.toml`）： + +```toml +[server] +host = "127.0.0.1" +port = 8000 + +# 1. 归纳推理模型：负责记忆萃取、实体提炼与画像演进 +[llm] +provider = "openai" +base_url = "https://api.example.com/v1" # 您的通用推理模型服务商端点 +api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxx" +model = "your-chat-model-name" +temperature = 0.2 + +# 2. 密集嵌入模型：负责语义相似度计算与知识库密集向量索引 +[embedding] +provider = "openai" +base_url = "https://api.example.com/v1" # 您的嵌入模型服务商端点 +api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxx" +model = "your-embedding-model-name" +dimension = 4096 # 必须与模型输出维度严格一致 +query_max_concurrent = 8 # 检索并发槽位（根据 API 速率配额设置） + +[storage] +backend = "lancedb" # 默认向量数据库 +``` + +### 连通性自检 +配置完成后启动 EverOS，访问健康探测端点验证： +```bash +curl http://127.0.0.1:8000/health +``` +**正常响应示例**： +```json +{ + "healthy": true, + "embed": true, + "version": "1.5.1" +} +``` +> 必须确保响应中 `"healthy": true` 且 `"embed": true`，方可开启完整的语义检索与认知沉淀！ + +--- + +## 二、 部署指南：AI Agent 一键式自动装配 Prompt + +如果您使用 AI Agent（如 Antigravity、Codex、Claude Code、Deepseek Harness 等）进行开发，只需将以下提示词**复制并粘贴给您的 Agent**，Agent 将全自动完成环境检测、依赖引导与全局注册： + +````markdown +# ArtEmis 全自动装配任务 + +请帮我在当前机器上全自动配置、部署并验证 ArtEmis (EverOS Google Antigravity) 记忆插件。 +仓库根目录为当前工作区（若未在插件根目录，请先向我询问或定位插件路径）。 + +请严格按照以下五个阶段依次推进，前一阶段未通过时请停下排查或向我确认： + +## 阶段一：运行环境与底层依赖探测 +- 检查系统 Node.js 运行时版本（需满足 `>= 20.0.0`）； +- 检查系统 Python 环境（需满足 `>= 3.10`）以及 EverOS 核心库的安装状态（通过 `everos --version` 或当前虚拟环境探测）；若未安装，引导我执行 `pip install everos`。 + +## 阶段二：认知引擎双模型配置核查（LLM 归纳 + 嵌入模型） +- 检查配置文件 `~/.everos/everos.toml`（Windows 下对应 `%USERPROFILE%\.everos\everos.toml`）是否存在且已配置有效的 `[llm]` 与 `[embedding]`； +- 若配置缺失或未填入凭据，请向我索取并引导我提供以下两组模型参数： + 1. **Extractor LLM（归纳模型）**：Base URL、API Key、Model 名称（用于对话长文提炼、规约抽取与长期画像演进）； + 2. **Embedding Model（嵌入模型）**：Base URL、API Key、Model 名称、输出维度 Dimension（用于知识库密集向量索引与语义召回）； +- 获得参数后，全自动生成并原子化写入标准的 `~/.everos/everos.toml`。 + +## 阶段三：认知后端启动与健康端点深度校验 +- 启动或确认 EverOS 服务正在运行（默认监听 `http://127.0.0.1:8000`）； +- 向 `http://127.0.0.1:8000/health` 发起探测，严格校验响应体必须同时满足： + * `healthy === true` + * `embed === true` + 确保嵌入模型与归纳推理通道均处于就绪状态。 + +## 阶段四：插件全局部署、原生 Sidecar 注册与门禁验证 +- 进入插件代码根目录，运行清单静态安全门禁： + `node scripts/check-manifests.mjs`（确认 16 项门禁 0 FAIL）； +- 执行一键全局插件安装与 Antigravity 原生 Sidecar 常驻守护注册： + `node scripts/install.mjs -g -s`（部署至 `~/.gemini/config/plugins/everos/` 并注册 `~/.gemini/config/sidecars/everos/` 守护）； +- 运行全量单元与集成测试套件验证环境兼容性： + `npm test`（确保 120 项测试全部通过）。 + +## 阶段五：交付摘要与使用指引 +- 输出格式化的部署状态看板（包含 EverOS 服务地址、双模型连通状态、插件安装目录与 Sidecar 守护路径）； +- 提示我重启或刷新 Antigravity，即可通过 `/everos status` 控制台或日常对话开始体验自进化长期认知记忆。 +```` + +--- + +## 三、 手动安装指南 + +如果您希望手动安装，请按照以下步骤操作： + +### 1. 全局安装与 Sidecar 守护注册（推荐） +在插件代码目录下执行： +```bash +# -g: 注册全局插件 (~/.gemini/config/plugins/everos) +# -s: 注册 Antigravity 原生常驻 Sidecar 守护进程 +node scripts/install.mjs -g -s +``` + +### 2. 单工作区独立挂载 +若仅希望在特定工程工作区启用记忆： +```bash +node scripts/install.mjs --workspace /path/to/your/workspace +``` +安装器会自动将钩子与 MCP 注册至目标工作区的 `.agents/hooks.json` 与 `.agents/mcp_config.json`，并安全备份已有配置（`.bak`）。 + +### 3. 一键卸载与配置回滚 +```bash +node scripts/install.mjs -g --uninstall +``` + +--- + +## 四、 核心功能与架构特性 + +``` + Google Antigravity IDE (Host) +┌───────────────────────────────────────────────┐ +│ System Context: (L1 画像) │ ─── 既定规约 & 意趣默契 (99% KV 缓存物理命中) +│ History Trajectory │ +│ Ephemeral Turn: (L2 瞬态记忆) │ ─── 曾有范例 & 交互脉络 (单轮阅后即焚，0 污染) +│ Current User Prompt │ +└───────────────────────────────────────────────┘ + ▲ + │ stdio JSON-RPC 2.0 / Hook Ingestion + ▼ +┌───────────────────────────────────────────────┐ +│ everos-antigravity (Pure ESM, Zero-Dep) │ +│ - Hook IO & Windows 11 自然排空协议 │ +│ - Detached 异步派发（SessionStart 降至 ~300ms）│ +│ - 两阶段提交 (2PC) 事务账本 (分片幂等防重发) │ +│ - Dummy Tool Synth 拓扑闭环防线 │ +│ - 原生 stdio MCP Server & 统一运维控制台 │ +└───────────────────────────────────────────────┘ + ▲ + │ HTTP REST (Loopback) + ▼ +┌───────────────────────────────────────────────┐ +│ EverOS 认知记忆后端 (:8000) │ +│ - LLM 归纳蒸馏 + 密集嵌入索引 (LanceDB) │ +└───────────────────────────────────────────────┘ +``` + +1. **纯 ESM 零运行时依赖 (Pure ESM, Zero-Dep)**： + 仅使用 Node.js `>=20.0.0` 原生标准库（`node:fs`、`node:child_process`、`node:readline`、原生 `fetch` 与 `crypto`），无需安装任何 npm 运行时依赖，开箱即跑。 +2. **Fail-Open 绝对容灾**： + 若 EverOS 离线、端口被占或网络波动，插件以毫秒级安全退出并向宿主返回 `{}`。宿主绝不报错、不卡顿、不打断开发者交互。 +3. **两阶段提交 (2PC) 事务账本**： + 本地维护精确到每会话的状态机，观察阶段（`observed_turn_index`）与结算阶段（`settled_turn_index`）解耦。针对上游 `/add` 引入客户端 `acked_chunks` 账本，网络重试时仅增量补发失败分片，彻底杜绝数据重复膨胀。 +4. **增量 Byte Offset 游标读取**： + 在 `Stop` 钩子中采用底层文件字节偏移切片读取，长会话下捕获耗时恒定在 `< 5ms`，彻底消除大文件磁盘 I/O 放大。 +5. **Windows 11 自然排空协议 (Natural Drain Protocol)**： + 强制执行 `process.exitCode = 0`，让事件循环自然完成管道排空，彻底杜绝 Windows 平台因 `process.exit(0)` 强杀引发的管道截断与空 JSON 报错。 +6. **代码泛型与正文完整性防护**： + 定向精准匹配 `` 与 `` 标签，绝不误伤用户代码中的 `Array`、JSX 标签及代码正文。 + +--- + +## 五、 四大分类锚点（中英双语自适应） + +记忆渲染引擎内置中英双语自适应锚点注册表（通过环境变量 `EVEROS_AG_LOCALE=zh` 或 `en` 切换）： + +| 数据桶 (Data Bucket) | 中文自然语言锚点 | 英文自然语言锚点 | 语义内涵与注入策略 | +|---|---|---|---| +| `explicit_info` | **【既定规约】** | **[Prescriptive Covenants]** | 开发者亲口声明的技术栈硬约束、依赖规范与架构铁律（注入 L1 Profile） | +| `implicit_traits` | **【意趣默契】** | **[Tacit Affinities]** | 模型从长期对话中观察归纳出的开发者编程品味、思维逻辑与习惯倾向（注入 L1 Profile） | +| `agent_cases` | **【曾有范例】** | **[Erstwhile Exemplars]** | 复杂的工程排错复盘、突破性攻坚案例与解决方案（PreInvocation 瞬态注入） | +| `episodes` | **【交互脉络】** | **[Interwoven Vestiges]** | 跨会话的架构演进事实、技术决策纪事与工作记忆轨迹（PreInvocation 瞬态注入） | + +--- + +## 六、 原生 MCP 工具与统一运维控制台 + +### 1. 暴露给大模型的自主工具 (MCP Tools) +- `everos_search_memory`：主动语义检索历史工程记忆； +- `everos_get_profile`：获取开发者的既定规约与意趣默契画像； +- `everos_add_memory`：显式摄入高价值技术决策或复盘； +- *(注意：严禁向模型暴露 `flush` 封箱权限，封箱权严格由生命周期与人类掌控)*。 + +### 2. 统一运维控制台命令 (`/everos`) +- **/everos status**（或直接输入 **/everos**）：打印诊断看板，查看服务连通性、当前工程 ID、用户分区与待封箱状态； +- **/everos flush**（或 **/everos-flush**）：对当前活跃会话执行两阶段提交显式封箱，安全触发后台知识萃取； +- **/everos search <关键词>**：在控制台直接执行跨会话记忆检索。 + +--- + +## 七、 环境变量配置参考 + +插件前端适配器支持通过环境变量自定义运行时参数： + +| 环境变量 | 默认值 | 作用与说明 | +|---|---|---| +| `EVEROS_AG_BASE_URL` | `http://127.0.0.1:8000` | EverOS 认知引擎的 HTTP 地址（非回环地址时会跨网络传输） | +| `EVEROS_AG_SEARCH_METHOD` | `keyword` | 默认检索策略模式 (`keyword`, `vector`, `hybrid`) | +| `EVEROS_AG_PROJECT_ID` | 根据 Git Remote 自动推导 | 规范化项目空间隔离分区 (Agent Track) | +| `EVEROS_AG_USER_ID` | 系统当前用户名 (`USERNAME`) | 开发者用户身份隔离分区 (User Track，跨工程穿透) | +| `EVEROS_AG_LOCALE` | `zh` | 语义注入锚点语种 (`zh` 中文 或 `en` 英文) | +| `EVEROS_AG_DATA_DIR` | `~/.everos/antigravity` | 本地 2PC 会话状态账本与索引存储路径 | +| `EVEROS_AG_RECALL_TIMEOUT_MS` | `5000` | 检索超时上限阈值 (500~10000ms 自动钳制) | + +--- + +## 八、 自动化验收套件与实证 + +项目内置零依赖的自动化测试矩阵与实机模拟套件： + +```bash +# 运行 16 项自动化清单门禁与 120 项单元/集成测试 +npm test + +# 运行完整宿主生命周期实机模拟套件 +npm run verify:live +``` + +测试覆盖了包括单调状态合并、分片重试账本、Windows 盘符防漂移、管道自然排空、Detached 后台派发、双轨检索防饿死等在内的全部边界场景。 + +--- + +## 开源协议 + +Apache-2.0 © 2026 Sethyrial diff --git a/antigravity/hooks.json b/antigravity/hooks.json new file mode 100644 index 0000000..0b929f3 --- /dev/null +++ b/antigravity/hooks.json @@ -0,0 +1,25 @@ +{ + "everos-antigravity": { + "SessionStart": [ + { + "type": "command", + "command": "node \"${PLUGIN_ROOT:-.}/hooks/scripts/session-start.js\"", + "timeout": 15 + } + ], + "PreInvocation": [ + { + "type": "command", + "command": "node \"${PLUGIN_ROOT:-.}/hooks/scripts/recall.js\"", + "timeout": 10 + } + ], + "Stop": [ + { + "type": "command", + "command": "node \"${PLUGIN_ROOT:-.}/hooks/scripts/capture.js\"", + "timeout": 30 + } + ] + } +} diff --git a/antigravity/hooks/scripts/capture.js b/antigravity/hooks/scripts/capture.js new file mode 100644 index 0000000..bf05def --- /dev/null +++ b/antigravity/hooks/scripts/capture.js @@ -0,0 +1,134 @@ +import { readStdinJson, writeStdoutJson, wrapHook } from "./lib/hook-io.js"; +import { loadConfig } from "./lib/config.js"; +import { resolveIdentity } from "./lib/identity.js"; +import { createClient } from "./lib/everos.js"; +import { CAPTURE_DEADLINE_MS, ADD_MAX_MESSAGES } from "./lib/constants.js"; +import { + loadSessionState, + saveSessionState, + markObserved, + markSettled, +} from "./lib/state.js"; +import { + readTranscript, + readTranscriptIncremental, + toEverosMessages, +} from "./lib/transcript.js"; + +wrapHook(async () => { + const input = readStdinJson(); + const transcriptPath = input.transcriptPath; + const conversationId = String( + input.conversationId ?? input.conversation_id ?? "default" + ).slice(0, 128); + + if (!transcriptPath) { + writeStdoutJson({}); + return; + } + + const config = loadConfig(); + const cwd = + (Array.isArray(input.workspacePaths) && input.workspacePaths[0]) || + process.cwd(); + const identity = resolveIdentity(cwd, config); + + const state = loadSessionState(config.dataDir, conversationId, { + projectId: identity.projectId, + branch: identity.branch, + userId: identity.userId, + agentId: identity.agentId, + }); + + // 1. Observe Phase: Incrementally read new transcript slice via byte offset cursor + const startOffset = + typeof state.last_read_byte_offset === "number" ? state.last_read_byte_offset : 0; + const { entries: candidateEntries, nextOffset } = readTranscriptIncremental( + transcriptPath, + startOffset + ); + + if (!candidateEntries || candidateEntries.length === 0) { + writeStdoutJson({}); + return; + } + + const settledIndex = state.settled_turn_index ?? -1; + const newEntries = candidateEntries.filter((e) => (e.step_index ?? -1) > settledIndex); + + if (newEntries.length === 0) { + writeStdoutJson({}); + return; + } + + const maxStepIndex = newEntries[newEntries.length - 1].step_index ?? -1; + markObserved(state, maxStepIndex); + saveSessionState(config.dataDir, state); + + // 2. Transform to EverOS messages (Thinking stripped, subagents reduced, FIFO paired, Dummy Tool Synth applied) + const messages = toEverosMessages(newEntries, { + userId: identity.userId, + agentId: identity.agentId, + }); + if (messages.length === 0) { + writeStdoutJson({}); + return; + } + + const client = createClient({ baseUrl: config.baseUrl }); + + // 3. 2PC Add: Ingest into EverOS (with bounded chunking <= 500 messages and chunk idempotency) + try { + const totalChunks = Math.ceil(messages.length / ADD_MAX_MESSAGES); + let startChunkIndex = 0; + + // Check if resuming an existing partially-acknowledged batch + if ( + state.pending_batch && + state.pending_batch.turn_index === maxStepIndex && + state.pending_batch.total_messages === messages.length && + typeof state.pending_batch.acked_chunks === "number" + ) { + startChunkIndex = state.pending_batch.acked_chunks; + } else { + state.pending_batch = { + turn_index: maxStepIndex, + total_messages: messages.length, + acked_chunks: 0, + }; + } + + for (let c = startChunkIndex; c < totalChunks; c++) { + const startMsg = c * ADD_MAX_MESSAGES; + const chunk = messages.slice(startMsg, startMsg + ADD_MAX_MESSAGES); + await client.add( + { + app_id: identity.appId, + session_id: conversationId, + project_id: identity.projectId, + messages: chunk, + }, + AbortSignal.timeout(CAPTURE_DEADLINE_MS) + ); + + // Record progress per chunk to ensure idempotency across retries + state.pending_batch.acked_chunks = c + 1; + saveSessionState(config.dataDir, state); + } + + // 4. 2PC Settle Phase: Advance settled_turn_index & byte offset ONLY on HTTP 200 Ack of all chunks + state.pending_batch = null; + markSettled(state, maxStepIndex); + state.last_read_byte_offset = nextOffset; + saveSessionState(config.dataDir, state); + } catch (err) { + // Nack: Keep settled_turn_index and last_read_byte_offset unadvanced so subsequent stop or sweep can retry + try { + process.stderr.write(`[capture] Ingestion deferred: ${err?.message || err}\n`); + } catch { + /* ignore */ + } + } + + writeStdoutJson({}); +}); diff --git a/antigravity/hooks/scripts/flush.js b/antigravity/hooks/scripts/flush.js new file mode 100644 index 0000000..11aa155 --- /dev/null +++ b/antigravity/hooks/scripts/flush.js @@ -0,0 +1,98 @@ +import { readStdinJson, writeStdoutJson, wrapHook } from "./lib/hook-io.js"; +import { loadConfig } from "./lib/config.js"; +import { resolveIdentity } from "./lib/identity.js"; +import { createClient } from "./lib/everos.js"; +import { FLUSH_TIMEOUT_MS } from "./lib/constants.js"; +import { + loadSessionState, + saveSessionState, + markFlushed, +} from "./lib/state.js"; + +wrapHook(async () => { + const isBackground = process.argv.includes("--background"); + const nonFlagArgs = process.argv.slice(2).filter((a) => !a.startsWith("--")); + const cliSessionId = nonFlagArgs[0]; + + const input = readStdinJson(); + const conversationId = String( + input.conversationId ?? input.conversation_id ?? cliSessionId ?? "default" + ).slice(0, 128); + + const config = loadConfig(); + const cwd = + (Array.isArray(input.workspacePaths) && input.workspacePaths[0]) || + process.cwd(); + const identity = resolveIdentity(cwd, config); + + const state = loadSessionState(config.dataDir, conversationId, { + projectId: identity.projectId, + branch: identity.branch, + userId: identity.userId, + agentId: identity.agentId, + }); + + const targetProjectId = state.project_id || identity.projectId; + + // If already flushed or permanently abandoned, avoid duplicate flush + if (state.flushed === true) { + writeStdoutJson({ + success: true, + already_flushed: true, + project_id: targetProjectId, + conversation_id: conversationId, + }); + return; + } + + if (state.flush_abandoned === true && isBackground) { + return; + } + + // Increment flush attempts + state.flush_attempts = (state.flush_attempts || 0) + 1; + saveSessionState(config.dataDir, state); + + const client = createClient({ baseUrl: config.baseUrl }); + + try { + // 2PC Settle Phase: Only mark flushed on HTTP 200 Ack + await client.flush( + { + app_id: identity.appId, + session_id: conversationId, + project_id: targetProjectId, + }, + AbortSignal.timeout(FLUSH_TIMEOUT_MS) + ); + + markFlushed(state, true); + state.flush_abandoned = false; + saveSessionState(config.dataDir, state); + + writeStdoutJson({ + success: true, + project_id: targetProjectId, + conversation_id: conversationId, + }); + } catch (err) { + // Nack: Check retry threshold (3 attempts max) + if (state.flush_attempts >= 3) { + state.flush_abandoned = true; + } + saveSessionState(config.dataDir, state); + + try { + process.stderr.write(`[flush] Flush failed: ${err?.message || err}\n`); + } catch { + /* ignore */ + } + writeStdoutJson({ + success: false, + error: err?.message || String(err), + project_id: identity.projectId, + flush_attempts: state.flush_attempts, + flush_abandoned: state.flush_abandoned, + }); + } +}); diff --git a/antigravity/hooks/scripts/lib/config.js b/antigravity/hooks/scripts/lib/config.js new file mode 100644 index 0000000..ac24909 --- /dev/null +++ b/antigravity/hooks/scripts/lib/config.js @@ -0,0 +1,230 @@ +import os from "node:os"; +import path from "node:path"; +import { + DEFAULT_BASE_URL, + RECALL_DEADLINE_MS, + RECALL_DEADLINE_MIN_MS, + RECALL_DEADLINE_MAX_MS, +} from "./constants.js"; + +/** A value that is absent or whitespace-only counts as unset and never shadows a lower layer. */ +function nonBlank(v) { + return typeof v === "string" && v.trim() !== "" ? v.trim() : undefined; +} + +/** + * Resolve one setting through multiple layers: + * 1. Primary env: EVEROS_AG_ + * 2. Secondary env: EVEROS_ANTIGRAVITY_ + * 3. Host option: ANTIGRAVITY_PLUGIN_OPTION_ + * 4. Fallback default + */ +function resolve(env, agSuffix, optionKey, fallback, sources, name) { + const agKey = `EVEROS_AG_${agSuffix}`; + const fromAg = nonBlank(env[agKey]); + if (fromAg !== undefined) { + sources[name] = "env (AG)"; + return fromAg; + } + + const antigravityKey = `EVEROS_ANTIGRAVITY_${agSuffix}`; + const fromAntigravity = nonBlank(env[antigravityKey]); + if (fromAntigravity !== undefined) { + sources[name] = "env (ANTIGRAVITY)"; + return fromAntigravity; + } + + if (optionKey) { + const fromOption = + nonBlank(env[`ANTIGRAVITY_PLUGIN_OPTION_${optionKey}`]) ?? + nonBlank(env[`CLAUDE_PLUGIN_OPTION_${optionKey}`]); + if (fromOption !== undefined) { + sources[name] = "userConfig"; + return fromOption; + } + } + + sources[name] = "default"; + return fallback; +} + +export function normalizeBaseUrl(raw) { + const candidate = nonBlank(raw); + if (candidate === undefined) return DEFAULT_BASE_URL; + const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(candidate) + ? candidate + : `http://${candidate}`; + try { + const url = new URL(withScheme); + if (url.protocol !== "http:" && url.protocol !== "https:") { + return DEFAULT_BASE_URL; + } + if (!url.origin || url.origin === "null") { + return DEFAULT_BASE_URL; + } + return url.origin; + } catch { + return DEFAULT_BASE_URL; + } +} + +export function isLoopback(baseUrl) { + try { + const host = new URL(baseUrl).hostname; + return ( + host === "127.0.0.1" || + host === "localhost" || + host === "::1" || + host === "[::1]" + ); + } catch { + return false; + } +} + +/** Minimal quote-aware argv split: e.g. `uv run "some dir/everos" server start`. */ +export function splitCommand(raw) { + const out = []; + let current = ""; + let quote = null; + let seen = false; + for (const ch of raw ?? "") { + if (quote) { + if (ch === quote) quote = null; + else current += ch; + continue; + } + if (ch === '"' || ch === "'") { + quote = ch; + seen = true; + continue; + } + if (/\s/.test(ch)) { + if (current || seen) { + out.push(current); + current = ""; + seen = false; + } + continue; + } + current += ch; + } + if (current || seen) out.push(current); + return out; +} + +/** Clamp rather than reject: a nonsense value should not disable recall. */ +function boundedInt(raw, fallback, min, max) { + const parsed = Number.parseInt(String(raw ?? "").trim(), 10); + if (!Number.isFinite(parsed)) return fallback; + return Math.min(Math.max(parsed, min), max); +} + +function truthy(v) { + return ["1", "true", "yes", "on"].includes(String(v ?? "").trim().toLowerCase()); +} + +function safeOsUser() { + try { + return os.userInfo().username; + } catch { + return undefined; + } +} + +export function loadConfig(env = process.env) { + const sources = {}; + const warnings = []; + + const rawBaseUrl = resolve(env, "BASE_URL", "BASE_URL", DEFAULT_BASE_URL, sources, "baseUrl"); + const baseUrl = normalizeBaseUrl(rawBaseUrl); + if (rawBaseUrl && rawBaseUrl !== DEFAULT_BASE_URL && baseUrl === DEFAULT_BASE_URL && rawBaseUrl !== baseUrl) { + warnings.push(`Invalid BASE_URL "${rawBaseUrl}", fallback to "${DEFAULT_BASE_URL}"`); + } + const everosDir = resolve(env, "EVEROS_DIR", "EVEROS_DIR", null, sources, "everosDir"); + const startCmdRaw = resolve( + env, + "START_CMD", + null, + "everos server start", + sources, + "startCmd" + ); + + const defaultUser = + nonBlank(env.USER) ?? nonBlank(env.USERNAME) ?? nonBlank(safeOsUser()) ?? null; + const userId = resolve(env, "USER_ID", null, defaultUser, sources, "userId"); + + const home = + nonBlank(env.HOME) ?? nonBlank(env.USERPROFILE) ?? os.homedir(); + const defaultDataDir = + nonBlank(env.ANTIGRAVITY_PLUGIN_DATA) ?? + nonBlank(env.CLAUDE_PLUGIN_DATA) ?? + path.join(home, ".everos", ".antigravity"); + const dataDir = resolve(env, "DATA_DIR", null, defaultDataDir, sources, "dataDir"); + + const recallTimeoutRaw = + nonBlank(env.EVEROS_AG_RECALL_TIMEOUT_MS) ?? + nonBlank(env.EVEROS_ANTIGRAVITY_RECALL_TIMEOUT_MS); + + const searchMethod = resolve( + env, + "SEARCH_METHOD", + "SEARCH_METHOD", + "keyword", + sources, + "searchMethod" + ); + + const verboseRaw = + env.EVEROS_AG_VERBOSE ?? env.EVEROS_ANTIGRAVITY_VERBOSE; + const debugRaw = + env.EVEROS_AG_DEBUG ?? env.EVEROS_ANTIGRAVITY_DEBUG; + + // Language / Locale resolution: + // Priority: EVEROS_AG_LOCALE -> EVEROS_AG_LANGUAGE -> EVEROS_ANTIGRAVITY_* -> Host Option -> zh + const localeFromEnv = + nonBlank(env.EVEROS_AG_LOCALE) ?? + nonBlank(env.EVEROS_AG_LANGUAGE) ?? + nonBlank(env.EVEROS_ANTIGRAVITY_LOCALE) ?? + nonBlank(env.EVEROS_ANTIGRAVITY_LANGUAGE); + + const localeFromOption = + nonBlank(env.ANTIGRAVITY_PLUGIN_OPTION_LOCALE) ?? + nonBlank(env.ANTIGRAVITY_PLUGIN_OPTION_LANGUAGE) ?? + nonBlank(env.CLAUDE_PLUGIN_OPTION_LOCALE); + + let locale = "zh"; + if (localeFromEnv) { + const normalized = localeFromEnv.trim().toLowerCase(); + locale = ["en", "english"].includes(normalized) ? "en" : "zh"; + sources.locale = "env"; + } else if (localeFromOption) { + const normalized = localeFromOption.trim().toLowerCase(); + locale = ["en", "english"].includes(normalized) ? "en" : "zh"; + sources.locale = "userConfig"; + } else { + sources.locale = "default"; + } + + return { + baseUrl, + everosDir, + startCmd: splitCommand(startCmdRaw), + userId, + projectIdOverride: resolve(env, "PROJECT_ID", null, null, sources, "projectIdOverride"), + recallTimeoutMs: boundedInt( + recallTimeoutRaw, + RECALL_DEADLINE_MS, + RECALL_DEADLINE_MIN_MS, + RECALL_DEADLINE_MAX_MS + ), + verbose: truthy(verboseRaw), + debug: truthy(debugRaw), + dataDir, + locale, + searchMethod, + sources, + warnings, + }; +} diff --git a/antigravity/hooks/scripts/lib/constants.js b/antigravity/hooks/scripts/lib/constants.js new file mode 100644 index 0000000..a3ae4b8 --- /dev/null +++ b/antigravity/hooks/scripts/lib/constants.js @@ -0,0 +1,53 @@ +/** Every tunable in one place. Nothing here is user-configurable; see lib/config.js for what is. */ + +/** Cross-host partition on the EverOS side. One EverOS serves OpenClaw, Hermes, Claude Code, Codex, and us. */ +export const APP_ID = "antigravity"; +/** Agent-track identity. Cases and skills land under agents//. */ +export const AGENT_ID = "antigravity"; + +export const DEFAULT_BASE_URL = "http://127.0.0.1:8000"; + +export const HEALTH_TIMEOUT_MS = 2000; +export const START_WAIT_MS = 5000; +export const START_POLL_MS = 500; + +/** + * Recall budget. A warm search is 0.3-0.8s; what it buys is the tail. + * Two of the first live sessions might lose their opening recall to a tight budget. + * Clamped between 500ms and 7000ms. Override with EVEROS_AG_RECALL_TIMEOUT_MS. + */ +export const RECALL_DEADLINE_MS = 5000; +export const RECALL_DEADLINE_MIN_MS = 500; +export const RECALL_DEADLINE_MAX_MS = 7000; +export const CAPTURE_DEADLINE_MS = 20000; + +/** + * Timeout budget for synchronous flush requests to complete LLM extraction. + * In background detached mode, this timeout provides ample room (120s) for + * full Episode extraction and Markdown persistence. + */ +export const FLUSH_TIMEOUT_MS = 120000; +export const FLUSH_DISPATCH_MS = FLUSH_TIMEOUT_MS; + +/** + * Max items per section in the injected ephemeral block. + * L2 ephemeral recall injects Top-3 memories to prevent context bloat. + */ +export const SECTION_MAX_ITEMS = 3; + +export const ID_MAX_LEN = 128; +export const ADD_MAX_MESSAGES = 500; +export const TOOL_RESULT_MAX_CHARS = 20000; +export const QUERY_MAX_CHARS = 500; +export const MIN_QUERY_TOKENS = 3; + +export const STATE_MAX_PROMPT_IDS = 200; +export const STATE_TTL_DAYS = 30; +export const STALE_SWEEP_MINUTES = 30; + +export const TRANSCRIPT_READ_ATTEMPTS = 10; +export const TRANSCRIPT_READ_DELAY_MS = 200; + +/** Windows NTFS resilience: retry on EBUSY/EPERM with backoff. */ +export const NTFS_RETRY_COUNT = 3; +export const NTFS_RETRY_DELAY_MS = 10; diff --git a/antigravity/hooks/scripts/lib/everos.js b/antigravity/hooks/scripts/lib/everos.js new file mode 100644 index 0000000..9ab7083 --- /dev/null +++ b/antigravity/hooks/scripts/lib/everos.js @@ -0,0 +1,150 @@ +/** + * Minimal client for the EverOS v2 memory API. Native fetch, no dependencies. + * + * Success envelope: { request_id, data } + * Error envelope: { request_id, error: { code, message, timestamp, path } } + */ + +export class EverosError extends Error { + constructor(status, code, message, path) { + super(message); + this.name = "EverosError"; + this.status = status; + this.code = code; + this.path = path; + } +} + +/** One signal, shared by every request that must finish inside the same budget. */ +export function deadline(ms) { + return AbortSignal.timeout(ms); +} + +export function createClient({ baseUrl, fetchImpl = fetch }) { + const cleanBaseUrl = (baseUrl || "").replace(/\/+$/, ""); + + async function call(method, path, body, signal) { + let res; + try { + res = await fetchImpl(`${cleanBaseUrl}${path}`, { + method, + signal, + headers: { + accept: "application/json", + "user-agent": "EverOS-Plugin-Antigravity/0.1.0", + ...(body === undefined ? {} : { "content-type": "application/json" }), + }, + body: body === undefined ? undefined : JSON.stringify(body), + }); + } catch (cause) { + // TIMEOUT indicates client deadline exceeded (server may or may not have received request); + // NETWORK_ERROR indicates immediate socket connection failure or host refusal. + const timedOut = + cause?.name === "TimeoutError" || + cause?.name === "AbortError" || + signal?.aborted; + throw new EverosError( + 0, + timedOut ? "TIMEOUT" : "NETWORK_ERROR", + `${method} ${path} failed: ${timedOut ? "deadline exceeded" : String(cause?.message ?? cause)}`, + path, + ); + } + + let parsed; + try { + parsed = await res.json(); + } catch (cause) { + const timedOut = + cause?.name === "TimeoutError" || + cause?.name === "AbortError" || + signal?.aborted; + if (timedOut) { + throw new EverosError( + 0, + "TIMEOUT", + `${method} ${path} failed: response body read timed out`, + path, + ); + } + throw new EverosError( + res.status, + undefined, + `${method} ${path}: non-JSON response (HTTP ${res.status})`, + path, + ); + } + + if (res.ok && parsed && typeof parsed === "object" && "data" in parsed) { + return parsed.data; + } + + const err = parsed?.error; + if (err) { + throw new EverosError(res.status, err.code, err.message ?? `${path} failed`, err.path ?? path); + } + throw new EverosError(res.status, undefined, `${path}: unexpected response (HTTP ${res.status})`, path); + } + + return { + async health(signal) { + let res; + try { + res = await fetchImpl(`${cleanBaseUrl}/health`, { + method: "GET", + signal, + headers: { accept: "application/json" }, + }); + } catch (cause) { + const timedOut = + cause?.name === "TimeoutError" || + cause?.name === "AbortError" || + signal?.aborted; + throw new EverosError( + 0, + timedOut ? "TIMEOUT" : "NETWORK_ERROR", + `GET /health failed: ${timedOut ? "deadline exceeded" : String(cause?.message ?? cause)}`, + "/health", + ); + } + + // /health is unversioned and returns a bare body, not the {data} envelope. + let parsed; + try { + parsed = await res.json(); + } catch (cause) { + const timedOut = + cause?.name === "TimeoutError" || + cause?.name === "AbortError" || + signal?.aborted; + if (timedOut) { + throw new EverosError( + 0, + "TIMEOUT", + "GET /health failed: response body read timed out", + "/health", + ); + } + throw new EverosError( + res.status, + undefined, + `/health: non-JSON response (HTTP ${res.status})`, + "/health", + ); + } + if (!res.ok) { + throw new EverosError(res.status, parsed?.error?.code, "/health not ok", "/health"); + } + return parsed; + }, + search(body, signal) { + return call("POST", "/api/v2/memory/search", body, signal); + }, + add(body, signal) { + return call("POST", "/api/v2/memory/add", body, signal); + }, + flush(body, signal) { + return call("POST", "/api/v2/memory/flush", body, signal); + }, + }; +} diff --git a/antigravity/hooks/scripts/lib/hook-io.js b/antigravity/hooks/scripts/lib/hook-io.js new file mode 100644 index 0000000..b7efc31 --- /dev/null +++ b/antigravity/hooks/scripts/lib/hook-io.js @@ -0,0 +1,106 @@ +import fs from "node:fs"; + +let hasStdoutWritten = false; + +/** + * Reset stdout written tracking state (for unit testing). + */ +export function resetHookIoState() { + hasStdoutWritten = false; +} + +/** + * Read JSON synchronously from process.stdin (file descriptor 0). + * Fail-open: returns {} if stdin is empty, TTY, malformed, or unreadable. + * + * @returns {Record} + */ +export function readStdinJson() { + try { + if (process.stdin.isTTY) { + return {}; + } + const raw = fs.readFileSync(0, { encoding: "utf8" }); + const clean = (raw && raw.charCodeAt(0) === 0xFEFF ? raw.slice(1) : raw) || ""; + if (!clean.trim()) { + return {}; + } + const parsed = JSON.parse(clean); + return parsed && typeof parsed === "object" ? parsed : {}; + } catch (err) { + try { + process.stderr.write(`[hook-io] readStdinJson warning: ${err?.message || err}\n`); + } catch { + /* ignore */ + } + return {}; + } +} + +/** + * Write a JSON object to process.stdout followed by a newline. + * + * @param {unknown} payload + */ +export function writeStdoutJson(payload) { + try { + const json = JSON.stringify(payload ?? {}); + process.stdout.write(json + "\n", "utf8"); + hasStdoutWritten = true; + } catch (err) { + try { + process.stderr.write(`[hook-io] writeStdoutJson error: ${err?.message || err}\n`); + } catch { + /* ignore */ + } + } +} + +/** + * Windows 11 Natural Drain Exit Protocol: + * Never call process.exit() directly as it abruptly truncates stdout on Windows. + * Assigning process.exitCode allows Node.js event loop to flush streams naturally. + * + * @param {number} [code=0] + */ +export function safeExit(code = 0) { + process.exitCode = code; +} + +/** + * Top-level fail-open wrapper for hook execution scripts. + * Catches any unhandled rejections or exceptions, logs diagnostics to stderr, + * outputs an empty JSON object to stdout (if not already written), and safely exits with code 0. + * + * @param {() => Promise | void} hookFn + * @returns {Promise} + */ +export async function wrapHook(hookFn) { + const emergencyFailOpen = (reason, source) => { + try { + process.stderr.write(`[hook] Fatal uncaught ${source}: ${reason?.stack || reason?.message || String(reason)}\n`); + } catch { + /* ignore */ + } + if (!hasStdoutWritten) { + writeStdoutJson({}); + } + safeExit(0); + }; + + const onUnhandledRejection = (reason) => emergencyFailOpen(reason, "unhandledRejection"); + const onUncaughtException = (err) => emergencyFailOpen(err, "uncaughtException"); + + process.once("unhandledRejection", onUnhandledRejection); + process.once("uncaughtException", onUncaughtException); + + try { + await hookFn(); + safeExit(process.exitCode ?? 0); + } catch (err) { + emergencyFailOpen(err, "error"); + } finally { + process.removeListener("unhandledRejection", onUnhandledRejection); + process.removeListener("uncaughtException", onUncaughtException); + } +} diff --git a/antigravity/hooks/scripts/lib/identity.js b/antigravity/hooks/scripts/lib/identity.js new file mode 100644 index 0000000..7837d28 --- /dev/null +++ b/antigravity/hooks/scripts/lib/identity.js @@ -0,0 +1,189 @@ +import { createHash } from "node:crypto"; +import { execFileSync } from "node:child_process"; +import { APP_ID, AGENT_ID, ID_MAX_LEN } from "./constants.js"; + +const PATH_SAFE = /[^A-Za-z0-9_.@+-]/g; + +/** + * EverOS turns app_id / project_id / sender_id into directory segments, so it + * enforces a charset whitelist and rejects "." and "..". Mirror that here - a + * rejected id would fail the whole /add with a 422. + */ +export function sanitizeId(raw, fallback) { + if (typeof raw !== "string") return fallback; + const trimmed = raw.trim(); + const cleaned = trimmed.replace(PATH_SAFE, "_").slice(0, ID_MAX_LEN); + if (cleaned === "" || cleaned === "." || cleaned === "..") return fallback; + + // Sanitizing can erase distinct names: e.g. 项目 becomes "__", and so does 测试. + // Whenever a character was actually lost outside the whitelist, keep the readable + // part and append a short digest of the original so distinct partitions stay distinct. + if (cleaned !== trimmed) { + const digest = createHash("sha256").update(trimmed).digest("hex").slice(0, 8); + const maxPrefixLen = ID_MAX_LEN - digest.length - 1; + return `${cleaned.slice(0, maxPrefixLen)}_${digest}`; + } + return cleaned; +} + +/** + * Sanitize branch string: prevent control character and tag injection, limit length. + * Strips `<` and `>` to avoid breaking XML tags in prompt injection (). + */ +export function sanitizeBranch(raw, fallback = "unknown") { + if (typeof raw !== "string") return fallback; + const cleaned = raw.replace(/[<>]/g, "").replace(/[\r\n\t]/g, " ").trim(); + if (!cleaned) return fallback; + if (cleaned === "HEAD") return "detached"; + return cleaned.slice(0, ID_MAX_LEN); +} + +/** Run a git subcommand, returning trimmed stdout or null. Never throws. */ +function defaultGitRunner(args, cwd, timeout = 1000) { + try { + const out = execFileSync("git", ["-C", cwd, ...args], { + encoding: "utf8", + timeout: Math.min(Math.max(Number(timeout) || 1000, 100), 1000), + stdio: ["ignore", "pipe", "ignore"], + }); + const trimmed = out.trim(); + return trimmed === "" ? null : trimmed; + } catch { + return null; + } +} + +/** + * Turn a git remote URL into host + owner + repo. + * Host is case-folded to lowercase to prevent DNS casing partition splits. + * Explicit ports (e.g. :2222 or :8080) are safely stripped so host is never lost. + */ +function repoNameFromRemote(url) { + const trimmed = url.trim().replace(/\.git\/?$/, ""); + if (!trimmed) return null; + + // 1. Try standard URL with scheme (e.g. ssh://git@gitlab.com:2222/org/repo, https://github.com/a/b) + if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) { + try { + const parsed = new URL(trimmed); + const host = (parsed.hostname || "").toLowerCase(); + const segments = parsed.pathname.split("/").filter(Boolean); + if (segments.length === 0) return host || null; + const tail = segments.slice(-2); + return host ? [host, ...tail].join("_") : tail.join("_"); + } catch {} + } + + // 2. SCP-like syntax: [user@]host:path or [user@]host:port/path + const withoutUser = trimmed.replace(/^[^/@]+@/, ""); + if (withoutUser.includes(":")) { + const colonIdx = withoutUser.indexOf(":"); + let host = withoutUser.slice(0, colonIdx).toLowerCase(); + let rest = withoutUser.slice(colonIdx + 1); + const segments = rest.split("/").filter(Boolean); + // If the segment immediately following colon is purely digits (port), strip it + if (segments.length > 1 && /^\d+$/.test(segments[0])) { + segments.shift(); + } + const tail = segments.slice(-2); + return host ? [host, ...tail].join("_") : tail.join("_"); + } + + // 3. Fallback for bare paths like /srv/git/bare-repo + const segments = withoutUser.split("/").filter(Boolean); + if (segments.length === 0) return null; + const tail = segments.slice(-3); + if (tail.length === 3) tail[0] = tail[0].toLowerCase(); + return tail.join("_"); +} + +/** + * Extract directory basename and normalize Windows path case to avoid drift + * (e.g., C:\Project vs c:\project or /c/Project). + */ +function extractLocalBasename(rawPath) { + if (!rawPath || typeof rawPath !== "string") return ""; + const normalized = rawPath.replace(/[\\/]+$/, ""); + const segments = normalized.split(/[\\/]/).filter(Boolean); + const base = segments.pop() || ""; + // Check if Windows platform or Windows path (drive letter) + const isWindows = + process.platform === "win32" || + /^[a-zA-Z]:[\\/]/.test(rawPath); + return isWindows ? base.toLowerCase() : base; +} + +/** + * Resolve current git branch name. Returns "unknown" or "detached" if unavailable. + */ +export function resolveBranch(cwd, gitRunner = defaultGitRunner) { + const current = gitRunner(["branch", "--show-current"], cwd); + if (current) return sanitizeBranch(current); + + const rev = gitRunner(["rev-parse", "--abbrev-ref", "HEAD"], cwd); + if (rev && rev !== "HEAD") return sanitizeBranch(rev); + if (rev === "HEAD") return "detached"; + + return "unknown"; +} + +/** + * Project partition resolver. + * Priority: + * 1. projectIdOverride + * 2. remote.origin.url (host_owner_repo, host lowercased, ports stripped) + * 3. git rev-parse --show-toplevel (basename, Windows path case normalized) + * 4. cwd basename (Windows path case normalized) + */ +export function resolveProjectId(cwd, config = {}, gitRunner = defaultGitRunner) { + if (config.projectIdOverride) return sanitizeId(config.projectIdOverride, "default"); + + const remote = gitRunner(["config", "--get", "remote.origin.url"], cwd); + if (remote) { + const name = repoNameFromRemote(remote); + if (name) return sanitizeId(name, "default"); + } + + const toplevel = gitRunner(["rev-parse", "--show-toplevel"], cwd); + if (toplevel) return sanitizeId(extractLocalBasename(toplevel), "default"); + + return sanitizeId(extractLocalBasename(cwd), "default"); +} + +export function resolveIdentity(cwdOrOptions, maybeConfig = {}, gitRunner = defaultGitRunner) { + let cwd = cwdOrOptions; + let config = maybeConfig; + if (cwdOrOptions && typeof cwdOrOptions === "object" && !Array.isArray(cwdOrOptions)) { + cwd = + cwdOrOptions.cwd || + (Array.isArray(cwdOrOptions.workspacePaths) ? cwdOrOptions.workspacePaths[0] : null) || + process.cwd(); + config = { + ...maybeConfig, + projectIdOverride: + cwdOrOptions.projectIdOverride ?? + cwdOrOptions.config?.projectIdOverride ?? + maybeConfig.projectIdOverride, + userId: + cwdOrOptions.userId ?? + cwdOrOptions.config?.userId ?? + maybeConfig.userId, + }; + } + + const startTime = Date.now(); + const maxGitBudgetMs = 1500; + const boundedGitRunner = (args, targetCwd) => { + const remaining = maxGitBudgetMs - (Date.now() - startTime); + if (remaining <= 50) return null; + return gitRunner(args, targetCwd, remaining); + }; + + return { + appId: APP_ID, + projectId: resolveProjectId(cwd, config, boundedGitRunner), + branch: resolveBranch(cwd, boundedGitRunner), + userId: config.userId ? sanitizeId(config.userId, "default") : null, + agentId: AGENT_ID, + }; +} diff --git a/antigravity/hooks/scripts/lib/provision.js b/antigravity/hooks/scripts/lib/provision.js new file mode 100644 index 0000000..2024604 --- /dev/null +++ b/antigravity/hooks/scripts/lib/provision.js @@ -0,0 +1,120 @@ +import { spawn } from "node:child_process"; +import { createClient } from "./everos.js"; +import { isLoopback } from "./config.js"; +import { HEALTH_TIMEOUT_MS, START_WAIT_MS, START_POLL_MS } from "./constants.js"; + +let lastSpawnTime = 0; + +/** + * Reset spawn throttling timestamp (primarily for tests). + */ +export function resetSpawnThrottle() { + lastSpawnTime = 0; +} + +/** + * Ensure EverOS server is healthy and running. + * If unreachable on loopback, attempts detached background auto-spawn, + * then polls /health until ready or timed out. + * + * Strict fail-open: never throws unhandled errors. + * + * @param {Record} config + * @param {object} [options] + * @param {object} [options.client] + * @param {typeof spawn} [options.spawnImpl=spawn] + * @param {number} [options.waitMs=1500] + * @param {number} [options.retries=3] + * @param {number} [options.retryDelayMs=300] + * @param {number} [options.throttleMs=15000] + * @returns {Promise<{ ok: boolean, spawned: boolean, reason?: string, error?: string }>} + */ +export async function ensureServerRunning(config, options = {}) { + const { + client = createClient({ baseUrl: config.baseUrl }), + spawnImpl = spawn, + waitMs = HEALTH_TIMEOUT_MS, + retries = 3, + retryDelayMs = START_POLL_MS, + throttleMs = 15000, + } = options; + + // 1. Initial health check + try { + const health = await client.health(AbortSignal.timeout(waitMs)); + const isHealthy = + health && + health.healthy !== false && + health.status !== "unhealthy" && + health.cascade?.healthy !== false; + + if (!isHealthy) { + return { ok: false, spawned: false, reason: "unhealthy" }; + } + return { ok: true, spawned: false }; + } catch { + // Service offline or pending + } + + // 2. Check if auto-spawn is appropriate + const canSpawn = + isLoopback(config.baseUrl) && + Array.isArray(config.startCmd) && + config.startCmd.length > 0; + + if (!canSpawn) { + return { ok: false, spawned: false, reason: "server_offline" }; + } + + // 3. Throttle spawn attempts to prevent fork storms + const now = Date.now(); + if (now - lastSpawnTime < throttleMs) { + return { ok: false, spawned: false, reason: "throttled" }; + } + lastSpawnTime = now; + + // 4. Detached background spawn (shell: false prevents cmd injection & quote stripping) + try { + const [cmd, ...args] = config.startCmd; + const child = spawnImpl(cmd, args, { + detached: true, + stdio: "ignore", + windowsHide: true, + cwd: config.everosDir || undefined, + shell: false, + }); + if (typeof child?.on === "function") { + child.on("error", () => {}); + } + if (typeof child?.unref === "function") { + child.unref(); + } + } catch (spawnErr) { + try { + process.stderr.write(`[provision] spawn error: ${spawnErr?.message || spawnErr}\n`); + } catch { + /* ignore */ + } + return { ok: false, spawned: false, error: spawnErr?.message || String(spawnErr) }; + } + + // 5. Gentle polling + for (let i = 0; i < retries; i++) { + await new Promise((r) => setTimeout(r, retryDelayMs)); + try { + const health = await client.health(AbortSignal.timeout(waitMs)); + const isHealthy = + health && + health.healthy !== false && + health.status !== "unhealthy" && + health.cascade?.healthy !== false; + if (isHealthy) { + return { ok: true, spawned: true }; + } + } catch { + // Continue next attempt + } + } + + return { ok: false, spawned: true, error: "timeout" }; +} diff --git a/antigravity/hooks/scripts/lib/query.js b/antigravity/hooks/scripts/lib/query.js new file mode 100644 index 0000000..ac711d0 --- /dev/null +++ b/antigravity/hooks/scripts/lib/query.js @@ -0,0 +1,70 @@ +import { QUERY_MAX_CHARS, MIN_QUERY_TOKENS } from "./constants.js"; + +/** Tags whose inner content AND brackets should be completely discarded. */ +const NOISE_TAGS = [ + "ADDITIONAL_METADATA", + "USER_SETTINGS_CHANGE", + "system-reminder", + "ide_selection", + "command-name", + "command-message", + "command-args", + "local-command-stdout", + "local-command-caveat", + "everos_memory", + "everos_profile", + "attachment", + "function_results", + "tool_result", + "task-notification", + "ide_opened_file", +]; + +const PAIRED_NOISE = new RegExp(`<(${NOISE_TAGS.join("|")})\\b[^>]*>[\\s\\S]*?<\\/\\1>`, "gi"); +const STRAY_NOISE = new RegExp(`<\\/?(${NOISE_TAGS.join("|")})\\b[^>]*>`, "gi"); +const FENCED_CODE = /```[\s\S]*?```/g; +const LONG_RUN = /\S{400,}/g; + +/** Unicode CJK range pattern for token estimation without space requirement. */ +const CJK = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]/g; + +/** CJK characters have no spaces, so count individual CJK glyphs plus Latin word tokens. */ +export function countTokens(s) { + const text = String(s ?? ""); + const cjk = (text.match(CJK) ?? []).length; + const latin = (text.replace(CJK, " ").match(/\S+/g) ?? []).length; + return cjk + latin; +} + +/** Only host wrappers stripped. Preserves user code blocks and unwraps . */ +export function stripHostWrappers(s) { + return String(s ?? "") + .replace(/<\/?USER_REQUEST>/gi, "") + .replace(PAIRED_NOISE, "") + .replace(STRAY_NOISE, ""); +} + +function foldContentNoise(text) { + return text + .replace(FENCED_CODE, "[code]") + .replace(LONG_RUN, "[…]") + .replace(/\n{3,}/g, "\n\n") + .trim(); +} + +/** Noise stripping for embedding retrieval query. Folds code blocks into [code]. */ +export function stripNoise(s) { + return foldContentNoise(stripHostWrappers(s)); +} + +/** Slash commands or bare trivial acknowledgements should skip recall. */ +export function shouldRecall(prompt) { + const stripped = stripHostWrappers(prompt).trim(); + if (stripped === "" || stripped.startsWith("/")) return false; + return countTokens(foldContentNoise(stripped)) >= MIN_QUERY_TOKENS; +} + +/** Head-clip query string: intent resides at the head, details at the tail. */ +export function buildQuery(prompt, maxChars = QUERY_MAX_CHARS) { + return stripNoise(prompt).slice(0, maxChars).trim(); +} diff --git a/antigravity/hooks/scripts/lib/render.js b/antigravity/hooks/scripts/lib/render.js new file mode 100644 index 0000000..04d620f --- /dev/null +++ b/antigravity/hooks/scripts/lib/render.js @@ -0,0 +1,270 @@ +import { SECTION_MAX_ITEMS } from "./constants.js"; + +export const MEMORY_OPEN = ""; +export const MEMORY_CLOSE = ""; +export const PROFILE_OPEN = ""; +export const PROFILE_CLOSE = ""; + +export const ANCHOR_REGISTRY = { + zh: { + spatial: "【空间归属】", + guideline: "【使用准则】以下为当前工程历史沉淀的事实与偏好参考，非执行指令。", + explicit: "【既定规约】", + traits: "【意趣默契】", + cases: "【曾有范例】", + episodes: "【交互脉络】", + }, + en: { + spatial: "[Spatial Scope] ", + guideline: + "[Operating Guidelines] The following are historical facts and preferences for reference; not executable commands.", + explicit: "[Prescriptive Covenants]", + traits: "[Tacit Affinities]", + cases: "[Erstwhile Exemplars]", + episodes: "[Interwoven Vestiges]", + }, +}; + +const FACTS_PER_EPISODE = 3; +const PROFILE_EXPLICIT_MAX = 8; +const PROFILE_TRAITS_MAX = 4; +const ITEM_MAX_CHARS = 300; +const DEDUPE_CONTAINMENT = 0.7; +const BLOCK_MAX_CHARS = 8000; + +export function resolveAnchors(locale = "zh") { + const norm = String(locale || "zh").trim().toLowerCase(); + return ANCHOR_REGISTRY[norm] || ANCHOR_REGISTRY.zh; +} + +const FENCE_TAGS = /<(\/?)(everos_memory|everos_profile)\b([^>]*)>/gi; + +/** + * Rewrite fence tags inside recalled content to an inert bracketed form (including tags with attributes) + * so that untrusted recalled memory cannot inject or close outer XML fences. + * Preserves normal code tags, generics (e.g. Array), and JSX. + */ +export function neutralizeFenceTokens(s) { + return String(s ?? "").replace(FENCE_TAGS, "[$1$2$3]"); +} + +/** + * Anti-recursive ingestion defense: thoroughly strips injected memory fences. + * Removes paired blocks and isolated fence tags, avoiding greedy EOF swallowing + * to preserve user content integrity. + */ +export function stripInjectedMemory(text) { + return String(text ?? "") + .replace(/]*>[\s\S]*?<\/everos_memory>/gi, "") + .replace(/]*>[\s\S]*?<\/everos_profile>/gi, "") + .replace(/<\/?(everos_memory|everos_profile)\b[^>]*>/gi, "") + .replace(/\n{3,}/g, "\n\n") + .trim(); +} + +function oneLine(s, max = ITEM_MAX_CHARS) { + const flat = neutralizeFenceTokens(String(s ?? "").replace(/\s+/g, " ").trim()); + return flat.length > max ? `${flat.slice(0, max - 1).trimEnd()}…` : flat; +} + +function joinDash(...parts) { + return parts.map((part) => oneLine(part)).filter(Boolean).join(" — "); +} + +/** Extract meaningful tokens for deduplication. */ +function meaningfulTokens(line) { + const text = line.replace(/^[-\s·*#]+/, "").toLowerCase(); + const cjk = text.match(/[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]/g) ?? []; + const latin = text.replace(/[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]/g, " ").match(/\b[a-z0-9_-]{3,}\b/g) ?? []; + return new Set([...cjk, ...latin]); +} + +/** Containment ratio check: checks if line content is already mostly covered by previous lines. */ +function saysNothingNew(line, seenSets) { + const tokens = meaningfulTokens(line); + if (tokens.size === 0) return true; + for (const seen of seenSets) { + if (seen.size === 0) continue; + let shared = 0; + for (const t of tokens) { + if (seen.has(t)) shared += 1; + } + if (shared / tokens.size >= DEDUPE_CONTAINMENT) return true; + } + return false; +} + +function profileFactLine(key, value) { + if (value && typeof value === "object" && !Array.isArray(value)) { + const label = oneLine(value.category ?? value.key ?? value.name ?? value.field); + const body = oneLine(value.description ?? value.value ?? value.content ?? value.statement ?? value.text); + if (label && body) return `- [${label}] ${body}`; + if (body) return `- ${body}`; + if (label) return `- ${label}`; + return null; + } + const rendered = oneLine(Array.isArray(value) ? value.join(", ") : value); + if (!rendered) return null; + const label = oneLine(key); + return /^\d+$/.test(label) ? `- ${rendered}` : `- ${label}: ${rendered}`; +} + +export function renderProfileSections(profileItem, anchors) { + const data = profileItem?.profile_data ?? profileItem ?? {}; + const sections = []; + + // Explicit info -> Prescriptive Covenants + const explicitLines = []; + const explicit = data.explicit_info; + if (explicit && typeof explicit === "object") { + const entries = Array.isArray(explicit) + ? explicit.map((v, i) => [String(i), v]) + : Object.entries(explicit); + for (const [key, value] of entries.slice(0, PROFILE_EXPLICIT_MAX)) { + const line = profileFactLine(key, value); + if (line) explicitLines.push(line); + } + } + if (explicitLines.length > 0) { + sections.push(`${anchors.explicit}\n${explicitLines.join("\n")}`); + } + + // Implicit traits -> Tacit Affinities + const traitLines = []; + const rawTraits = Array.isArray(data.implicit_traits) + ? data.implicit_traits + : data.implicit_traits && typeof data.implicit_traits === "object" + ? Object.values(data.implicit_traits) + : []; + for (const trait of rawTraits.slice(0, PROFILE_TRAITS_MAX)) { + const traitName = trait?.trait ?? trait?.name ?? trait?.title; + const traitDesc = trait?.description ?? trait?.content ?? trait?.statement ?? trait?.text; + let rawText = typeof trait === "string" ? trait : null; + if (!rawText) { + if (traitName && traitDesc) rawText = `${traitName}: ${traitDesc}`; + else rawText = traitDesc || traitName; + } + const rendered = oneLine(rawText); + if (rendered) traitLines.push(`- ${rendered}`); + } + if (traitLines.length > 0) { + sections.push(`${anchors.traits}\n${traitLines.join("\n")}`); + } + + return sections; +} + +function renderEpisode(item, seen) { + const head = joinDash(item.subject, item.summary) || oneLine(item.episode); + if (!head) return null; + const facts = []; + for (const fact of item.atomic_facts ?? []) { + if (facts.length >= FACTS_PER_EPISODE) break; + const raw = typeof fact === "string" ? fact : fact?.content ?? fact?.statement ?? fact?.text ?? fact?.fact; + const text = oneLine(raw); + if (!text || saysNothingNew(text, seen)) continue; + seen.push(meaningfulTokens(text)); + facts.push(` · ${text}`); + } + return [`- ${head}`, ...facts].join("\n"); +} + +function renderCase(item) { + const head = oneLine(item.task_intent); + if (!head) return null; + const insight = oneLine(item.key_insight); + return insight ? `- ${head}\n · ${insight}` : `- ${head}`; +} + +function buildHeader(anchors, config) { + const spatialPrefix = anchors.spatial.endsWith(" ") || anchors.spatial.endsWith("】") + ? anchors.spatial + : anchors.spatial + " "; + return [ + `${spatialPrefix}project_id: ${config.projectId || "default"} | branch: ${config.branch || "main"}`, + anchors.guideline, + ].join("\n"); +} + +function clampBlockLength(block, maxChars = BLOCK_MAX_CHARS) { + if (block.length <= maxChars) return block; + const lines = block.split("\n"); + while (lines.join("\n").length > maxChars && lines.length > 5) { + lines.splice(-2, 1); + } + return lines.join("\n"); +} + +/** + * Render L1 persistent Profile Block. + */ +export function renderProfileBlock(profileItem, config = {}) { + const anchors = resolveAnchors(config.locale); + const sections = renderProfileSections(profileItem, anchors); + if (sections.length === 0) return null; + + const header = buildHeader(anchors, config); + const fullBlock = [ + PROFILE_OPEN, + header, + "", + sections.join("\n\n"), + PROFILE_CLOSE, + ].join("\n"); + + return clampBlockLength(fullBlock); +} + +/** + * Render L2 ephemeral Memory Block. + */ +export function renderMemoryBlock(searchResult = {}, config = {}) { + const anchors = resolveAnchors(config.locale); + const seenTokens = []; + const sections = []; + + // 1. Profile sections if included + const profileList = Array.isArray(searchResult.profiles) + ? searchResult.profiles + : searchResult.profile + ? [searchResult.profile] + : []; + if (profileList.length > 0) { + const pSections = renderProfileSections(profileList[0], anchors); + for (const sec of pSections) sections.push(sec); + } + + // 2. Cases -> Erstwhile Exemplars (Top 3) + const caseLines = []; + const cases = Array.isArray(searchResult.agent_cases) + ? searchResult.agent_cases + : Array.isArray(searchResult.cases) + ? searchResult.cases + : []; + for (const item of cases.slice(0, SECTION_MAX_ITEMS)) { + const rendered = renderCase(item); + if (rendered) caseLines.push(rendered); + } + if (caseLines.length > 0) { + sections.push(`${anchors.cases}\n${caseLines.join("\n")}`); + } + + // 3. Episodes -> Interwoven Vestiges (Top 3) + const episodeLines = []; + const episodes = Array.isArray(searchResult.episodes) ? searchResult.episodes : []; + for (const item of episodes.slice(0, SECTION_MAX_ITEMS)) { + const rendered = renderEpisode(item, seenTokens); + if (rendered) episodeLines.push(rendered); + } + if (episodeLines.length > 0) { + sections.push(`${anchors.episodes}\n${episodeLines.join("\n")}`); + } + + if (sections.length === 0) return null; + + const header = buildHeader(anchors, config); + let body = sections.join("\n\n"); + const fullBlock = [MEMORY_OPEN, header, "", body, MEMORY_CLOSE].join("\n"); + + return clampBlockLength(fullBlock); +} diff --git a/antigravity/hooks/scripts/lib/search-tracks.js b/antigravity/hooks/scripts/lib/search-tracks.js new file mode 100644 index 0000000..20910c4 --- /dev/null +++ b/antigravity/hooks/scripts/lib/search-tracks.js @@ -0,0 +1,129 @@ +/** + * Common dual-track retrieval and merge utilities for EverOS Antigravity Plugin. + * Prevents code duplication across recall.js, mcp/server.js, and skills/everos/cli.js. + * Solves single-track starvation (D2-04) by interleaving results. + */ + +/** + * Interleave elements of two arrays evenly to prevent either track from being starved. + * + * @template T + * @param {T[]} a + * @param {T[]} b + * @returns {T[]} + */ +export function interleave(a = [], b = []) { + const result = []; + const maxLen = Math.max(a.length, b.length); + for (let i = 0; i < maxLen; i++) { + if (i < a.length) result.push(a[i]); + if (i < b.length) result.push(b[i]); + } + return result; +} + +/** + * Execute dual-track parallel search across User Track and Agent Engineering Track. + * + * @param {object} client - EverOS client instance + * @param {object} options + * @param {object} options.identity - Resolved identity (appId, projectId, userId, agentId) + * @param {string} options.query - Search query string + * @param {object} [options.config={}] - Configuration object + * @param {number} [options.topK=3] - Items per track + * @param {boolean} [options.includeProfile=false] - Whether to include profile + * @param {AbortSignal} [options.signal] - Timeout / cancellation signal + * @returns {Promise<{ episodes: any[], agent_cases: any[], profiles: any[], profile: any | null }>} + */ +export async function dualTrackSearch(client, options) { + const { + identity, + query, + config = {}, + topK = 3, + includeProfile = false, + signal, + } = options; + + const searchErrors = []; + const searches = []; + + // Track 1: User Track + if (identity.userId) { + searches.push( + client + .search( + { + app_id: identity.appId, + query, + project_id: identity.projectId, + user_id: identity.userId, + method: config.searchMethod || "keyword", + top_k: topK, + include_profile: includeProfile, + }, + signal + ) + .catch((err) => { + searchErrors.push(err); + return null; + }) + ); + } else { + searches.push(Promise.resolve(null)); + } + + // Track 2: Agent Engineering Track + searches.push( + client + .search( + { + app_id: identity.appId, + query, + project_id: identity.projectId, + agent_id: identity.agentId, + method: config.searchMethod || "keyword", + top_k: topK, + include_profile: includeProfile && !identity.userId, + }, + signal + ) + .catch((err) => { + searchErrors.push(err); + return null; + }) + ); + + const [userRes, agentRes] = await Promise.all(searches); + + // Normalize profiles: upstream contract uses 'profiles' array + const userProfiles = userRes?.profiles ?? (userRes?.profile ? [userRes.profile] : []); + const agentProfiles = agentRes?.profiles ?? (agentRes?.profile ? [agentRes.profile] : []); + const profiles = [...userProfiles, ...agentProfiles]; + const profile = profiles[0] ?? null; + + // Interleave episodes and cases to prevent one track starving the other (D2-04) + const userEpisodes = Array.isArray(userRes?.episodes) ? userRes.episodes : []; + const agentEpisodes = Array.isArray(agentRes?.episodes) ? agentRes.episodes : []; + const episodes = interleave(userEpisodes, agentEpisodes); + + const userCases = Array.isArray(userRes?.agent_cases) + ? userRes.agent_cases + : Array.isArray(userRes?.cases) + ? userRes.cases + : []; + const agentCases = Array.isArray(agentRes?.agent_cases) + ? agentRes.agent_cases + : Array.isArray(agentRes?.cases) + ? agentRes.cases + : []; + const agent_cases = interleave(userCases, agentCases); + + return { + episodes, + agent_cases, + profiles, + profile, + errors: searchErrors, + }; +} diff --git a/antigravity/hooks/scripts/lib/state.js b/antigravity/hooks/scripts/lib/state.js new file mode 100644 index 0000000..a9a2aef --- /dev/null +++ b/antigravity/hooks/scripts/lib/state.js @@ -0,0 +1,497 @@ +import fs from "node:fs"; +import path from "node:path"; +import { createHash } from "node:crypto"; +import { + APP_ID, + STATE_MAX_PROMPT_IDS, + STATE_TTL_DAYS, + NTFS_RETRY_COUNT, + NTFS_RETRY_DELAY_MS, + STALE_SWEEP_MINUTES, +} from "./constants.js"; + +/** + * Perform synchronous backoff sleep for EBUSY/EPERM retries on Windows. + * Uses Atomics.wait if possible, with a busy-spin fallback. + * + * @param {number} delayMs + */ +function syncSleep(delayMs) { + try { + Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs); + } catch { + const start = Date.now(); + while (Date.now() - start < delayMs) { + /* spin wait fallback */ + } + } +} + +/** + * Atomically write a file via a temporary sibling and rename. + * On Windows, handles transient file locks (EBUSY / EPERM) from antivirus + * or indexers with bounded retries and backoff. + * + * @param {string} filePath + * @param {string} content + * @param {number} [retries=3] + * @param {number} [retryDelayMs=10] + */ +export function atomicWriteFileSync(filePath, content, retries = NTFS_RETRY_COUNT, retryDelayMs = NTFS_RETRY_DELAY_MS) { + const dir = path.dirname(filePath); + fs.mkdirSync(dir, { recursive: true }); + + const randomPart = Math.random().toString(36).slice(2, 10); + const tmpPath = `${filePath}.${process.pid}.${Date.now()}.${randomPart}.tmp`; + + fs.writeFileSync(tmpPath, content, { encoding: "utf8" }); + + let lastError = null; + for (let attempt = 0; attempt <= retries; attempt++) { + try { + fs.renameSync(tmpPath, filePath); + return; + } catch (err) { + lastError = err; + if ( + (err.code === "EBUSY" || err.code === "EPERM" || err.code === "EACCES") && + attempt < retries + ) { + syncSleep(retryDelayMs); + continue; + } + break; + } + } + + // Best-effort cleanup on failure + try { + if (fs.existsSync(tmpPath)) { + fs.unlinkSync(tmpPath); + } + } catch { + /* ignore cleanup failure */ + } + + throw lastError; +} + +/** + * Sanitize session id to produce a safe filename. + * + * @param {string} sessionId + * @returns {string} + */ +export function getSessionFilePath(dataDir, sessionId) { + const rawId = String(sessionId || "default"); + const safeId = rawId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64); + const hash = createHash("sha1").update(rawId).digest("hex").slice(0, 8); + return path.join(dataDir, `session_${safeId}_${hash}.json`); +} + +/** + * Construct a clean default session state object. + * + * @param {string} sessionId + * @param {Record} [defaults={}] + * @returns {Record} + */ +export function createDefaultSessionState(sessionId, defaults = {}) { + const now = Date.now(); + return { + session_id: String(sessionId || ""), + app_id: defaults.app_id ?? defaults.appId ?? APP_ID, + project_id: defaults.project_id ?? defaults.projectId ?? "", + branch: defaults.branch ?? "", + user_id: defaults.user_id ?? defaults.userId ?? "", + agent_id: defaults.agent_id ?? defaults.agentId ?? "antigravity", + created_at: defaults.created_at ?? now, + updated_at: now, + has_injected_profile: Boolean(defaults.has_injected_profile), + recalled_turn_ids: Array.isArray(defaults.recalled_turn_ids) + ? [...defaults.recalled_turn_ids] + : [], + observed_turn_index: Number.isFinite(defaults.observed_turn_index) + ? defaults.observed_turn_index + : -1, + settled_turn_index: Number.isFinite(defaults.settled_turn_index) + ? defaults.settled_turn_index + : -1, + flushed: Boolean(defaults.flushed), + flush_attempts: Number.isFinite(defaults.flush_attempts) + ? defaults.flush_attempts + : 0, + flush_abandoned: Boolean(defaults.flush_abandoned), + pending_batch: defaults.pending_batch ?? null, + last_read_byte_offset: Number.isFinite(defaults.last_read_byte_offset) + ? defaults.last_read_byte_offset + : 0, + }; +} + +/** + * Load state for a given session. If not found or malformed, returns default state. + * + * @param {string} dataDir + * @param {string} sessionId + * @param {Record} [defaults={}] + * @returns {Record} + */ +export function loadSessionState(dataDir, sessionId, defaults = {}) { + const filePath = getSessionFilePath(dataDir, sessionId); + try { + if (!fs.existsSync(filePath)) { + return createDefaultSessionState(sessionId, defaults); + } + const raw = fs.readFileSync(filePath, { encoding: "utf8" }); + const parsed = JSON.parse(raw); + return { + ...createDefaultSessionState(sessionId, defaults), + ...parsed, + recalled_turn_ids: Array.isArray(parsed.recalled_turn_ids) + ? parsed.recalled_turn_ids + : [], + }; + } catch (err) { + try { + process.stderr.write(`[state] loadSessionState warning: ${err?.message || err}\n`); + } catch { + /* ignore */ + } + return createDefaultSessionState(sessionId, defaults); + } +} + +export const SESSIONS_INDEX_FILE = "sessions_index.json"; + +function loadSessionsIndex(dataDir) { + const indexPath = path.join(dataDir, SESSIONS_INDEX_FILE); + try { + if (!fs.existsSync(indexPath)) return null; + const raw = fs.readFileSync(indexPath, "utf8"); + const parsed = JSON.parse(raw); + if (parsed && typeof parsed === "object" && parsed.sessions && typeof parsed.sessions === "object") { + return parsed; + } + return null; + } catch { + return null; + } +} + +function saveSessionsIndex(dataDir, indexObj) { + const indexPath = path.join(dataDir, SESSIONS_INDEX_FILE); + try { + atomicWriteFileSync(indexPath, JSON.stringify(indexObj, null, 2)); + } catch { + // Fail-open + } +} + +/** + * Persist state object atomically. Automatically stamps updated_at. + * + * @param {string} dataDir + * @param {Record} state + * @returns {Record} + */ +export function saveSessionState(dataDir, state) { + if (!state || typeof state !== "object") { + throw new TypeError("State must be an object"); + } + state.updated_at = Date.now(); + + const filePath = getSessionFilePath(dataDir, state.session_id); + + // Merge-on-write: reload from disk if file exists to perform monotonic merge + let merged = state; + try { + if (fs.existsSync(filePath)) { + const raw = fs.readFileSync(filePath, "utf8"); + const onDisk = JSON.parse(raw); + if (onDisk && typeof onDisk === "object") { + merged = { + ...onDisk, + ...state, + recalled_turn_ids: [ + ...new Set([ + ...(Array.isArray(onDisk.recalled_turn_ids) ? onDisk.recalled_turn_ids : []), + ...(Array.isArray(state.recalled_turn_ids) ? state.recalled_turn_ids : []), + ]), + ], + observed_turn_index: Math.max( + Number.isFinite(onDisk.observed_turn_index) ? onDisk.observed_turn_index : -1, + Number.isFinite(state.observed_turn_index) ? state.observed_turn_index : -1 + ), + settled_turn_index: Math.max( + Number.isFinite(onDisk.settled_turn_index) ? onDisk.settled_turn_index : -1, + Number.isFinite(state.settled_turn_index) ? state.settled_turn_index : -1 + ), + last_read_byte_offset: Math.max( + Number.isFinite(onDisk.last_read_byte_offset) ? onDisk.last_read_byte_offset : 0, + Number.isFinite(state.last_read_byte_offset) ? state.last_read_byte_offset : 0 + ), + flushed: Boolean(onDisk.flushed || state.flushed), + flush_attempts: Math.max( + Number.isFinite(onDisk.flush_attempts) ? onDisk.flush_attempts : 0, + Number.isFinite(state.flush_attempts) ? state.flush_attempts : 0 + ), + flush_abandoned: Boolean(onDisk.flush_abandoned || state.flush_abandoned), + has_injected_profile: Boolean(onDisk.has_injected_profile || state.has_injected_profile), + pending_batch: state.pending_batch !== undefined ? state.pending_batch : (onDisk.pending_batch ?? null), + updated_at: state.updated_at, + }; + } + } + } catch { + // If disk read or parse fails, proceed with in-memory state + } + + try { + atomicWriteFileSync(filePath, JSON.stringify(merged, null, 2)); + } catch (writeErr) { + try { + process.stderr.write(`[state] saveSessionState write error: ${writeErr?.message || writeErr}\n`); + } catch { + /* ignore */ + } + } + + // Maintain lightweight active unflushed session index + try { + let indexObj = loadSessionsIndex(dataDir); + if (!indexObj) { + indexObj = { version: 1, sessions: {} }; + } + if (merged.flushed === true || merged.flush_abandoned === true) { + delete indexObj.sessions[merged.session_id]; + } else { + indexObj.sessions[merged.session_id] = { + session_id: merged.session_id, + project_id: merged.project_id || "", + flushed: false, + flush_attempts: merged.flush_attempts || 0, + updated_at: merged.updated_at, + }; + } + saveSessionsIndex(dataDir, indexObj); + } catch { + // Fail-open + } + + Object.assign(state, merged); + return state; +} + +/** + * Advance observed turn index (2PC Phase 1: Observation). + * + * @param {Record} state + * @param {number} turnIndex + */ +export function markObserved(state, turnIndex) { + if (typeof turnIndex === "number" && Number.isFinite(turnIndex)) { + state.observed_turn_index = Math.max(state.observed_turn_index ?? -1, turnIndex); + } + return state; +} + +/** + * Advance settled turn index (2PC Phase 2: Settlement on HTTP 200). + * + * @param {Record} state + * @param {number} turnIndex + */ +export function markSettled(state, turnIndex) { + if (typeof turnIndex === "number" && Number.isFinite(turnIndex)) { + state.settled_turn_index = Math.max(state.settled_turn_index ?? -1, turnIndex); + } + return state; +} + +/** + * Set flushed flag on session state (Only on HTTP 200 Ack). + * + * @param {Record} state + * @param {boolean} [flushed=true] + */ +export function markFlushed(state, flushed = true) { + state.flushed = Boolean(flushed); + return state; +} + +/** + * Mark a turn as recalled to prevent redundant duplicate recalls within the same turn. + * + * @param {Record} state + * @param {string} turnId + */ +export function markRecalled(state, turnId) { + if (turnId && typeof turnId === "string") { + if (!Array.isArray(state.recalled_turn_ids)) { + state.recalled_turn_ids = []; + } + if (!state.recalled_turn_ids.includes(turnId)) { + state.recalled_turn_ids.push(turnId); + if (state.recalled_turn_ids.length > STATE_MAX_PROMPT_IDS) { + state.recalled_turn_ids.splice( + 0, + state.recalled_turn_ids.length - STATE_MAX_PROMPT_IDS + ); + } + } + } + return state; +} + +/** + * Mark whether the L1 profile has been successfully injected into context. + * + * @param {Record} state + * @param {boolean} [injected=true] + */ +export function markProfileInjected(state, injected = true) { + state.has_injected_profile = Boolean(injected); + return state; +} + +/** + * Scan data directory for sessions that are unflushed and have been idle + * longer than staleThresholdMs. Used by SessionStart for 2PC compensation. + * + * @param {string} dataDir + * @param {number} [staleThresholdMs=1800000] // 30 minutes default + * @returns {Array>} + */ +export function listStaleSessions(dataDir, staleThresholdMs = STALE_SWEEP_MINUTES * 60 * 1000) { + try { + if (!fs.existsSync(dataDir)) { + return []; + } + const now = Date.now(); + const stale = []; + + const files = fs.readdirSync(dataDir); + let indexObj = loadSessionsIndex(dataDir); + if (!indexObj || typeof indexObj.sessions !== "object") { + indexObj = { version: 1, sessions: {} }; + } + + let indexDirty = false; + const diskSessionIds = new Set(); + + for (const file of files) { + if (!file.startsWith("session_") || !file.endsWith(".json") || file === "sessions_index.json") continue; + try { + const fullPath = path.join(dataDir, file); + const raw = fs.readFileSync(fullPath, { encoding: "utf8" }); + const parsed = JSON.parse(raw); + if (parsed && typeof parsed === "object" && parsed.session_id) { + diskSessionIds.add(parsed.session_id); + if (!indexObj.sessions[parsed.session_id]) { + indexObj.sessions[parsed.session_id] = { + session_id: parsed.session_id, + project_id: parsed.project_id || "", + flushed: Boolean(parsed.flushed), + updated_at: parsed.updated_at || 0, + }; + indexDirty = true; + } + } + } catch { + // Skip corrupt file + } + } + + // Check sessions recorded in index (fast-path: skips all flushed sessions) + for (const [sid, item] of Object.entries(indexObj.sessions)) { + // If file deleted from disk, remove from index + if (!diskSessionIds.has(sid)) { + delete indexObj.sessions[sid]; + indexDirty = true; + continue; + } + + if (item.flushed === true) { + continue; + } + + // It's unflushed: load its full state to check staleness + const fullState = loadSessionState(dataDir, sid); + if (!fullState || fullState.flushed === true || fullState.flush_abandoned === true) { + if (item.flushed !== true && fullState?.flushed === true) { + item.flushed = true; + indexDirty = true; + } + continue; + } + + const age = now - (fullState.updated_at || 0); + const hasUnsettledDebt = (fullState.observed_turn_index ?? -1) > (fullState.settled_turn_index ?? -1); + if (age >= staleThresholdMs || hasUnsettledDebt) { + stale.push(fullState); + } + } + + if (indexDirty) { + saveSessionsIndex(dataDir, indexObj); + } + + return stale; + } catch (err) { + try { + process.stderr.write(`[state] listStaleSessions warning: ${err?.message || err}\n`); + } catch { + /* ignore */ + } + return []; + } +} + +/** + * Cleanup expired session state files that are older than ttlDays (default 30 days). + * + * @param {string} dataDir + * @param {number} [ttlDays=30] + * @returns {number} count of deleted files + */ +export function cleanupExpiredSessions(dataDir, ttlDays = STATE_TTL_DAYS) { + try { + if (!fs.existsSync(dataDir)) return 0; + const ttlMs = ttlDays * 24 * 60 * 60 * 1000; + const now = Date.now(); + let removedCount = 0; + const files = fs.readdirSync(dataDir); + const indexObj = loadSessionsIndex(dataDir); + let indexDirty = false; + + for (const file of files) { + if (!file.startsWith("session_") || !file.endsWith(".json") || file === "sessions_index.json") continue; + const fullPath = path.join(dataDir, file); + try { + const stat = fs.statSync(fullPath); + if (now - stat.mtimeMs > ttlMs) { + // Never delete unflushed session drafts: protect long-running branches! + const raw = fs.readFileSync(fullPath, "utf8"); + const state = JSON.parse(raw); + if (state && state.flushed === true) { + fs.unlinkSync(fullPath); + removedCount++; + if (indexObj?.sessions?.[state.session_id]) { + delete indexObj.sessions[state.session_id]; + indexDirty = true; + } + } + } + } catch { + /* ignore */ + } + } + if (indexDirty && indexObj) { + saveSessionsIndex(dataDir, indexObj); + } + return removedCount; + } catch { + return 0; + } +} diff --git a/antigravity/hooks/scripts/lib/transcript.js b/antigravity/hooks/scripts/lib/transcript.js new file mode 100644 index 0000000..ac0479b --- /dev/null +++ b/antigravity/hooks/scripts/lib/transcript.js @@ -0,0 +1,372 @@ +import fs from "node:fs"; +import { + TOOL_RESULT_MAX_CHARS, + TRANSCRIPT_READ_ATTEMPTS, + TRANSCRIPT_READ_DELAY_MS, +} from "./constants.js"; +import { stripInjectedMemory } from "./render.js"; +import { stripHostWrappers } from "./query.js"; + +/** Parse Antigravity transcript lines and deduplicate/update by step_index. */ +export function parseAndSortTranscript(rawText) { + const map = new Map(); + for (const line of String(rawText ?? "").split("\n")) { + const trimmed = line.trim(); + if (!trimmed) continue; + try { + const entry = JSON.parse(trimmed); + if (typeof entry?.step_index === "number") { + map.set(entry.step_index, entry); + } + } catch { + // tolerate half-written lines during host streaming flush + } + } + return Array.from(map.values()).sort((a, b) => a.step_index - b.step_index); +} + +/** + * Read transcript safely from either a file path or a raw transcript text. + * Retries on transient read locks (EBUSY/EPERM) when reading from disk. + * + * @param {string} pathOrText + * @returns {Array>} + */ +export function readTranscript(pathOrText) { + if (typeof pathOrText !== "string" || !pathOrText.trim()) { + return []; + } + try { + if (fs.existsSync(pathOrText) && fs.statSync(pathOrText).isFile()) { + let content = ""; + for (let attempt = 0; attempt < TRANSCRIPT_READ_ATTEMPTS; attempt++) { + try { + content = fs.readFileSync(pathOrText, { encoding: "utf8" }); + break; + } catch (err) { + if (attempt === TRANSCRIPT_READ_ATTEMPTS - 1) { + break; + } + try { + Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, TRANSCRIPT_READ_DELAY_MS); + } catch { + const start = Date.now(); + while (Date.now() - start < TRANSCRIPT_READ_DELAY_MS) {} + } + } + } + return parseAndSortTranscript(content); + } + } catch { + /* fallback to raw text parsing */ + } + return parseAndSortTranscript(pathOrText); +} + +/** + * Incrementally read new lines from a transcript file starting at startOffset bytes. + * Guarantees atomic line boundaries: if a trailing line is incomplete (missing \n), + * it is not consumed and the offset remains at the last complete newline. + * + * @param {string} pathOrText + * @param {number} [startOffset=0] + * @returns {{ entries: Array>, nextOffset: number }} + */ +export function readTranscriptIncremental(pathOrText, startOffset = 0) { + const offset = typeof startOffset === "number" && startOffset >= 0 ? startOffset : 0; + if (typeof pathOrText !== "string" || !pathOrText.trim()) { + return { entries: [], nextOffset: offset }; + } + + // If pathOrText is not an existing file, treat as raw text + try { + if (!fs.existsSync(pathOrText) || !fs.statSync(pathOrText).isFile()) { + return { entries: parseAndSortTranscript(pathOrText), nextOffset: 0 }; + } + } catch { + return { entries: parseAndSortTranscript(pathOrText), nextOffset: 0 }; + } + + let fd = null; + for (let attempt = 0; attempt < TRANSCRIPT_READ_ATTEMPTS; attempt++) { + try { + const stat = fs.statSync(pathOrText); + const totalSize = stat.size; + + // File was truncated or reset: rewind to 0 + const safeOffset = totalSize < offset ? 0 : offset; + if (totalSize <= safeOffset) { + return { entries: [], nextOffset: totalSize }; + } + + const readLength = totalSize - safeOffset; + const buf = Buffer.alloc(readLength); + fd = fs.openSync(pathOrText, "r"); + fs.readSync(fd, buf, 0, readLength, safeOffset); + fs.closeSync(fd); + fd = null; + + const rawChunk = buf.toString("utf8"); + // Find the last complete line boundary to avoid parsing half-written streaming JSON + const lastNewlineIdx = rawChunk.lastIndexOf("\n"); + if (lastNewlineIdx === -1) { + // No complete newline yet: do not advance offset + return { entries: [], nextOffset: safeOffset }; + } + + const completeChunk = rawChunk.slice(0, lastNewlineIdx + 1); + const consumedBytes = Buffer.byteLength(completeChunk, "utf8"); + const entries = parseAndSortTranscript(completeChunk); + return { entries, nextOffset: safeOffset + consumedBytes }; + } catch (err) { + if (fd !== null) { + try { fs.closeSync(fd); } catch {} + fd = null; + } + if (attempt === TRANSCRIPT_READ_ATTEMPTS - 1) { + break; + } + try { + Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, TRANSCRIPT_READ_DELAY_MS); + } catch { + const start = Date.now(); + while (Date.now() - start < TRANSCRIPT_READ_DELAY_MS) {} + } + } + } + + return { entries: [], nextOffset: offset }; +} + +/** + * Slice one conversational turn from sorted transcript entries. + * A turn begins at a USER_INPUT entry (identified by turnId or step_index) + * and continues until the next USER_INPUT entry (or end of entries). + */ +export function sliceTurn(entries, targetTurnIdOrIndex) { + let targetIndex = null; + if (typeof targetTurnIdOrIndex === "number") { + targetIndex = targetTurnIdOrIndex; + } else if (typeof targetTurnIdOrIndex === "string" && targetTurnIdOrIndex.startsWith("turn_")) { + targetIndex = Number.parseInt(targetTurnIdOrIndex.slice(5), 10); + } + + let start = -1; + if (targetIndex !== null && !Number.isNaN(targetIndex)) { + start = entries.findIndex((e) => e?.step_index === targetIndex && e?.type === "USER_INPUT"); + } else { + // If not specified or not found, find the latest explicit USER_INPUT entry + for (let i = entries.length - 1; i >= 0; i--) { + if (entries[i]?.type === "USER_INPUT" && entries[i]?.source === "USER_EXPLICIT") { + start = i; + break; + } + } + } + + if (start === -1) return []; + + let end = entries.length; + for (let i = start + 1; i < entries.length; i++) { + if (entries[i]?.type === "USER_INPUT") { + end = i; + break; + } + } + + return entries.slice(start, end); +} + +/** + * Truncate long content with head/tail preservation and standard notification. + */ +export function truncateMiddle(text, max = TOOL_RESULT_MAX_CHARS, headRatio = 0.7) { + const s = String(text ?? ""); + if (s.length <= max) return s; + const head = Math.floor(max * headRatio); + const tail = max - head; + const cut = s.length - max; + return `${s.slice(0, head)}\n[... trimmed ${cut} chars by the EverOS Antigravity plugin ...]\n${s.slice(s.length - tail)}`; +} + +/** + * Extract clean user prompt from Antigravity content (strips host tags like and metadata). + */ +export function extractUserPrompt(content) { + const s = String(content ?? ""); + const match = s.match(/([\s\S]*?)<\/USER_REQUEST>/i); + const raw = match ? match[1] : s; + return stripHostWrappers(raw).trim(); +} + +function parseTs(createdAt, fallback) { + const parsed = Date.parse(createdAt ?? ""); + if (Number.isFinite(parsed) && parsed > 0) return parsed; + return fallback + 1; +} + +/** + * Convert Antigravity turn entries into standard EverOS v2 MessageItemDTO sequence. + * Enforces: + * 1. Thinking stripped from PLANNER_RESPONSE; + * 2. invoke_subagent dimensionality reduction with case resilience; + * 3. FIFO tool call pairing with GENERIC; + * 4. Multi-invocation Dummy Tool Synth loop closure on user cancellation / interruption; + * 5. Anti-recursive memory injection stripping. + */ +export function toEverosMessages(turnEntries, options = {}) { + const { userId, agentId } = options ?? {}; + const messages = []; + const pendingCalls = []; // FIFO queue of call IDs + const userSender = userId ? String(userId) : "user"; + const agentSender = agentId ? String(agentId) : "antigravity"; + let previousTs = Date.now(); + + for (const entry of turnEntries) { + const ts = parseTs(entry.created_at, previousTs); + previousTs = ts; + + // 1. User Message + if (entry.type === "USER_INPUT" && entry.source === "USER_EXPLICIT") { + const rawPrompt = extractUserPrompt(entry.content); + const cleanContent = stripInjectedMemory(rawPrompt); + if (cleanContent) { + messages.push({ + sender_id: userSender, + role: "user", + timestamp: ts, + content: cleanContent, + }); + } + continue; + } + + // 2. Assistant Response + if (entry.type === "PLANNER_RESPONSE") { + // Topology constraint: before pushing a new assistant turn, any unfulfilled tool calls + // from the previous invocation MUST be closed with Dummy Tool Synth messages. + while (pendingCalls.length > 0) { + const orphanId = pendingCalls.shift(); + messages.push({ + sender_id: agentSender, + role: "tool", + tool_call_id: orphanId, + timestamp: previousTs + 1, + content: "[tool interrupted or canceled by user]", + }); + } + + // Thinking chain is intentionally dropped + const content = entry.content || ""; + const rawCalls = Array.isArray(entry.tool_calls) ? entry.tool_calls : []; + const formattedCalls = rawCalls.map((tc, idx) => { + const id = tc.id || `call_${entry.step_index}_${idx}`; + const toolName = tc.name ?? tc.tool ?? tc.function?.name ?? "unknown_tool"; + let args = tc.args ?? tc.arguments ?? tc.function?.arguments ?? {}; + + // Parse args if stringified JSON + if (typeof args === "string") { + try { + args = JSON.parse(args); + } catch {} + } + + // Concurrent subagent dimensionality reduction with casing resilience + if (toolName === "invoke_subagent") { + let role = null; + let prompt = null; + let subagentId = null; + let typeName = null; + const subs = args.Subagents ?? args.subagents; + if (subs) { + try { + const parsed = typeof subs === "string" ? JSON.parse(subs) : subs; + const first = Array.isArray(parsed) ? parsed[0] : parsed; + role = first?.Role ?? first?.role; + prompt = first?.Prompt ?? first?.prompt; + subagentId = + first?.conversationId ?? + first?.conversation_id ?? + first?.SubagentId ?? + first?.subagent_id; + typeName = first?.TypeName ?? first?.type_name; + } catch {} + } + role = role ?? args.Role ?? args.role; + prompt = prompt ?? args.Prompt ?? args.prompt; + subagentId = + subagentId ?? + args.conversationId ?? + args.conversation_id ?? + args.SubagentId ?? + args.subagent_id ?? + null; + typeName = typeName ?? args.TypeName ?? args.type_name ?? null; + + const subagentPayload = { + subagent_role: role || "Subagent", + prompt: prompt || "", + }; + if (subagentId) { + subagentPayload.subagent_id = String(subagentId); + } + if (typeName) { + subagentPayload.type_name = String(typeName); + } + args = subagentPayload; + } + + pendingCalls.push(id); + return { + id, + type: "function", + function: { + name: toolName, + arguments: typeof args === "string" ? args : JSON.stringify(args), + }, + }; + }); + + const assistantMsg = { + sender_id: agentSender, + role: "assistant", + timestamp: ts, + content, + }; + if (formattedCalls.length > 0) { + assistantMsg.tool_calls = formattedCalls; + } + messages.push(assistantMsg); + continue; + } + + // 3. Tool Result (GENERIC in Antigravity) + if (entry.type === "GENERIC" && pendingCalls.length > 0) { + const matchedCallId = pendingCalls.shift(); + const rawContent = entry.content || ""; + const content = entry.status === "ERROR" ? `[tool error] ${rawContent}` : rawContent; + messages.push({ + sender_id: agentSender, + role: "tool", + tool_call_id: matchedCallId, + timestamp: ts, + content: truncateMiddle(content, TOOL_RESULT_MAX_CHARS), + }); + continue; + } + } + + // 4. Dummy Tool Synth: close the OpenAI message chain for final interrupted/orphaned calls + while (pendingCalls.length > 0) { + const orphanId = pendingCalls.shift(); + messages.push({ + sender_id: agentSender, + role: "tool", + tool_call_id: orphanId, + timestamp: previousTs + 1, + content: "[tool interrupted or canceled by user]", + }); + } + + return messages; +} diff --git a/antigravity/hooks/scripts/recall.js b/antigravity/hooks/scripts/recall.js new file mode 100644 index 0000000..830aa5c --- /dev/null +++ b/antigravity/hooks/scripts/recall.js @@ -0,0 +1,138 @@ +import { createHash } from "node:crypto"; +import { readStdinJson, writeStdoutJson, wrapHook } from "./lib/hook-io.js"; +import { loadConfig } from "./lib/config.js"; +import { resolveIdentity } from "./lib/identity.js"; +import { createClient, deadline } from "./lib/everos.js"; +import { + loadSessionState, + saveSessionState, + markRecalled, + markProfileInjected, +} from "./lib/state.js"; +import { readTranscript } from "./lib/transcript.js"; +import { shouldRecall, buildQuery } from "./lib/query.js"; +import { renderProfileBlock, renderMemoryBlock } from "./lib/render.js"; +import { dualTrackSearch } from "./lib/search-tracks.js"; + +wrapHook(async () => { + const input = readStdinJson(); + const transcriptPath = input.transcriptPath; + const conversationId = String( + input.conversationId ?? input.conversation_id ?? "default" + ); + + if (!transcriptPath) { + writeStdoutJson({}); + return; + } + + const config = loadConfig(); + + // 1. Double-Lock: check transcript's latest USER_INPUT + const entries = readTranscript(transcriptPath); + let latestUserStep = null; + for (let i = entries.length - 1; i >= 0; i--) { + const entry = entries[i]; + if (entry.type === "USER_INPUT" && entry.source === "USER_EXPLICIT") { + latestUserStep = entry; + break; + } + } + + if (!latestUserStep) { + writeStdoutJson({}); + return; + } + + const contentDigest = createHash("sha1") + .update(`${conversationId}|${latestUserStep.created_at ?? ""}|${String(latestUserStep.content ?? "").slice(0, 200)}`) + .digest("hex") + .slice(0, 8); + const turnId = `turn_${latestUserStep.step_index}_${contentDigest}`; + + const cwd = + (Array.isArray(input.workspacePaths) && input.workspacePaths[0]) || + process.cwd(); + const identity = resolveIdentity(cwd, config); + + const state = loadSessionState(config.dataDir, conversationId, { + projectId: identity.projectId, + branch: identity.branch, + userId: identity.userId, + agentId: identity.agentId, + }); + + // Check if this turn was already recalled + if (state.recalled_turn_ids.includes(turnId)) { + writeStdoutJson({}); + return; + } + + // 2. Query Intent Filtering: filter trivial acknowledgments or slash commands + const rawContent = latestUserStep.content ?? ""; + if (!shouldRecall(rawContent)) { + markRecalled(state, turnId); + saveSessionState(config.dataDir, state); + writeStdoutJson({}); + return; + } + + const query = buildQuery(rawContent); + const client = createClient({ baseUrl: config.baseUrl }); + const signal = deadline(config.recallTimeoutMs); + + const needProfileFallback = !state.has_injected_profile; + + // 3. Dual-Track Parallel Search & Interleaved Merge (D2-04 / D5-03) + const mergedSearchRes = await dualTrackSearch(client, { + identity, + query, + config, + topK: 3, + includeProfile: needProfileFallback, + signal, + }); + + const blocks = []; + + // 5. Cold-Start Fallback: L1 Profile if SessionStart missed it + if (needProfileFallback && mergedSearchRes.profile) { + const profileBlock = renderProfileBlock(mergedSearchRes.profile, { + projectId: identity.projectId, + branch: identity.branch, + locale: config.locale, + }); + if (profileBlock) { + blocks.push(profileBlock); + markProfileInjected(state, true); + } + } + + // 6. L2 Ephemeral Memory Block + const memoryBlock = renderMemoryBlock(mergedSearchRes, { + projectId: identity.projectId, + branch: identity.branch, + locale: config.locale, + }); + + if (memoryBlock) { + blocks.push(memoryBlock); + } + + // 7. Mark recalled and persist + markRecalled(state, turnId); + saveSessionState(config.dataDir, state); + + if (blocks.length > 0) { + writeStdoutJson({ + injectSteps: [ + { + ephemeralMessage: blocks.join("\n\n"), + }, + ], + }); + return; + } + + writeStdoutJson({}); +}); diff --git a/antigravity/hooks/scripts/session-start.js b/antigravity/hooks/scripts/session-start.js new file mode 100644 index 0000000..58f14eb --- /dev/null +++ b/antigravity/hooks/scripts/session-start.js @@ -0,0 +1,134 @@ +import fs from "node:fs"; +import path from "node:path"; +import { spawn } from "node:child_process"; +import { fileURLToPath } from "node:url"; +import { readStdinJson, writeStdoutJson, wrapHook } from "./lib/hook-io.js"; +import { loadConfig } from "./lib/config.js"; +import { resolveIdentity } from "./lib/identity.js"; +import { createClient } from "./lib/everos.js"; +import { + loadSessionState, + saveSessionState, + markProfileInjected, + listStaleSessions, + cleanupExpiredSessions, +} from "./lib/state.js"; +import { ensureServerRunning } from "./lib/provision.js"; +import { renderProfileBlock } from "./lib/render.js"; + +wrapHook(async () => { + const input = readStdinJson(); + const conversationId = String( + input.conversationId ?? input.conversation_id ?? "default" + ); + const config = loadConfig(); + + const cwd = + (Array.isArray(input.workspacePaths) && input.workspacePaths[0]) || + process.cwd(); + const identity = resolveIdentity(cwd, config); + + const state = loadSessionState(config.dataDir, conversationId, { + projectId: identity.projectId, + branch: identity.branch, + userId: identity.userId, + agentId: identity.agentId, + }); + + const client = createClient({ baseUrl: config.baseUrl }); + + // 1. Ensure EverOS daemon is alive + const daemon = await ensureServerRunning(config, { client }); + + // 2. Stale Sweep: 2PC compensation via detached background flush (capped at 3 items) + if (daemon.ok) { + try { + const here = path.dirname(fileURLToPath(import.meta.url)); + const flushScript = path.join(here, "flush.js"); + const staleCandidates = listStaleSessions(config.dataDir) + .filter((s) => s.session_id !== conversationId && Boolean(s.project_id) && !s.flush_abandoned) + .slice(0, 3); // Bounded batch of max 3 + + const safeCwd = (cwd && fs.existsSync(cwd)) ? cwd : process.cwd(); + for (const stale of staleCandidates) { + try { + const child = spawn(process.execPath, [flushScript, "--background", stale.session_id], { + detached: true, + stdio: "ignore", + windowsHide: true, + cwd: safeCwd, + env: process.env, + }); + child.on("error", () => {}); // Never throw unhandled error event + child.unref(); + } catch { + /* ignore spawn error */ + } + } + + // 2b. Cleanup expired sessions older than TTL (D5-07) + cleanupExpiredSessions(config.dataDir); + } catch { + /* stale sweep non-blocking */ + } + } + + // 3. L1 Persistent Profile Injection + if (daemon.ok && !state.has_injected_profile) { + try { + const profileSearchBody = { + app_id: identity.appId, + query: "developer preferences and coding style", + project_id: identity.projectId, + method: config.searchMethod, + top_k: 1, + include_profile: true, + }; + if (identity.userId) { + profileSearchBody.user_id = identity.userId; + } else { + profileSearchBody.agent_id = identity.agentId; + } + + const searchRes = await client.search( + profileSearchBody, + AbortSignal.timeout(config.recallTimeoutMs) + ); + + const profileItem = searchRes?.profiles?.[0] ?? null; + if (profileItem) { + const rendered = renderProfileBlock(profileItem, { + projectId: identity.projectId, + branch: identity.branch, + locale: config.locale, + }); + + if (rendered) { + markProfileInjected(state, true); + saveSessionState(config.dataDir, state); + writeStdoutJson({ + injectSteps: [ + { + systemMessage: { + systemMessage: rendered, + }, + }, + ], + }); + return; + } + } + } catch (err) { + // Server may still be starting or unreachable: leave has_injected_profile as false + // PreInvocation will perform Cold-Start Fallback + try { + process.stderr.write(`[session-start] Profile fetch deferred: ${err?.message || err}\n`); + } catch { + /* ignore */ + } + } + } + + saveSessionState(config.dataDir, state); + writeStdoutJson({}); +}); diff --git a/antigravity/mcp/server.js b/antigravity/mcp/server.js new file mode 100644 index 0000000..4bf620c --- /dev/null +++ b/antigravity/mcp/server.js @@ -0,0 +1,347 @@ +// Ensure stdout is 100% reserved for JSON-RPC 2.0 frames; redirect logs to stderr +console.log = (...args) => process.stderr.write(`[everos-mcp] ${args.join(" ")}\n`); + +import readline from "node:readline"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { loadConfig } from "../hooks/scripts/lib/config.js"; +import { resolveIdentity } from "../hooks/scripts/lib/identity.js"; +import { createClient } from "../hooks/scripts/lib/everos.js"; +import { renderProfileBlock, renderMemoryBlock } from "../hooks/scripts/lib/render.js"; +import { dualTrackSearch } from "../hooks/scripts/lib/search-tracks.js"; + +const __dirname = path.dirname(fileURLToPath(import.meta.url)); +const pluginRoot = path.resolve(__dirname, ".."); + +const config = loadConfig(); +const identity = resolveIdentity(process.cwd(), config); +const client = createClient({ baseUrl: config.baseUrl }); +const TIMEOUT_MS = Math.min(Math.max(config.recallTimeoutMs || 5000, 500), 10000); + +/** + * Standard MCP Tools definitions + */ +const TOOLS = [ + { + name: "everos_search_memory", + description: + "Search historical memories and cognitive dialogues across project sessions via semantic & hybrid retrieval. " + + "Returns distilled Markdown by default, or raw JSON when raw: true.", + inputSchema: { + type: "object", + properties: { + query: { + type: "string", + description: + "Search query describing the context, scenario or the very symptom. " + + "For complex syndrome, refining concept keywords, architectural entities, etc., yields optimal recall.", + }, + top_k: { + type: "integer", + description: "Maximum number of items to recall (1..20, default 5)", + default: 5, + }, + raw: { + type: "boolean", + description: "If true, returns full raw JSON with metadata; defaults to false (clean high-density Markdown)", + default: false, + }, + }, + required: ["query"], + }, + }, + { + name: "everos_get_profile", + description: + "Get developer conventions and preferences profile for the current project (Prescriptive Covenants and Tacit Affinities).", + inputSchema: { + type: "object", + properties: { + raw: { + type: "boolean", + description: "If true, returns full raw profile JSON; defaults to false (clean Markdown)", + default: false, + }, + }, + }, + }, + { + name: "everos_add_memory", + description: + "Explicitly ingest a high-value insight, troubleshooting postmortem, or architectural decision into EverOS.", + inputSchema: { + type: "object", + properties: { + content: { + type: "string", + description: "The insight, troubleshooting case, or architectural covenant to record", + }, + category: { + type: "string", + description: "Category hint: 'case' | 'rule' | 'fact'", + enum: ["case", "rule", "fact"], + default: "case", + }, + }, + required: ["content"], + }, + }, +]; + +/** + * Send standard JSON-RPC 2.0 response to stdout followed by newline. + */ +function sendResponse(id, result) { + const payload = { jsonrpc: "2.0", id, result }; + process.stdout.write(JSON.stringify(payload) + "\n", "utf8"); +} + +/** + * Send standard JSON-RPC 2.0 error to stdout followed by newline. + */ +function sendError(id, code, message, data) { + const payload = { + jsonrpc: "2.0", + id, + error: { code, message, ...(data !== undefined ? { data } : {}) }, + }; + process.stdout.write(JSON.stringify(payload) + "\n", "utf8"); +} + +/** + * Wrap text as standard CallToolResult + */ +function textResult(text, isError = false) { + return { + content: [ + { + type: "text", + text: String(text ?? ""), + }, + ], + isError, + }; +} + +/** + * Handle tools/call execution + */ +async function handleToolCall(name, args = {}) { + switch (name) { + case "everos_search_memory": { + const query = String(args.query || "").trim(); + if (!query) { + return textResult("Error: query parameter is required and cannot be empty.", true); + } + const topK = Number.isInteger(args.top_k) ? Math.min(Math.max(args.top_k, 1), 20) : 5; + + const merged = await dualTrackSearch(client, { + identity, + query, + config, + topK, + includeProfile: true, + signal: AbortSignal.timeout(TIMEOUT_MS), + }); + + // Distinguish offline / backend failure from genuine empty memory + const attemptedCount = identity.userId ? 2 : 1; + if (merged.errors.length >= attemptedCount && merged.episodes.length === 0 && merged.agent_cases.length === 0 && !merged.profile) { + return textResult( + `EverOS search unavailable: ${merged.errors[0]?.message || "Backend connection failed"}`, + true + ); + } + + if (args.raw === true) { + return textResult(JSON.stringify(merged, null, 2)); + } + + const rendered = renderMemoryBlock(merged, { + projectId: identity.projectId, + branch: identity.branch, + locale: config.locale, + }); + + if (!rendered) { + return textResult(`No matching memories found for query: "${query}".`); + } + + const notice = + config.locale === "en" + ? "\n\n> [Tip] The above is distilled high-density memory. Pass raw: true to view full raw JSON with confidence and evidence." + : "\n\n> [提示] 以上为精简提炼的高密度工程记忆。如需查看完整原始数据（含置信度、时间戳与证据链），可传入参数 raw: true 再次查询。"; + + return textResult(rendered + notice); + } + + case "everos_get_profile": { + const searchBody = { + app_id: identity.appId, + query: "developer preferences and coding style", + project_id: identity.projectId, + top_k: 1, + include_profile: true, + }; + if (identity.userId) { + searchBody.user_id = identity.userId; + } else { + searchBody.agent_id = identity.agentId; + } + + let searchRes; + try { + searchRes = await client.search(searchBody, AbortSignal.timeout(TIMEOUT_MS)); + } catch (err) { + return textResult( + `EverOS profile unavailable: ${err?.message || "Backend connection failed"}`, + true + ); + } + const profileItem = searchRes?.profiles?.[0] ?? null; + + if (!profileItem) { + return textResult(`No profile recorded for project: ${identity.projectId}.`); + } + + if (args.raw === true) { + return textResult(JSON.stringify(profileItem, null, 2)); + } + + const rendered = renderProfileBlock(profileItem, { + projectId: identity.projectId, + branch: identity.branch, + locale: config.locale, + }); + + return textResult(rendered || `Empty profile for project: ${identity.projectId}.`); + } + + case "everos_add_memory": { + const content = String(args.content || "").trim(); + if (!content) { + return textResult("Error: content parameter is required and cannot be empty.", true); + } + const category = String(args.category || "case").trim(); + const now = Date.now(); + + const messages = [ + { + sender_id: identity.userId || "developer", + role: "user", + timestamp: now - 1000, + content: `[Manual Record: ${category}] ${content}`, + }, + { + sender_id: identity.agentId, + role: "assistant", + timestamp: now, + content: `Recorded insight: ${content}`, + }, + ]; + + await client.add( + { + app_id: identity.appId, + session_id: `manual_${now}`, + project_id: identity.projectId, + messages, + }, + AbortSignal.timeout(TIMEOUT_MS) + ); + + return textResult( + `Successfully ingested memory into project '${identity.projectId}' (category: ${category}).` + ); + } + + default: + return textResult(`Unknown tool: ${name}`, true); + } +} + +/** + * Main stdio JSON-RPC processing loop + */ +export function startMcpServer() { + const rl = readline.createInterface({ + input: process.stdin, + terminal: false, + }); + + rl.on("line", async (line) => { + const trimmed = line.trim(); + if (!trimmed) return; + + let msg; + try { + msg = JSON.parse(trimmed); + } catch (parseErr) { + sendError(null, -32700, "Parse error: invalid JSON"); + return; + } + + if (!msg || typeof msg !== "object") return; + + const { id, method, params } = msg; + + // Handle notifications (no id) + if (id === undefined || id === null) { + if (method === "notifications/initialized") { + /* client initialized acknowledgement, silent ignore */ + } + return; + } + + try { + switch (method) { + case "initialize": { + sendResponse(id, { + protocolVersion: "2024-11-05", + serverInfo: { + name: "everos-antigravity", + version: "1.0.0", + }, + capabilities: { + tools: {}, + }, + }); + break; + } + + case "ping": { + sendResponse(id, {}); + break; + } + + case "tools/list": { + sendResponse(id, { tools: TOOLS }); + break; + } + + case "tools/call": { + const toolName = params?.name; + const toolArgs = params?.arguments || {}; + try { + const result = await handleToolCall(toolName, toolArgs); + sendResponse(id, result); + } catch (toolErr) { + sendResponse(id, textResult(`Tool Error: ${toolErr?.message || toolErr}`, true)); + } + break; + } + + default: + sendError(id, -32601, `Method not found: ${method}`); + break; + } + } catch (err) { + sendError(id, -32603, `Internal RPC Error: ${err?.message || err}`); + } + }); +} + +// Start server if directly invoked +if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) { + startMcpServer(); +} diff --git a/antigravity/mcp_config.json b/antigravity/mcp_config.json new file mode 100644 index 0000000..29508ca --- /dev/null +++ b/antigravity/mcp_config.json @@ -0,0 +1,9 @@ +{ + "mcpServers": { + "everos": { + "command": "node", + "args": ["${PLUGIN_ROOT}/mcp/server.js"], + "env": {} + } + } +} diff --git a/antigravity/package.json b/antigravity/package.json new file mode 100644 index 0000000..5a1fcce --- /dev/null +++ b/antigravity/package.json @@ -0,0 +1,24 @@ +{ + "name": "everos-antigravity", + "version": "1.0.0-rc1", + "private": true, + "description": "EverOS cognitive memory plugin for Google Antigravity - lifecycle hooks, skills, native MCP server, and resilient 2PC state machine.", + "author": "Sethyrial", + "license": "Apache-2.0", + "type": "module", + "engines": { + "node": ">=20.0.0" + }, + "scripts": { + "check": "node scripts/check-manifests.mjs", + "install:workspace": "node scripts/install.mjs", + "test": "node scripts/check-manifests.mjs && node --test --test-concurrency=1 tests/*.test.js", + "ci": "npm test", + "seed:demo": "node scripts/seed-demo.js", + "verify:live": "node scripts/live-verify.js" + }, + "repository": { + "type": "git", + "url": "https://github.com/LoveS0ph1e/ArtEmis.git" + } +} diff --git a/antigravity/plugin.json b/antigravity/plugin.json new file mode 100644 index 0000000..773092c --- /dev/null +++ b/antigravity/plugin.json @@ -0,0 +1,10 @@ +{ + "name": "everos", + "version": "0.1.0", + "description": "EverOS cross-session cognitive memory for Google Antigravity. Recalls relevant covenants and exemplars, captures message trajectories, and auto-seals memory episodes.", + "suggestedPrompts": [ + "/everos status", + "/everos search memory for recent architecture decisions", + "/everos flush" + ] +} diff --git a/antigravity/scripts/check-manifests.mjs b/antigravity/scripts/check-manifests.mjs new file mode 100644 index 0000000..690bbe7 --- /dev/null +++ b/antigravity/scripts/check-manifests.mjs @@ -0,0 +1,152 @@ +#!/usr/bin/env node +/** + * check-manifests.mjs — Antigravity 插件清单闭环校验 + * + * 位于 scripts/check-manifests.mjs，由 `npm run check` 与 CI 调用。 + * 校验：宿主读哪份清单、清单指向的脚本是否存在、路径是否能跨 cwd 解析、无本地路径泄漏、零依赖。 + */ +import fs from "node:fs"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +const here = path.dirname(fileURLToPath(import.meta.url)); +const root = path.resolve(process.argv[2] || path.join(here, "..")); + +let failures = 0; +const ok = (m) => console.log(` PASS ${m}`); +const bad = (m) => { failures++; console.error(` FAIL ${m}`); }; + +console.log(`[check-manifests] root = ${root}\n`); + +// ── 1. package.json 零依赖 ──────────────────────────────────────────────── +console.log("1) package.json"); +const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")); +for (const k of ["dependencies", "devDependencies", "peerDependencies"]) { + const v = pkg[k]; + if (v && Object.keys(v).length) bad(`${k} 必须为空，实际: ${Object.keys(v)}`); + else ok(`${k} 为空`); +} +if (!pkg.scripts?.ci) bad("scripts.ci 缺失"); +else ok(`scripts.ci = "${pkg.scripts.ci}"`); +if (!pkg.scripts?.check) bad('scripts.check 缺失（CI 需要独立于 test 的清单门禁）'); +else ok(`scripts.check = "${pkg.scripts.check}"`); + +// ── 2. hooks 清单：只允许一份，且命令可跨 cwd 解析 ──────────────────────── +console.log("\n2) hooks 清单"); +const hookCandidates = [path.join(root, "hooks.json"), path.join(root, "hooks", "hooks.json")] + .filter((p) => fs.existsSync(p)); +if (hookCandidates.length === 0) bad("未找到 hooks.json"); +if (hookCandidates.length > 1) { + bad(`hooks 清单存在 ${hookCandidates.length} 份，宿主读哪份未定义: ${hookCandidates.map((p) => path.relative(root, p)).join(", ")}`); +} else ok("hooks 清单唯一"); + +const hookEvents = new Set(["SessionStart", "PreInvocation", "PreToolUse", "PostToolUse", "PostInvocation", "Stop"]); +for (const hp of hookCandidates) { + const rel = path.relative(root, hp); + let doc; + try { doc = JSON.parse(fs.readFileSync(hp, "utf8")); } + catch (e) { bad(`${rel} 不是合法 JSON: ${e.message}`); continue; } + + const namespaces = Object.keys(doc); + if (namespaces.length !== 1 || typeof doc[namespaces[0]] !== "object") { + bad(`${rel} 应为「单一顶层命名空间」包裹，实际顶层键: ${namespaces.join(", ")}`); + continue; + } + ok(`${rel} 顶层命名空间 = ${namespaces[0]}`); + + const events = doc[namespaces[0]]; + for (const [ev, arr] of Object.entries(events)) { + if (!hookEvents.has(ev)) bad(`${rel} 未知事件 ${ev}`); + if (!Array.isArray(arr)) { bad(`${rel} ${ev} 不是数组`); continue; } + for (const item of arr) { + if (item.matcher !== undefined || item.hooks !== undefined) { + bad(`${rel} ${ev} 使用了 Claude Code 的 matcher/hooks 双层包装`); + } + if (item.type !== "command") bad(`${rel} ${ev} type 应为 command`); + if (typeof item.timeout !== "number") bad(`${rel} ${ev} timeout 应为数字（秒）`); + + const cmd = String(item.command || ""); + const hasVar = /\$\{?[A-Z_]*PLUGIN_ROOT/.test(cmd); + if (hasVar && !/\$\{[A-Z_]*PLUGIN_ROOT:-\.?\}/.test(cmd)) { + bad(`${rel} ${ev} 变量 ${cmd.match(/\$\{?[A-Z_]*PLUGIN_ROOT\}?/)[0]} 缺少 ":-." 兜底`); + } + const target = cmd.replace(/^node\s+/, "").replace(/^"|"$/g, "") + .replace(/^\$\{[A-Z_]*PLUGIN_ROOT:-?\.?\}\//, ""); + if (!hasVar && !/^[A-Za-z]:[\\/]/.test(target)) { + bad(`${rel} ${ev} 使用裸相对路径 "${target}"：宿主 cwd 非插件根时必然失败（应用 \${PLUGIN_ROOT} 或绝对路径）`); + } else { + const abs = path.resolve(root, target); + if (!fs.existsSync(abs)) bad(`${rel} ${ev} 指向不存在的文件: ${target}`); + else ok(`${ev} -> ${target}`); + } + } + } +} + +// ── 3. MCP 清单 ───────────────────────────────────────────────────────── +console.log("\n3) mcp_config.json"); +const mcpPath = path.join(root, "mcp_config.json"); +if (!fs.existsSync(mcpPath)) bad("mcp_config.json 缺失"); +else { + const mcp = JSON.parse(fs.readFileSync(mcpPath, "utf8")); + const servers = mcp.mcpServers ?? {}; + if (!Object.keys(servers).length) bad("mcpServers 为空"); + for (const [name, cfg] of Object.entries(servers)) { + const args = cfg.args ?? []; + for (const a of args) { + if (!/\$\{PLUGIN_ROOT\}/.test(a)) { bad(`mcpServers.${name} 参数未锚定插件根: ${a}`); continue; } + const rel = a.replace("${PLUGIN_ROOT}/", ""); + if (!fs.existsSync(path.join(root, rel))) bad(`mcpServers.${name} 指向不存在的文件: ${rel}`); + else ok(`mcpServers.${name} -> ${rel}`); + } + } +} + +// ── 4. 本地绝对路径泄漏 ────────────────────────────────────────────────── +console.log("\n4) 本地路径泄漏"); +// 只扫「随包交付的文档与源码」；tests/ 下的 /home/tester、/Users/me 是 fixture 常量，不算泄漏。 +const LEAK = /[A-Za-z]:\\+(Users|ArtEmis|Tencent)\\+|\/Users\/(?!me\b)[a-z]|\/home\/(?!tester\b)[a-z]/i; +const walk = (d) => fs.readdirSync(d, { withFileTypes: true }).flatMap((e) => { + const p = path.join(d, e.name); + if (e.isDirectory()) return e.name === "node_modules" || e.name === ".git" ? [] : walk(p); + return [p]; +}); +const textExt = new Set([".js", ".mjs", ".json", ".md", ".yml", ".yaml", ".txt"]); +let leaks = 0; +for (const f of walk(root)) { + if (!textExt.has(path.extname(f))) continue; + if (path.relative(root, f).split(path.sep)[0] === "tests") continue; + const txt = fs.readFileSync(f, "utf8"); + txt.split("\n").forEach((ln, i) => { + if (LEAK.test(ln)) { leaks++; bad(`${path.relative(root, f)}:${i + 1} 含本地绝对路径: ${ln.trim().slice(0, 90)}`); } + }); +} +if (!leaks) ok("无本地绝对路径"); + +// ── 5. Skills 与 CLI 路由闭环 ─────────────────────────────────────────── +console.log("\n5) Skills"); +const skillsDir = path.join(root, "skills"); +if (!fs.existsSync(skillsDir)) bad("skills/ 缺失"); +else { + const skills = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()); + for (const s of skills) { + const md = path.join(skillsDir, s.name, "SKILL.md"); + if (!fs.existsSync(md)) { bad(`skills/${s.name} 缺少 SKILL.md`); continue; } + const body = fs.readFileSync(md, "utf8"); + const fm = body.match(/^---\n([\s\S]*?)\n---/); + if (!fm) bad(`skills/${s.name}/SKILL.md 缺少 frontmatter`); + else if (!/^name:/m.test(fm[1]) || !/^description:/m.test(fm[1])) bad(`skills/${s.name}/SKILL.md frontmatter 缺 name/description`); + + // SKILL.md 里出现的 cli 路径必须真实存在 + for (const m of body.matchAll(/node\s+"([^"]*cli\.js)"/g)) { + const p = m[1]; + const rel = p.replace("${PLUGIN_ROOT}/", ""); + if (!fs.existsSync(path.resolve(root, rel))) bad(`skills/${s.name} 引用不存在的 ${p}`); + else ok(`skills/${s.name} -> ${p}`); + if (!/\$\{PLUGIN_ROOT\}/.test(p)) bad(`skills/${s.name} 使用裸相对路径 "${p}"，依赖宿主 cwd`); + } + } +} + +console.log(`\n${failures === 0 ? "ALL CHECKS PASSED" : `${failures} CHECK(S) FAILED`}`); +process.exit(failures === 0 ? 0 : 1); diff --git a/antigravity/scripts/install.mjs b/antigravity/scripts/install.mjs new file mode 100644 index 0000000..0a279aa --- /dev/null +++ b/antigravity/scripts/install.mjs @@ -0,0 +1,315 @@ +#!/usr/bin/env node +/** + * install.mjs — EverOS Antigravity Plugin Unified Installer + * + * Supports three deployment modes: + * 1. Workspace Local Mode: Injects absolute paths into /.agents/ + * 2. Global Plugin Bundle Mode: Deploys as standard plugin to ~/.gemini/config/plugins/everos/ + * 3. Native Sidecar Daemon Mode: Registers EverOS as an Antigravity background sidecar + * + * Usage: + * node scripts/install.mjs [options] + */ + +import fs from "node:fs"; +import path from "node:path"; +import os from "node:os"; +import { fileURLToPath } from "node:url"; + +const here = path.dirname(fileURLToPath(import.meta.url)); +const pluginRoot = path.resolve(here, ".."); + +function parseArgs(args) { + const options = { + workspace: null, + global: false, + sidecar: false, + python: null, + dryRun: false, + help: false, + }; + + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + if (arg === "--workspace" || arg === "-w") { + options.workspace = path.resolve(args[++i] || process.cwd()); + } else if (arg === "--global" || arg === "-g") { + options.global = true; + } else if (arg === "--sidecar" || arg === "-s") { + options.sidecar = true; + } else if (arg === "--python" || arg === "-p") { + options.python = path.resolve(args[++i]); + } else if (arg === "--dry-run") { + options.dryRun = true; + } else if (arg === "--help" || arg === "-h") { + options.help = true; + } + } + + // Default to workspace mode on cwd if neither global nor sidecar is specified + if (!options.global && !options.sidecar && !options.workspace) { + options.workspace = process.cwd(); + } + + return options; +} + +function normalizePath(p) { + return p.replace(/\\/g, "/"); +} + +function backupFile(targetPath, dryRun) { + if (fs.existsSync(targetPath)) { + const bakPath = `${targetPath}.bak`; + if (!dryRun) { + fs.copyFileSync(targetPath, bakPath); + } + console.log(`[install] Backed up existing file -> ${bakPath}`); + } +} + +/** + * 1. Install to Workspace (.agents/hooks.json & mcp_config.json with absolute paths) + */ +export function installToWorkspace(targetWorkspace, { dryRun = false } = {}) { + const targetAgentsDir = path.join(targetWorkspace, ".agents"); + const normalizedRoot = normalizePath(pluginRoot); + + console.log(`\n--- [Workspace Mode] ---`); + console.log(`[install] Plugin Root: ${pluginRoot}`); + console.log(`[install] Target Workspace: ${targetWorkspace}`); + console.log(`[install] Agents Directory: ${targetAgentsDir}`); + + if (!dryRun && !fs.existsSync(targetAgentsDir)) { + fs.mkdirSync(targetAgentsDir, { recursive: true }); + } + + // Install hooks.json + const templateHooksPath = path.join(pluginRoot, "hooks.json"); + if (!fs.existsSync(templateHooksPath)) { + throw new Error(`Template hooks.json not found at ${templateHooksPath}`); + } + + const rawHooks = fs.readFileSync(templateHooksPath, "utf8"); + const resolvedHooksStr = rawHooks + .replace(/\$\{PLUGIN_ROOT:-\.?\}/g, normalizedRoot) + .replace(/\$\{PLUGIN_ROOT\}/g, normalizedRoot) + .replace(/__PLUGIN_ROOT__/g, normalizedRoot); + + const hooksTemplate = JSON.parse(resolvedHooksStr); + const targetHooksPath = path.join(targetAgentsDir, "hooks.json"); + + let finalHooks = hooksTemplate; + if (fs.existsSync(targetHooksPath)) { + backupFile(targetHooksPath, dryRun); + try { + const existing = JSON.parse(fs.readFileSync(targetHooksPath, "utf8")); + finalHooks = { + ...existing, + ...hooksTemplate, + }; + } catch (e) { + console.warn(`[install] Warning: existing hooks.json was invalid JSON, overwriting: ${e.message}`); + } + } + + const hooksContent = JSON.stringify(finalHooks, null, 2) + "\n"; + if (dryRun) { + console.log(`[install] [dry-run] Would write hooks -> ${targetHooksPath}`); + } else { + fs.writeFileSync(targetHooksPath, hooksContent, "utf8"); + console.log(`[install] Successfully wrote hooks -> ${targetHooksPath}`); + } + + // Install mcp_config.json + const templateMcpPath = path.join(pluginRoot, "mcp_config.json"); + if (fs.existsSync(templateMcpPath)) { + const rawMcp = fs.readFileSync(templateMcpPath, "utf8"); + const resolvedMcpStr = rawMcp + .replace(/\$\{PLUGIN_ROOT:-\.?\}/g, normalizedRoot) + .replace(/\$\{PLUGIN_ROOT\}/g, normalizedRoot) + .replace(/__PLUGIN_ROOT__/g, normalizedRoot); + + const mcpTemplate = JSON.parse(resolvedMcpStr); + const targetMcpPath = path.join(targetAgentsDir, "mcp_config.json"); + + let finalMcp = mcpTemplate; + if (fs.existsSync(targetMcpPath)) { + backupFile(targetMcpPath, dryRun); + try { + const existingMcp = JSON.parse(fs.readFileSync(targetMcpPath, "utf8")); + finalMcp = { + ...existingMcp, + mcpServers: { + ...(existingMcp.mcpServers || {}), + ...(mcpTemplate.mcpServers || {}), + }, + }; + } catch (e) { + console.warn(`[install] Warning: existing mcp_config.json was invalid JSON, overwriting: ${e.message}`); + } + } + + const mcpContent = JSON.stringify(finalMcp, null, 2) + "\n"; + if (dryRun) { + console.log(`[install] [dry-run] Would write MCP config -> ${targetMcpPath}`); + } else { + fs.writeFileSync(targetMcpPath, mcpContent, "utf8"); + console.log(`[install] Successfully wrote MCP config -> ${targetMcpPath}`); + } + } + + console.log(`[install] Workspace configuration complete.`); + return { targetHooksPath, targetAgentsDir }; +} + +/** + * 2. Install as Global Plugin Bundle (~/.gemini/config/plugins/everos/) + */ +export function installGlobalPlugin({ dryRun = false } = {}) { + const globalPluginsDir = path.join(os.homedir(), ".gemini", "config", "plugins"); + const targetPluginDir = path.join(globalPluginsDir, "everos"); + + console.log(`\n--- [Global Plugin Bundle Mode] ---`); + console.log(`[install] Source: ${pluginRoot}`); + console.log(`[install] Destination: ${targetPluginDir}`); + + if (dryRun) { + console.log(`[install] [dry-run] Would deploy global plugin to ${targetPluginDir}`); + return; + } + + if (!fs.existsSync(targetPluginDir)) { + fs.mkdirSync(targetPluginDir, { recursive: true }); + } + + // Copy bundle items (excluding tests, fixtures, node_modules) + const itemsToCopy = [ + "plugin.json", + "package.json", + "hooks.json", + "mcp_config.json", + "README.md", + "README_zh.md", + "hooks", + "skills", + "mcp", + "scripts", + ]; + + for (const item of itemsToCopy) { + const src = path.join(pluginRoot, item); + const dest = path.join(targetPluginDir, item); + if (!fs.existsSync(src)) continue; + + const stat = fs.statSync(src); + if (stat.isDirectory()) { + fs.cpSync(src, dest, { recursive: true, force: true }); + } else { + fs.copyFileSync(src, dest); + } + } + + console.log(`[install] Successfully deployed global plugin to ${targetPluginDir}`); + console.log(`[install] Antigravity will automatically load it on next launch with full \${PLUGIN_ROOT} resolution.`); +} + +/** + * 3. Register as Native Antigravity Sidecar (~/.gemini/config/sidecars/everos/sidecar.json) + */ +export function registerSidecar({ pythonPath = null, dryRun = false } = {}) { + const sidecarDir = path.join(os.homedir(), ".gemini", "config", "sidecars", "everos"); + const sidecarJsonPath = path.join(sidecarDir, "sidecar.json"); + + console.log(`\n--- [Native Sidecar Daemon Mode] ---`); + console.log(`[install] Sidecar Directory: ${sidecarDir}`); + + let resolvedPython = pythonPath; + if (!resolvedPython) { + // Probe local venv in EverOS or parent workspace + const candidateEverosExe = path.resolve(pluginRoot, "..", "..", "EverOS", ".venv", "Scripts", "everos.exe"); + if (fs.existsSync(candidateEverosExe)) { + resolvedPython = candidateEverosExe; + } else { + const candidates = [ + path.resolve(pluginRoot, "..", "..", "EverOS", ".venv", "Scripts", "python.exe"), + path.resolve(pluginRoot, "..", "..", "EverOS", ".venv", "bin", "python"), + path.resolve(pluginRoot, "..", "..", ".venv", "Scripts", "python.exe"), + path.resolve(pluginRoot, "..", "..", ".venv", "bin", "python"), + ]; + for (const c of candidates) { + if (fs.existsSync(c)) { + resolvedPython = c; + break; + } + } + } + if (!resolvedPython) { + resolvedPython = "everos"; + } + } + + console.log(`[install] Using Executable: ${resolvedPython}`); + + const isExe = resolvedPython.endsWith("everos.exe") || resolvedPython.endsWith("everos"); + const sidecarConfig = { + command: normalizePath(resolvedPython), + args: isExe ? ["server", "start"] : ["-m", "everos.entrypoints.cli.main", "server", "start"], + restart_policy: "always", + description: "EverOS Cognitive Memory Engine (Native Antigravity Sidecar)", + }; + + const content = JSON.stringify(sidecarConfig, null, 2) + "\n"; + if (dryRun) { + console.log(`[install] [dry-run] Would write sidecar.json:\n${content}`); + return; + } + + if (!fs.existsSync(sidecarDir)) { + fs.mkdirSync(sidecarDir, { recursive: true }); + } + + backupFile(sidecarJsonPath, dryRun); + fs.writeFileSync(sidecarJsonPath, content, "utf8"); + console.log(`[install] Successfully registered EverOS sidecar -> ${sidecarJsonPath}`); + console.log(`[install] Antigravity engine will automatically supervise EverOS daemon.`); +} + +// CLI entrypoint +if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) { + const options = parseArgs(process.argv.slice(2)); + + if (options.help) { + console.log(`EverOS Antigravity Plugin Installer +Usage: + node scripts/install.mjs [options] + +Modes & Options: + -w, --workspace Install to specific workspace .agents/ (Default: current directory) + -g, --global Install as standard Global Plugin Bundle to ~/.gemini/config/plugins/everos/ + -s, --sidecar Register EverOS as an Antigravity background sidecar daemon + -p, --python Explicit python interpreter path for sidecar mode + --dry-run Print generated configs without writing files + -h, --help Show this help message + +Quick AI Agent Install Prompt: + "Please run: node F:/ArtEmis/EverPlugins/antigravity/scripts/install.mjs -g -s" +`); + process.exit(0); + } + + try { + if (options.global) { + installGlobalPlugin({ dryRun: options.dryRun }); + } + if (options.sidecar) { + registerSidecar({ pythonPath: options.python, dryRun: options.dryRun }); + } + if (options.workspace) { + installToWorkspace(options.workspace, { dryRun: options.dryRun }); + } + } catch (err) { + console.error(`[install] Error: ${err.message}`); + process.exit(1); + } +} diff --git a/antigravity/scripts/live-verify.js b/antigravity/scripts/live-verify.js new file mode 100644 index 0000000..a1f0e31 --- /dev/null +++ b/antigravity/scripts/live-verify.js @@ -0,0 +1,447 @@ +#!/usr/bin/env node + +/** + * EverOS Antigravity Plugin — Phase 5 Live Verification & Smoke Suite + * + * Simulates a full, real Antigravity IDE lifecycle run inside the isolated sandbox: + * 1. Probes EverOS backend (uses live instance if running on 8000, or starts high-fidelity mock); + * 2. Executes SessionStart (health check, stale sweep, L1 profile injection); + * 3. Executes PreInvocation (double-lock check, dual-track search, L2 ephemeral memory injection); + * 4. Executes Stop (byte-offset incremental slicing, thinking stripping, Dummy Tool Synth, 2PC Add); + * 5. Executes /everos status diagnostics CLI; + * 6. Executes /everos flush (2PC final seal); + * 7. Verifies MCP Server JSON-RPC 2.0 stdio communication (initialize, tools/list, tools/call); + * 8. Prints an executive verification evidence report. + */ + +import fs from "node:fs"; +import path from "node:path"; +import os from "node:os"; +import { fileURLToPath } from "node:url"; +import { spawn } from "node:child_process"; +import readline from "node:readline"; +import { startFakeEveros } from "../tests/helpers/fake-everos.js"; +import { loadSessionState } from "../hooks/scripts/lib/state.js"; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = path.dirname(__filename); +const pluginRoot = path.resolve(__dirname, ".."); +const sandboxDir = path.join(pluginRoot, "tests", "fixtures", "live-sandbox"); + +// Colors for terminal output +const BOLD = "\x1b[1m"; +const GREEN = "\x1b[32m"; +const YELLOW = "\x1b[33m"; +const CYAN = "\x1b[36m"; +const RED = "\x1b[31m"; +const RESET = "\x1b[0m"; + +function logStep(stepNum, title) { + console.log(`\n${BOLD}${CYAN}[Step ${stepNum}] ${title}${RESET}`); +} + +function logSuccess(msg) { + console.log(` ${GREEN}✔${RESET} ${msg}`); +} + +function logWarn(msg) { + console.log(` ${YELLOW}⚠${RESET} ${msg}`); +} + +function logError(msg) { + console.log(` ${RED}✖${RESET} ${msg}`); +} + +function runSubprocess(cmd, args, options = {}, stdinData = null) { + return new Promise((resolve, reject) => { + const start = Date.now(); + const child = spawn(cmd, args, { + ...options, + stdio: ["pipe", "pipe", "pipe"], + }); + + let stdout = ""; + let stderr = ""; + + child.stdout.on("data", (c) => (stdout += c)); + child.stderr.on("data", (c) => (stderr += c)); + + if (stdinData !== null && stdinData !== undefined) { + const payload = typeof stdinData === "string" ? stdinData : JSON.stringify(stdinData); + child.stdin.write(payload, "utf8"); + child.stdin.end(); + } else { + child.stdin.end(); + } + + child.on("close", (code) => { + resolve({ + code, + stdout, + stderr, + durationMs: Date.now() - start, + }); + }); + + child.on("error", reject); + }); +} + +async function probeBackend(baseUrl) { + try { + const res = await fetch(`${baseUrl}/health`, { + signal: AbortSignal.timeout(1000), + }); + return res.ok; + } catch { + return false; + } +} + +function getHookCommand(hooksManifest, eventName) { + const container = hooksManifest?.["everos-antigravity"] || hooksManifest?.hooks || hooksManifest; + const list = container?.[eventName]; + if (!Array.isArray(list) || list.length === 0 || !list[0]?.command) { + throw new Error(`hooks.json missing hook command for ${eventName}`); + } + let rawCmd = list[0].command; + rawCmd = rawCmd + .replaceAll("${PLUGIN_ROOT:-.}", pluginRoot) + .replaceAll("${PLUGIN_ROOT}", pluginRoot); + const parts = []; + const regex = /[^\s"']+|"([^"]*)"|'([^']*)'/g; + let match; + while ((match = regex.exec(rawCmd)) !== null) { + parts.push(match[1] || match[2] || match[0]); + } + return { + exec: parts[0] === "node" ? process.execPath : parts[0], + args: parts.slice(1), + }; +} + +async function main() { + console.log(`${BOLD}========================================================================${RESET}`); + console.log(`${BOLD} EverOS for Google Antigravity — Phase 5 Live Verification Suite ${RESET}`); + console.log(`${BOLD}========================================================================${RESET}`); + + const startTime = Date.now(); + const testDataDir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-live-verify-")); + const conversationId = `live_session_${Date.now()}`; + const transcriptPath = path.join(sandboxDir, "live_transcript.jsonl"); + + let fakeServer = null; + let baseUrl = process.env.EVEROS_AG_BASE_URL || "http://127.0.0.1:8000"; + + // Step 1: Probe Backend + logStep(1, "Probing EverOS Cognitive Engine backend..."); + const isLiveOnline = await probeBackend(baseUrl); + + if (isLiveOnline) { + logSuccess(`Detected REAL EverOS engine online at ${baseUrl}`); + } else { + logWarn(`No live EverOS found at ${baseUrl}. Launching high-fidelity mock backend for isolated stage 1...`); + fakeServer = await startFakeEveros({ + searchFn: (body) => { + return { + episodes: [ + { + subject: "Windows Natural Drain", + summary: "Windows 11 requires process.exitCode = 0 to prevent pipe truncation", + atomic_facts: ["process.exit(0) kills stdout buffer prematurely"], + }, + ], + agent_cases: [ + { + task_intent: "Subprocess Pipe Conformance", + key_insight: "Always wrap stdin/stdout with TTY and natural drain guards", + }, + ], + profile: { + profile_data: { + explicit_info: { + dependencies: "zero-dep pure ESM only", + exit_protocol: "natural drain via process.exitCode = 0", + }, + implicit_traits: [ + "Demands test-driven development (TDD)", + "Prefers deep modules and defensive programming", + ], + }, + }, + }; + }, + }); + baseUrl = fakeServer.baseUrl; + logSuccess(`High-fidelity mock engine running at ${baseUrl}`); + } + + const baseEnv = { + ...process.env, + EVEROS_AG_BASE_URL: baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_PROJECT_ID: "github.com_sandbox_demo", + EVEROS_AG_USER_ID: "live_developer", + EVEROS_AG_LOCALE: "zh", + }; + + // Verify hooks.json exists and is readable (D1-07) + const hooksConfigPath = path.join(pluginRoot, "hooks.json"); + if (!fs.existsSync(hooksConfigPath)) { + throw new Error(`Critical manifest missing: hooks.json not found at ${hooksConfigPath}`); + } + const hooksManifest = JSON.parse(fs.readFileSync(hooksConfigPath, "utf8")); + + try { + // Step 2: SessionStart (L1 Profile Injection) + logStep(2, "Simulating SessionStart lifecycle trigger via hooks.json command..."); + const sessionStartCmd = getHookCommand(hooksManifest, "SessionStart"); + const sessionStartRes = await runSubprocess( + sessionStartCmd.exec, + sessionStartCmd.args, + { cwd: sandboxDir, env: baseEnv }, + { + conversationId, + workspacePaths: [sandboxDir], + transcriptPath, + } + ); + + if (sessionStartRes.code !== 0) { + throw new Error(`session-start exited with code ${sessionStartRes.code}: ${sessionStartRes.stderr}`); + } + + const sessionStartOutput = JSON.parse(sessionStartRes.stdout.trim() || "{}"); + const injectedProfile = sessionStartOutput?.injectSteps?.[0]?.systemMessage?.systemMessage || ""; + if (!injectedProfile.includes("")) { + throw new Error(`SessionStart failed to inject ! Output: ${sessionStartRes.stdout}`); + } + if (!injectedProfile.includes("【既定规约】") || !injectedProfile.includes("【意趣默契】")) { + throw new Error(`SessionStart profile lacks prescriptive covenants or tacit affinities anchors!`); + } + logSuccess(`SessionStart completed in ${sessionStartRes.durationMs}ms`); + logSuccess(`L1 Profile Injected cleanly into System Instructions (size: ${injectedProfile.length} chars)`); + + // Step 3: Write initial turn into transcript and test PreInvocation + logStep(3, "Writing turn 1 user prompt to transcript and invoking PreInvocation (L2 Recall)..."); + const turn1UserEntry = { + step_index: 0, + type: "USER_INPUT", + source: "USER_EXPLICIT", + created_at: new Date().toISOString(), + content: "How should we handle stdout pipe drain in Windows 11 Node.js?", + }; + fs.writeFileSync(transcriptPath, JSON.stringify(turn1UserEntry) + "\n", "utf8"); + + const recallCmd = getHookCommand(hooksManifest, "PreInvocation"); + const recallRes = await runSubprocess( + recallCmd.exec, + recallCmd.args, + { cwd: sandboxDir, env: baseEnv }, + { + invocationNum: 1, + conversationId, + workspacePaths: [sandboxDir], + transcriptPath, + } + ); + + if (recallRes.code !== 0) { + throw new Error(`recall.js exited with code ${recallRes.code}: ${recallRes.stderr}`); + } + + const recallOutput = JSON.parse(recallRes.stdout.trim() || "{}"); + const injectedMemory = recallOutput?.injectSteps?.[0]?.ephemeralMessage || ""; + if (!injectedMemory.includes("")) { + throw new Error(`PreInvocation failed to inject ! Output: ${recallRes.stdout}`); + } + if (!injectedMemory.includes("【曾有范例】") && !injectedMemory.includes("【交互脉络】")) { + throw new Error(`PreInvocation memory lacks valid anchors!`); + } + logSuccess(`PreInvocation completed in ${recallRes.durationMs}ms`); + logSuccess(`L2 Ephemeral Memory injected (Single-turn ephemeral, size: ${injectedMemory.length} chars)`); + + // Verify Double-Lock: Calling PreInvocation again in the same turn must be a 0ms no-op + const recallRepeatRes = await runSubprocess( + recallCmd.exec, + recallCmd.args, + { cwd: sandboxDir, env: baseEnv }, + { + invocationNum: 2, + conversationId, + workspacePaths: [sandboxDir], + transcriptPath, + } + ); + const repeatOutput = JSON.parse(recallRepeatRes.stdout.trim() || "{}"); + if (Object.keys(repeatOutput).length !== 0) { + throw new Error(`PreInvocation double-lock failed! Repeated call returned non-empty instructions.`); + } + logSuccess(`PreInvocation double-lock verified: repeated invocation in same turn returned {} (0ms overhead)`); + + // Step 4: Assistant response, Tool call with Dummy Tool Synth, and Stop Hook + logStep(4, "Simulating assistant thinking, tool call, and invoking Stop Hook (2PC Capture)..."); + const assistantStep = { + step_index: 1, + type: "PLANNER_RESPONSE", + created_at: new Date().toISOString(), + thinking: "Internal thinking process that must be stripped from long-term memory...", + content: "Let's inspect the process exit handler.", + tool_calls: [ + { + name: "invoke_subagent", + args: { + role: "PipeAuditor", + prompt: "Inspect stdout stream", + conversationId: "subagent_live_01", + TypeName: "research", + }, + }, + ], + }; + // Simulate user interruption: tool result is missing (GENERIC never arrives) + fs.appendFileSync(transcriptPath, JSON.stringify(assistantStep) + "\n", "utf8"); + + const stopCmd = getHookCommand(hooksManifest, "Stop"); + const captureRes = await runSubprocess( + stopCmd.exec, + stopCmd.args, + { cwd: sandboxDir, env: baseEnv }, + { + terminationReason: "NO_TOOL_CALL", + conversationId, + workspacePaths: [sandboxDir], + transcriptPath, + } + ); + + if (captureRes.code !== 0) { + throw new Error(`capture.js exited with code ${captureRes.code}: ${captureRes.stderr}`); + } + logSuccess(`Stop Hook completed in ${captureRes.durationMs}ms`); + + // Verify state progression + const state = loadSessionState(testDataDir, conversationId); + if (state.settled_turn_index !== 1) { + throw new Error(`2PC settlement failed: settled_turn_index expected 1, got ${state.settled_turn_index}`); + } + if (typeof state.last_read_byte_offset !== "number" || state.last_read_byte_offset <= 0) { + throw new Error(`Incremental byte offset cursor not advanced! Got: ${state.last_read_byte_offset}`); + } + logSuccess(`2PC Ingestion Succeeded: settled_turn_index advanced to 1`); + logSuccess(`Byte offset cursor recorded: ${state.last_read_byte_offset} bytes`); + + // Step 5: Test /everos status CLI + logStep(5, "Testing unified CLI diagnostic console (/everos status)..."); + const cliStatusRes = await runSubprocess( + process.execPath, + [path.join(pluginRoot, "skills", "everos", "cli.js"), "status"], + { cwd: sandboxDir, env: baseEnv } + ); + if (cliStatusRes.code !== 0) { + throw new Error(`CLI status failed: ${cliStatusRes.stderr}`); + } + if (!cliStatusRes.stdout.includes("EverOS Memory Engine for Google Antigravity")) { + throw new Error(`CLI status output missing header! Output: ${cliStatusRes.stdout}`); + } + logSuccess(`CLI status executed in ${cliStatusRes.durationMs}ms`); + logSuccess(`Diagnostic banner output verified (Connection, Project, User, Branch, Stale sessions)`); + + // Step 6: Test /everos flush (Explicit 2PC Seal) + logStep(6, "Testing 2PC manual seal (/everos flush)..."); + const cliFlushRes = await runSubprocess( + process.execPath, + [path.join(pluginRoot, "skills", "everos", "cli.js"), "flush"], + { cwd: sandboxDir, env: baseEnv } + ); + if (cliFlushRes.code !== 0) { + throw new Error(`CLI flush failed: ${cliFlushRes.stderr}`); + } + const finalState = loadSessionState(testDataDir, conversationId); + if (finalState.flushed !== true) { + throw new Error(`Session state flushed expected true, got: ${finalState.flushed}`); + } + logSuccess(`CLI flush executed in ${cliFlushRes.durationMs}ms`); + logSuccess(`Session marked flushed: true in local 2PC ledger`); + + // Step 7: Test Native MCP Server JSON-RPC 2.0 stdio + logStep(7, "Testing native stdio MCP Server (mcp/server.js)..."); + const mcpChild = spawn(process.execPath, [path.join(pluginRoot, "mcp", "server.js")], { + cwd: sandboxDir, + env: baseEnv, + stdio: ["pipe", "pipe", "pipe"], + }); + + const rl = readline.createInterface({ input: mcpChild.stdout, terminal: false }); + const pendingMcp = new Map(); + rl.on("line", (line) => { + try { + const msg = JSON.parse(line.trim()); + if (msg.id !== undefined && pendingMcp.has(msg.id)) { + const { resolve } = pendingMcp.get(msg.id); + pendingMcp.delete(msg.id); + resolve(msg); + } + } catch {} + }); + + let mcpReqId = 1; + function callMcp(method, params = {}) { + return new Promise((resolve, reject) => { + const id = mcpReqId++; + pendingMcp.set(id, { resolve, reject }); + mcpChild.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n", "utf8"); + }); + } + + // Handshake + const initRes = await callMcp("initialize"); + if (initRes.result?.serverInfo?.name !== "everos-antigravity") { + throw new Error(`MCP initialize returned unexpected serverInfo: ${JSON.stringify(initRes)}`); + } + logSuccess(`MCP handshake completed (protocol: ${initRes.result?.protocolVersion})`); + + // List tools + const listRes = await callMcp("tools/list"); + const toolNames = (listRes.result?.tools || []).map((t) => t.name); + if (!toolNames.includes("everos_search_memory") || !toolNames.includes("everos_get_profile")) { + throw new Error(`MCP tools/list missing core tools! Found: ${toolNames.join(", ")}`); + } + logSuccess(`MCP tools/list verified: ${toolNames.join(", ")}`); + + // Call tool: everos_get_profile + const toolCallRes = await callMcp("tools/call", { + name: "everos_get_profile", + arguments: {}, + }); + if (toolCallRes.result?.isError !== false) { + throw new Error(`MCP everos_get_profile returned error: ${JSON.stringify(toolCallRes)}`); + } + logSuccess(`MCP everos_get_profile successfully executed and rendered markdown`); + + mcpChild.kill(); + logSuccess(`MCP Server safely closed with 0 stdio pollution`); + + // Step 8: Final Summary + const totalDuration = Date.now() - startTime; + console.log(`\n${BOLD}========================================================================${RESET}`); + console.log(` ${GREEN}${BOLD}✔ ALL 7 STAGES OF LIVE VERIFICATION PASSED SUCCESSFULLY!${RESET}`); + console.log(` Total verification duration: ${totalDuration}ms`); + console.log(` Environment: Windows 11 Node.js ${process.version}`); + console.log(` Workspace: ${sandboxDir}`); + console.log(`${BOLD}========================================================================${RESET}\n`); + } finally { + if (fakeServer) { + fakeServer.close(); + } + try { + if (fs.existsSync(transcriptPath)) fs.unlinkSync(transcriptPath); + fs.rmSync(testDataDir, { recursive: true, force: true }); + } catch {} + } +} + +main().catch((err) => { + console.error(`\n${RED}${BOLD}✖ LIVE VERIFICATION FAILED:${RESET}`, err); + process.exit(1); +}); diff --git a/antigravity/scripts/seed-demo.js b/antigravity/scripts/seed-demo.js new file mode 100644 index 0000000..0834264 --- /dev/null +++ b/antigravity/scripts/seed-demo.js @@ -0,0 +1,69 @@ +import { createClient } from "../hooks/scripts/lib/everos.js"; + +async function seed() { + const client = createClient({ baseUrl: "http://127.0.0.1:8000" }); + const projectId = "antigravity-demo"; + const now = Date.now(); + + console.log("Adding case conversation to EverOS..."); + await client.add({ + session_id: "seed-session-002-case", + project_id: projectId, + app_id: "antigravity", + messages: [ + { + sender_id: "developer", + sender_name: "Developer", + role: "user", + timestamp: now - 15000, + content: "我们在 Windows 11 环境下遇到了 NTFS 瞬态并发写锁 EBUSY 问题，以及子进程管道截断导致输出丢失。你是怎么彻底解决的？", + }, + { + sender_id: "antigravity_assistant", + sender_name: "Antigravity Assistant", + role: "assistant", + timestamp: now - 10000, + content: "我们在 atomicWriteFileSync 中引入了多层防御：1. 使用 pid + 时间戳 + 随机数命名临时文件；2. renameSync 遇 EBUSY/EACCES 时，采用 Atomics.wait 结合 Int32Array 挂起当前线程 10ms 进行退避重试，最多重试 3 次；3. 退出时严格使用 process.exitCode = 0，确保 Node.js 事件循环自然排空 stdout 管道，彻底根绝了 Windows 下的输出截断与文件锁死。", + tool_calls: [ + { + id: "call_fix_lock_001", + type: "function", + function: { + name: "edit_file", + arguments: JSON.stringify({ + Path: "state.js", + Target: "fs.renameSync", + Replacement: "retryRenameSync", + }), + }, + }, + ], + }, + { + sender_id: "antigravity_assistant", + sender_name: "Tool Execution", + role: "tool", + tool_call_id: "call_fix_lock_001", + timestamp: now - 5000, + content: JSON.stringify({ success: true, retries: 1, duration_ms: 12 }), + }, + { + sender_id: "antigravity_assistant", + sender_name: "Antigravity Assistant", + role: "assistant", + timestamp: now, + content: "复盘总结：该方案已作为我们的【曾有范例】沉淀，在后续遇到类似文件并发或管道排空场景时直接复用此模式。", + }, + ], + }); + + console.log("Flushing case session..."); + const flushRes = await client.flush({ + session_id: "seed-session-002-case", + project_id: projectId, + app_id: "antigravity", + }); + console.log("Flush result:", JSON.stringify(flushRes)); +} + +seed().catch(console.error); diff --git a/antigravity/skills/everos-flush/SKILL.md b/antigravity/skills/everos-flush/SKILL.md new file mode 100644 index 0000000..e568fc3 --- /dev/null +++ b/antigravity/skills/everos-flush/SKILL.md @@ -0,0 +1,17 @@ +--- +name: everos-flush +description: 立即将当前工程的最新会话与沉淀记忆提交封箱（两阶段提交 2PC），安全触发 EverOS 后台知识萃取与长期画像演进更新。支持 /everos flush 与 /everos-flush 快捷调用。 +--- + +# EverOS Fast Seal & Flush + +手动显式触发当前工程的记忆封箱。驱动脚本位于 [cli.js](../everos/cli.js)。 + +## 执行指令 + +执行底层两阶段提交封箱脚本： +```bash +node "${PLUGIN_ROOT}/skills/everos/cli.js" flush +``` + +向用户报告封箱确认结果（HTTP 200 Ack 或 Nack 容灾提示）。 diff --git a/antigravity/skills/everos-search/SKILL.md b/antigravity/skills/everos-search/SKILL.md new file mode 100644 index 0000000..8e6da3c --- /dev/null +++ b/antigravity/skills/everos-search/SKILL.md @@ -0,0 +1,18 @@ +--- +name: everos-search +description: 在当前工程中检索历史沉淀的长期记忆（包含【既定规约】、【曾有范例】、【交互脉络】等）。 +--- + +# EverOS Memory Search + +本技能用于通过语义与关键词检索当前工作区历史沉淀的工程事实与经验范例。 + +## 执行步骤 + +1. 如果用户提供了检索词（例如 `/everos-search ESM 规约`）： + ```bash + node "${PLUGIN_ROOT}/skills/everos/cli.js" search "<用户检索词>" + ``` +2. 如果用户未提供检索词，先询问用户想检索什么内容，或提示用户输入检索关键字。 +3. **输出规范**： + 直接将 CLI 检索到的 Markdown 格式记忆卡片呈现给用户。 diff --git a/antigravity/skills/everos-status/SKILL.md b/antigravity/skills/everos-status/SKILL.md new file mode 100644 index 0000000..a6f97e0 --- /dev/null +++ b/antigravity/skills/everos-status/SKILL.md @@ -0,0 +1,17 @@ +--- +name: everos-status +description: 查看 EverOS 长期记忆引擎的连接状态、当前工程空间分区、用户信息与待补偿会话诊断看板。 +--- + +# EverOS Status Diagnostic Console + +本技能用于即时输出 EverOS 记忆引擎的健康诊断看板。 + +## 执行步骤 + +1. 立即执行自检驱动： + ```bash + node "${PLUGIN_ROOT}/skills/everos/cli.js" status + ``` +2. **输出规范**： + 直接将命令的标准输出以代码块或原生文本原样呈现给用户，不要添加任何冗余的寒暄或多余的解释。 diff --git a/antigravity/skills/everos/SKILL.md b/antigravity/skills/everos/SKILL.md new file mode 100644 index 0000000..3cc2680 --- /dev/null +++ b/antigravity/skills/everos/SKILL.md @@ -0,0 +1,41 @@ +--- +name: everos +description: EverOS 智能记忆引擎统一运维总控台。提供当前工程记忆健康状态自检、手动两阶段提交封箱（flush）与自然语言记忆检索（search）。输入 /everos 呼出控制台分流面板。 +--- + +# EverOS Memory Engine Unified Console + +EverOS 为 Google Antigravity 提供跨会话的自进化长期记忆与工程规约。执行驱动位于 [cli.js](cli.js)。 + +## 命令调度与交互分流规约 + +根据用户附带的子参数调度执行 [cli.js](cli.js)： + +### 1. 无参裸敲 `/everos`：呼出统一指令分流窗口 +如果用户输入了 `/everos` 且未提供明确的子指令，若宿主提供交互式问答工具（如 `ask_question`）则呼出原生交互式分流窗口，否则默认执行状态自检并提示用户选择期望的操作： +- 选项 1: `查看当前工程记忆引擎健康状态 (/everos status)` +- 选项 2: `执行当前会话两阶段提交封箱 (/everos flush)` +- 选项 3: `检索历史工程沉淀架构决策与范例 (/everos search)` + +用户做出选择后，直接执行对应分支。 + +### 2. 状态自检: `/everos status` +立即执行： +```bash +node "${PLUGIN_ROOT}/skills/everos/cli.js" status +``` +直接原样向用户输出返回的诊断看板。 + +### 3. 两阶段封箱: `/everos flush` +立即执行两阶段提交封箱： +```bash +node "${PLUGIN_ROOT}/skills/everos/cli.js" flush +``` +向用户展示两阶段提交与后台萃取调度状态。 + +### 4. 记忆检索: `/everos search <关键词>` +立即执行检索： +```bash +node "${PLUGIN_ROOT}/skills/everos/cli.js" search "<关键词>" +``` +若用户追加了 `--raw` 参数，传递 `--raw` 获取原始 JSON。 diff --git a/antigravity/skills/everos/cli.js b/antigravity/skills/everos/cli.js new file mode 100644 index 0000000..56c062a --- /dev/null +++ b/antigravity/skills/everos/cli.js @@ -0,0 +1,237 @@ +#!/usr/bin/env node +import fs from "node:fs"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +const __dirname = path.dirname(fileURLToPath(import.meta.url)); + +function resolveLib(relPath) { + const local = path.resolve(__dirname, "../../hooks/scripts/lib", relPath); + if (fs.existsSync(local)) return local; + const envRoot = process.env.EVEROS_AG_PLUGIN_ROOT; + if (envRoot && fs.existsSync(path.resolve(envRoot, "hooks/scripts/lib", relPath))) { + return path.resolve(envRoot, "hooks/scripts/lib", relPath); + } + return local; +} + +function importLib(relPath) { + const p = resolveLib(relPath).replace(/\\/g, "/"); + return import(`file:///${p}`); +} + +const { loadConfig } = await importLib("config.js"); +const { resolveIdentity } = await importLib("identity.js"); +const { createClient } = await importLib("everos.js"); +const { dualTrackSearch } = await importLib("search-tracks.js"); +const { + listStaleSessions, + loadSessionState, + saveSessionState, + markFlushed, +} = await importLib("state.js"); +const { renderProfileBlock, renderMemoryBlock } = await importLib("render.js"); +const { FLUSH_DISPATCH_MS } = await importLib("constants.js"); + +const config = loadConfig(); +const identity = resolveIdentity(process.cwd(), config); +const client = createClient({ baseUrl: config.baseUrl }); + +function formatPad(label, width = 16) { + return label.padEnd(width, " "); +} + +/** + * Handle `status` subcommand + */ +async function handleStatus() { + const lines = []; + lines.push("══════════════════════════════════════════════════════════"); + lines.push(" EverOS Memory Engine for Google Antigravity - Status "); + lines.push("══════════════════════════════════════════════════════════"); + lines.push(""); + + // 1. Service Health + try { + const health = await client.health(AbortSignal.timeout(2000)); + lines.push(`${formatPad("Server Status")} 🟢 Online (HTTP 200)`); + lines.push(`${formatPad("Base URL")} ${config.baseUrl}`); + if (health?.version) { + lines.push(`${formatPad("EverOS Version")} ${health.version}`); + } + } catch (err) { + lines.push(`${formatPad("Server Status")} 🔴 Offline / Unreachable (${err?.message || err})`); + lines.push(`${formatPad("Base URL")} ${config.baseUrl}`); + } + + lines.push(""); + + // 2. Spatial Scope & Identity + lines.push(`${formatPad("App Partition")} ${identity.appId}`); + lines.push(`${formatPad("Project ID")} ${identity.projectId}`); + lines.push(`${formatPad("Git Branch")} ${identity.branch}`); + lines.push(`${formatPad("User ID")} ${identity.userId || "[not set: personal track disabled]"}`); + lines.push(`${formatPad("Agent ID")} ${identity.agentId}`); + lines.push(`${formatPad("Locale")} ${config.locale}`); + lines.push(`${formatPad("Search Method")} ${config.searchMethod}`); + + lines.push(""); + + // 3. Data Directory & Sessions + let dirWritable = false; + try { + fs.mkdirSync(config.dataDir, { recursive: true }); + const probe = path.join(config.dataDir, `.probe_${process.pid}`); + fs.writeFileSync(probe, ""); + fs.unlinkSync(probe); + dirWritable = true; + } catch { + dirWritable = false; + } + + lines.push(`${formatPad("Data Directory")} ${config.dataDir} (${dirWritable ? "writable" : "READ ONLY / PERM ERROR"})`); + + const stale = listStaleSessions(config.dataDir); + lines.push(`${formatPad("Idle Sessions")} ${stale.length} pending 2PC flush sweep`); + + if (Array.isArray(config.warnings) && config.warnings.length > 0) { + lines.push(""); + lines.push("Configuration Warnings:"); + for (const w of config.warnings) { + lines.push(` ⚠️ ${w}`); + } + } + + lines.push(""); + lines.push("Commands available:"); + lines.push(" /everos status - Re-run this diagnostic report"); + lines.push(" /everos flush - Seal and extract current project memory"); + lines.push(" /everos search - Search engineering memories"); + + return lines.join("\n"); +} + +/** + * Handle `flush` subcommand + */ +async function handleFlush(targetConversationId) { + let conversationId = targetConversationId; + // If not explicitly specified, auto-discover the most recent unflushed session for this project + if (!conversationId || conversationId === "default") { + try { + const candidates = listStaleSessions(config.dataDir, 0).filter( + (s) => s.project_id === identity.projectId && s.flushed !== true + ); + if (candidates.length > 0) { + candidates.sort((a, b) => (b.updated_at || 0) - (a.updated_at || 0)); + conversationId = candidates[0].session_id; + } else { + conversationId = "default"; + } + } catch { + conversationId = "default"; + } + } + + const state = loadSessionState(config.dataDir, conversationId, { + projectId: identity.projectId, + branch: identity.branch, + userId: identity.userId, + agentId: identity.agentId, + }); + + const lines = []; + lines.push(`Initiating 2PC memory seal for project '${identity.projectId}' (session: '${conversationId}')...`); + + try { + await client.flush( + { + app_id: identity.appId, + session_id: conversationId, + project_id: identity.projectId, + }, + AbortSignal.timeout(FLUSH_DISPATCH_MS) + ); + + markFlushed(state, true); + saveSessionState(config.dataDir, state); + + lines.push("✅ 2PC Flush Acknowledged (HTTP 200)."); + lines.push(`Session state for '${conversationId}' marked flushed: true.`); + lines.push("EverOS background extraction pipeline dispatched successfully."); + } catch (err) { + lines.push(`❌ Flush deferred: ${err?.message || err}`); + lines.push("Session state left unflushed (Nack) to be compensated by next session start sweep."); + } + + return lines.join("\n"); +} + +/** + * Handle `search` subcommand + */ +async function handleSearch(args) { + const rawFlag = args.includes("--raw"); + const queryWords = args.filter((a) => a !== "--raw"); + const query = queryWords.join(" ").trim(); + + if (!query) { + return "Error: Please provide a search query. Example: /everos search event bus design"; + } + + const TIMEOUT_MS = Math.min(Math.max(config.recallTimeoutMs || 5000, 500), 10000); + const merged = await dualTrackSearch(client, { + identity, + query, + config, + topK: 5, + includeProfile: true, + signal: AbortSignal.timeout(TIMEOUT_MS), + }); + + if (rawFlag) { + return JSON.stringify(merged, null, 2); + } + + const rendered = renderMemoryBlock(merged, { + projectId: identity.projectId, + branch: identity.branch, + locale: config.locale, + }); + + return rendered || `No memories found matching "${query}".`; +} + +/** + * Main router + */ +async function main() { + const args = process.argv.slice(2); + const command = (args[0] || "").toLowerCase(); + + switch (command) { + case "status": + console.log(await handleStatus()); + break; + + case "flush": + console.log(await handleFlush(args[1] || "default")); + break; + + case "search": + console.log(await handleSearch(args.slice(1))); + break; + + case "help": + case "-h": + case "--help": + default: + console.log(await handleStatus()); + break; + } +} + +main().catch((err) => { + console.error(`[everos-cli] Fatal: ${err?.message || err}`); + process.exitCode = 1; +}); diff --git a/antigravity/tests/capture-chunk.test.js b/antigravity/tests/capture-chunk.test.js new file mode 100644 index 0000000..8493250 --- /dev/null +++ b/antigravity/tests/capture-chunk.test.js @@ -0,0 +1,87 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { startFakeEveros } from "./helpers/fake-everos.js"; +import { runHookScript } from "./helpers/run-hook.js"; +import { getSessionFilePath } from "../hooks/scripts/lib/state.js"; + +function buildTranscript(file, steps) { + const lines = [ + JSON.stringify({ + step_index: 0, + type: "USER_INPUT", + source: "USER_EXPLICIT", + content: "heavy batch test", + }), + ]; + for (let i = 1; i <= steps; i++) { + lines.push( + JSON.stringify({ + step_index: i, + type: "PLANNER_RESPONSE", + content: `step ${i}`, + }) + ); + } + fs.writeFileSync(file, lines.join("\n") + "\n", "utf8"); +} + +test("capture: multi-chunk retry does not duplicate already acknowledged chunks (D2-01)", async (t) => { + const fake = await startFakeEveros(); + const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-test-chunk-")); + const tDir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-test-tr-")); + const transcript = path.join(tDir, "transcript.jsonl"); + buildTranscript(transcript, 600); // 601 messages -> chunk 1 (500), chunk 2 (101) + + t.after(async () => { + await fake.close(); + fs.rmSync(dataDir, { recursive: true, force: true }); + fs.rmSync(tDir, { recursive: true, force: true }); + }); + + const env = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: dataDir, + EVEROS_AG_PROJECT_ID: "github.com_test_chunk", + EVEROS_AG_USER_ID: "tester", + }; + + // Run 1: Reject second chunk only + let addCalls = 0; + fake.setAddHandler(() => { + addCalls++; + return addCalls === 2 ? "fail" : "ok"; + }); + + const run1 = await runHookScript( + "hooks/scripts/capture.js", + { conversationId: "conv_chunk_test", transcriptPath: transcript }, + env + ); + + assert.equal(run1.code, 0); + assert.equal(fake.only("/api/v2/memory/add").length, 2); + + const stateFile = getSessionFilePath(dataDir, "conv_chunk_test"); + const state1 = JSON.parse(fs.readFileSync(stateFile, "utf8")); + assert.equal(state1.settled_turn_index, -1, "settled_turn_index must not advance on partial failure"); + assert.equal(state1.pending_batch.acked_chunks, 1, "pending_batch.acked_chunks must record 1 chunk succeeded"); + + // Run 2: Backend recovers, retry must NOT re-send chunk 1 + const run2 = await runHookScript( + "hooks/scripts/capture.js", + { conversationId: "conv_chunk_test", transcriptPath: transcript }, + env + ); + + assert.equal(run2.code, 0); + const allAdds = fake.only("/api/v2/memory/add"); + assert.equal(allAdds.length, 3, "Total /add calls across run 1 and 2 must be 3 (run 2 sent only chunk 2)"); + assert.equal(allAdds[2].body.messages.length, 101, "Run 2 must only send chunk 2 (101 messages)"); + + const state2 = JSON.parse(fs.readFileSync(stateFile, "utf8")); + assert.equal(state2.settled_turn_index, 600, "settled_turn_index must advance after full batch completes"); + assert.equal(state2.pending_batch, null, "pending_batch must be cleared after batch completes"); +}); diff --git a/antigravity/tests/config.test.js b/antigravity/tests/config.test.js new file mode 100644 index 0000000..1241dc9 --- /dev/null +++ b/antigravity/tests/config.test.js @@ -0,0 +1,129 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import path from "node:path"; +import { loadConfig, normalizeBaseUrl, splitCommand, isLoopback } from "../hooks/scripts/lib/config.js"; + +const base = { HOME: "/home/tester", USER: "tester" }; + +test("defaults apply when nothing is set", () => { + const c = loadConfig({ ...base }); + assert.equal(c.baseUrl, "http://127.0.0.1:8000"); + assert.equal(c.everosDir, null); + assert.deepEqual(c.startCmd, ["everos", "server", "start"]); + assert.equal(c.userId, "tester"); + assert.equal(c.projectIdOverride, null); + assert.equal(c.verbose, false); + assert.equal(c.locale, "zh"); + assert.equal(c.sources.baseUrl, "default"); + assert.equal(c.sources.locale, "default"); +}); + +test("EVEROS_AG_* beats EVEROS_ANTIGRAVITY_* beats userConfig beats default", () => { + // EVEROS_AG_* takes precedence + const c = loadConfig({ + ...base, + ANTIGRAVITY_PLUGIN_OPTION_BASE_URL: "http://10.0.0.2:9000", + EVEROS_ANTIGRAVITY_BASE_URL: "http://127.0.0.1:8888", + EVEROS_AG_BASE_URL: "http://127.0.0.1:7777", + }); + assert.equal(c.baseUrl, "http://127.0.0.1:7777"); + assert.equal(c.sources.baseUrl, "env (AG)"); + + // EVEROS_ANTIGRAVITY_* takes precedence over userConfig + const d = loadConfig({ + ...base, + ANTIGRAVITY_PLUGIN_OPTION_BASE_URL: "http://10.0.0.2:9000", + EVEROS_ANTIGRAVITY_BASE_URL: "http://127.0.0.1:8888", + }); + assert.equal(d.baseUrl, "http://127.0.0.1:8888"); + assert.equal(d.sources.baseUrl, "env (ANTIGRAVITY)"); + + // userConfig takes precedence over default + const e = loadConfig({ + ...base, + ANTIGRAVITY_PLUGIN_OPTION_BASE_URL: "http://10.0.0.2:9000", + }); + assert.equal(e.baseUrl, "http://10.0.0.2:9000"); + assert.equal(e.sources.baseUrl, "userConfig"); +}); + +test("a blank value never shadows a lower layer", () => { + const c = loadConfig({ + ...base, + EVEROS_AG_BASE_URL: " ", + EVEROS_ANTIGRAVITY_BASE_URL: "http://127.0.0.1:8888", + }); + assert.equal(c.baseUrl, "http://127.0.0.1:8888"); + assert.equal(c.sources.baseUrl, "env (ANTIGRAVITY)"); +}); + +test("normalizeBaseUrl adds a scheme, strips a trailing slash, falls back when unparseable", () => { + assert.equal(normalizeBaseUrl("127.0.0.1:8000"), "http://127.0.0.1:8000"); + assert.equal(normalizeBaseUrl("http://host:1/"), "http://host:1"); + assert.equal(normalizeBaseUrl("http://[bad"), "http://127.0.0.1:8000"); + assert.equal(normalizeBaseUrl(""), "http://127.0.0.1:8000"); +}); + +test("normalizeBaseUrl blocks non-http protocols and null origins", () => { + assert.equal(normalizeBaseUrl("javascript://alert(1)"), "http://127.0.0.1:8000"); + assert.equal(normalizeBaseUrl("file:///etc/passwd"), "http://127.0.0.1:8000"); + assert.equal(normalizeBaseUrl("data:text/plain;base64,SGVsbG8="), "http://127.0.0.1:8000"); +}); + +test("splitCommand is quote-aware", () => { + assert.deepEqual(splitCommand("everos server start"), ["everos", "server", "start"]); + assert.deepEqual(splitCommand('uv run "my everos" start'), ["uv", "run", "my everos", "start"]); + assert.deepEqual(splitCommand(" "), []); +}); + +test("isLoopback recognises loopback hosts only", () => { + assert.equal(isLoopback("http://127.0.0.1:8000"), true); + assert.equal(isLoopback("http://localhost:8000"), true); + assert.equal(isLoopback("http://[::1]:8000"), true); + assert.equal(isLoopback("http://10.0.0.2:8000"), false); +}); + +test("userId falls back through USER, USERNAME, then the chosen override", () => { + assert.equal(loadConfig({ HOME: "/h", USERNAME: "winuser" }).userId, "winuser"); + assert.equal(loadConfig({ HOME: "/h", EVEROS_AG_USER_ID: "chosen", USER: "tester" }).userId, "chosen"); + assert.equal(loadConfig({ HOME: "/h", EVEROS_ANTIGRAVITY_USER_ID: "compat", USER: "tester" }).userId, "compat"); +}); + +test("dataDir prefers EVEROS_AG_DATA_DIR, then ANTIGRAVITY_PLUGIN_DATA, then falls back under HOME", () => { + assert.equal(loadConfig({ ...base, ANTIGRAVITY_PLUGIN_DATA: "/data/ag" }).dataDir, "/data/ag"); + assert.equal(loadConfig({ ...base, EVEROS_AG_DATA_DIR: "/data/custom" }).dataDir, "/data/custom"); + assert.equal(loadConfig({ ...base }).dataDir, path.join("/home/tester", ".everos", ".antigravity")); +}); + +test("the recall timeout defaults to 5s and is clamped, never disabled", () => { + assert.equal(loadConfig({ ...base }).recallTimeoutMs, 5000); + assert.equal(loadConfig({ ...base, EVEROS_AG_RECALL_TIMEOUT_MS: "2500" }).recallTimeoutMs, 2500); + assert.equal(loadConfig({ ...base, EVEROS_AG_RECALL_TIMEOUT_MS: "0" }).recallTimeoutMs, 500); + assert.equal(loadConfig({ ...base, EVEROS_AG_RECALL_TIMEOUT_MS: "999999" }).recallTimeoutMs, 7000); + assert.equal(loadConfig({ ...base, EVEROS_AG_RECALL_TIMEOUT_MS: "nonsense" }).recallTimeoutMs, 5000); +}); + +test("verbose and debug read 1/true/yes/on", () => { + assert.equal(loadConfig({ ...base, EVEROS_AG_VERBOSE: "1" }).verbose, true); + assert.equal(loadConfig({ ...base, EVEROS_AG_VERBOSE: "true" }).verbose, true); + assert.equal(loadConfig({ ...base, EVEROS_AG_VERBOSE: "0" }).verbose, false); + assert.equal(loadConfig({ ...base, EVEROS_AG_DEBUG: "yes" }).debug, true); + assert.equal(loadConfig({ ...base, EVEROS_ANTIGRAVITY_DEBUG: "on" }).debug, true); +}); + +test("locale supports EVEROS_AG_LOCALE / EVEROS_AG_LANGUAGE, host options, and resolves zh or en", () => { + assert.equal(loadConfig({ ...base, EVEROS_AG_LOCALE: "en" }).locale, "en"); + assert.equal(loadConfig({ ...base, EVEROS_AG_LANGUAGE: "english" }).locale, "en"); + assert.equal(loadConfig({ ...base, EVEROS_ANTIGRAVITY_LOCALE: "en" }).locale, "en"); + assert.equal(loadConfig({ ...base, ANTIGRAVITY_PLUGIN_OPTION_LOCALE: "en" }).locale, "en"); + assert.equal(loadConfig({ ...base, EVEROS_AG_LOCALE: "zh" }).locale, "zh"); + assert.equal(loadConfig({ ...base, EVEROS_AG_LOCALE: "other" }).locale, "zh"); +}); + +test("loadConfig records warnings for invalid baseUrl (D3-05)", () => { + const cfg = loadConfig({ EVEROS_AG_BASE_URL: "ftp://invalid-scheme" }); + assert.equal(cfg.baseUrl, "http://127.0.0.1:8000"); + assert.ok(Array.isArray(cfg.warnings)); + assert.equal(cfg.warnings.length, 1); + assert.match(cfg.warnings[0], /Invalid BASE_URL/); +}); diff --git a/antigravity/tests/everos.test.js b/antigravity/tests/everos.test.js new file mode 100644 index 0000000..51824fa --- /dev/null +++ b/antigravity/tests/everos.test.js @@ -0,0 +1,164 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { createServer } from "node:http"; +import { createClient, EverosError, deadline } from "../hooks/scripts/lib/everos.js"; +import { startFakeEveros } from "./helpers/fake-everos.js"; + +test("health returns the parsed body", async () => { + const server = await startFakeEveros(); + try { + const client = createClient({ baseUrl: server.baseUrl }); + const body = await client.health(deadline(1000)); + assert.equal(body.status, "ok"); + assert.equal(body.capabilities.llm, true); + } finally { + await server.close(); + } +}); + +test("search unwraps data and posts the body verbatim", async () => { + const server = await startFakeEveros({ + searchFn: () => ({ + episodes: [{ id: "e1", summary: "s" }], + profiles: [], + agent_cases: [], + agent_skills: [], + unprocessed_messages: [], + }), + }); + try { + const client = createClient({ baseUrl: server.baseUrl }); + const data = await client.search( + { user_id: "me", app_id: "antigravity", project_id: "p", query: "q" }, + deadline(1000), + ); + assert.equal(data.episodes[0].id, "e1"); + const sent = server.only("/api/v2/memory/search")[0].body; + assert.deepEqual(sent, { user_id: "me", app_id: "antigravity", project_id: "p", query: "q" }); + assert.ok(!("top_k" in sent), "top_k must never be sent - EverOS defaults own it"); + } finally { + await server.close(); + } +}); + +test("client normalizes trailing slashes in baseUrl", async () => { + const server = await startFakeEveros(); + try { + const client = createClient({ baseUrl: `${server.baseUrl}///` }); + const body = await client.health(deadline(1000)); + assert.equal(body.status, "ok"); + } finally { + await server.close(); + } +}); + +test("an error envelope becomes an EverosError carrying code and status", async () => { + const server = await startFakeEveros({ addStatus: 500 }); + try { + const client = createClient({ baseUrl: server.baseUrl }); + await assert.rejects( + () => + client.add( + { + session_id: "s", + app_id: "antigravity", + messages: [{ sender_id: "u", role: "user", timestamp: 1789050000000, content: "hi" }], + }, + deadline(1000), + ), + (err) => { + assert.ok(err instanceof EverosError); + assert.equal(err.status, 500); + assert.equal(err.code, "INTERNAL_ERROR"); + return true; + }, + ); + } finally { + await server.close(); + } +}); + +test("a stalled server aborts at the deadline rather than hanging", async () => { + const server = await startFakeEveros({ stall: true }); + try { + const client = createClient({ baseUrl: server.baseUrl }); + const started = Date.now(); + await assert.rejects( + () => client.search({ user_id: "me", query: "q" }, deadline(300)), + (err) => err instanceof EverosError && err.code === "TIMEOUT", + ); + assert.ok(Date.now() - started < 2000, "must abort near the deadline"); + } finally { + await server.close(); + } +}); + +test("streaming response body timeout is classified as TIMEOUT, not non-JSON", async () => { + // Server answers headers immediately with 200 OK, but never finishes sending the body + const server = createServer((req, res) => { + res.writeHead(200, { "content-type": "application/json" }); + res.write('{"request_id":"test","data":'); + // Deliberately do not close or send remaining JSON + }); + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + const port = server.address().port; + + try { + const client = createClient({ baseUrl: `http://127.0.0.1:${port}` }); + await assert.rejects( + () => client.search({ user_id: "me", query: "q" }, deadline(200)), + (err) => { + assert.ok(err instanceof EverosError); + assert.equal(err.code, "TIMEOUT"); + assert.equal(err.status, 0); + return true; + }, + ); + } finally { + await new Promise((resolve) => server.close(resolve)); + } +}); + +test("a closed port is NETWORK_ERROR while a slow server is TIMEOUT", async () => { + const closed = createClient({ baseUrl: "http://127.0.0.1:1" }); + await assert.rejects( + () => closed.flush({ session_id: "s" }, deadline(500)), + (e) => e.code === "NETWORK_ERROR", + ); + + const stalled = await startFakeEveros({ stall: true }); + try { + const client = createClient({ baseUrl: stalled.baseUrl }); + await assert.rejects( + () => client.flush({ session_id: "s" }, deadline(200)), + (e) => e.code === "TIMEOUT", + ); + } finally { + await stalled.close(); + } +}); + +test("a closed port is a NETWORK_ERROR, not a crash", async () => { + const client = createClient({ baseUrl: "http://127.0.0.1:1" }); + await assert.rejects( + () => client.health(deadline(500)), + (err) => err instanceof EverosError && err.status === 0, + ); +}); + +test("one signal can carry two parallel searches on a shared deadline", async () => { + const server = await startFakeEveros(); + try { + const client = createClient({ baseUrl: server.baseUrl }); + const signal = deadline(1000); + const [a, b] = await Promise.all([ + client.search({ app_id: "antigravity", user_id: "me", query: "q" }, signal), + client.search({ app_id: "antigravity", agent_id: "antigravity", query: "q" }, signal), + ]); + assert.deepEqual(a.episodes, []); + assert.deepEqual(b.agent_cases, []); + assert.equal(server.only("/api/v2/memory/search").length, 2); + } finally { + await server.close(); + } +}); diff --git a/antigravity/tests/failure-branches.test.js b/antigravity/tests/failure-branches.test.js new file mode 100644 index 0000000..304a314 --- /dev/null +++ b/antigravity/tests/failure-branches.test.js @@ -0,0 +1,137 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { startFakeEveros } from "./helpers/fake-everos.js"; +import { runHookScript } from "./helpers/run-hook.js"; +import { loadSessionState, saveSessionState, createDefaultSessionState } from "../hooks/scripts/lib/state.js"; +import { ensureServerRunning } from "../hooks/scripts/lib/provision.js"; + +function makeTempDir() { + return fs.mkdtempSync(path.join(os.tmpdir(), "everos-fail-branches-test-")); +} + +test("failure-branches: capture.js handles corrupt JSON lines in transcript gracefully (D6-03 / D8-05)", async (t) => { + const fake = await startFakeEveros(); + const testDataDir = makeTempDir(); + const transcriptDir = makeTempDir(); + const transcriptFile = path.join(transcriptDir, "transcript.jsonl"); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + fs.rmSync(transcriptDir, { recursive: true, force: true }); + }); + + // Write mix of valid user step, corrupt garbage line, and valid assistant step + fs.writeFileSync( + transcriptFile, + [ + JSON.stringify({ step_index: 0, type: "USER_INPUT", source: "USER_EXPLICIT", content: "valid prompt" }), + "{ corrupt broken json line ???", + JSON.stringify({ step_index: 1, type: "PLANNER_RESPONSE", content: "valid answer" }), + ].join("\n") + "\n", + "utf8" + ); + + const res = await runHookScript( + "hooks/scripts/capture.js", + { conversationId: "conv_corrupt_test", transcriptPath: transcriptFile }, + { EVEROS_AG_BASE_URL: fake.baseUrl, EVEROS_AG_DATA_DIR: testDataDir } + ); + + assert.equal(res.code, 0); + const state = loadSessionState(testDataDir, "conv_corrupt_test"); + assert.equal(state.settled_turn_index, 1); +}); + +test("failure-branches: capture.js preserves Nack on HTTP 500 without crashing (D6-03 / D8-05)", async (t) => { + const fake = await startFakeEveros({ addStatus: 500 }); + const testDataDir = makeTempDir(); + const transcriptDir = makeTempDir(); + const transcriptFile = path.join(transcriptDir, "transcript.jsonl"); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + fs.rmSync(transcriptDir, { recursive: true, force: true }); + }); + + fs.writeFileSync( + transcriptFile, + [ + JSON.stringify({ step_index: 0, type: "USER_INPUT", source: "USER_EXPLICIT", content: "will fail 500" }), + JSON.stringify({ step_index: 1, type: "PLANNER_RESPONSE", content: "answer" }), + ].join("\n") + "\n", + "utf8" + ); + + const res = await runHookScript( + "hooks/scripts/capture.js", + { conversationId: "conv_500_test", transcriptPath: transcriptFile }, + { EVEROS_AG_BASE_URL: fake.baseUrl, EVEROS_AG_DATA_DIR: testDataDir } + ); + + assert.equal(res.code, 0); + const state = loadSessionState(testDataDir, "conv_500_test"); + assert.equal(state.settled_turn_index, -1); // Must not advance + assert.equal(state.observed_turn_index, 1); // But observation is logged +}); + +test("failure-branches: flush.js --background fast short-circuits when flush_abandoned is true (D6-03 / D8-05)", async (t) => { + const fake = await startFakeEveros(); + const testDataDir = makeTempDir(); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + }); + + const state = createDefaultSessionState("conv_abandoned_fast", { projectId: "proj_abandoned" }); + state.flush_abandoned = true; + state.flush_attempts = 3; + saveSessionState(testDataDir, state); + + const here = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([a-zA-Z]:)/, "$1")); + const flushScript = path.resolve(here, "../hooks/scripts/flush.js"); + + const { spawn } = await import("node:child_process"); + await new Promise((resolve) => { + const child = spawn( + process.execPath, + [flushScript, "--background", "conv_abandoned_fast"], + { + env: { + ...process.env, + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + }, + stdio: "ignore", + } + ); + child.on("close", resolve); + }); + + // No flush call should be made to fakeEveros + assert.equal(fake.only("/api/v2/memory/flush").length, 0); +}); + +test("failure-branches: provision does not attempt spawn when non-loopback host fails (D6-03 / D8-05)", async () => { + let spawnCalls = 0; + const fakeClient = { + async health() { + throw new Error("DNS resolution failed"); + }, + }; + + const res = await ensureServerRunning( + { baseUrl: "https://remote.production.internal:8000", startCmd: ["echo", "never"] }, + { client: fakeClient, spawnImpl: () => { spawnCalls++; return { unref() {} }; } } + ); + + assert.equal(res.ok, false); + assert.equal(res.spawned, false); + assert.equal(res.reason, "server_offline"); + assert.equal(spawnCalls, 0); +}); diff --git a/antigravity/tests/fake-everos.test.js b/antigravity/tests/fake-everos.test.js new file mode 100644 index 0000000..c829603 --- /dev/null +++ b/antigravity/tests/fake-everos.test.js @@ -0,0 +1,207 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { startFakeEveros } from "./helpers/fake-everos.js"; + +test("fake EverOS records requests and answers the four routes", async () => { + const server = await startFakeEveros(); + try { + const health = await fetch(`${server.baseUrl}/health`); + assert.equal(health.status, 200); + assert.equal((await health.json()).status, "ok"); + + const search = await fetch(`${server.baseUrl}/api/v2/memory/search`, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify({ user_id: "me", app_id: "antigravity", query: "hi" }), + }); + assert.deepEqual((await search.json()).data.episodes, []); + + assert.equal(server.only("/api/v2/memory/search").length, 1); + assert.equal(server.only("/api/v2/memory/search")[0].body.user_id, "me"); + } finally { + await server.close(); + } +}); + +test("fake EverOS 404s an unknown path with the real error envelope", async () => { + const server = await startFakeEveros(); + try { + const res = await fetch(`${server.baseUrl}/api/v2/memory/nope`, { method: "POST", body: "{}" }); + assert.equal(res.status, 404); + assert.equal((await res.json()).error.code, "NOT_FOUND"); + } finally { + await server.close(); + } +}); + +const VALID_MESSAGE = { sender_id: "u", role: "user", timestamp: 1789050000000, content: "hi" }; + +async function post(server, path, body) { + const res = await fetch(`${server.baseUrl}${path}`, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify(body), + }); + return { status: res.status, body: await res.json() }; +} + +test("the double accepts exactly the payloads the plugin really sends", async () => { + const server = await startFakeEveros(); + try { + assert.equal( + ( + await post(server, "/api/v2/memory/add", { + session_id: "s", + app_id: "antigravity", + project_id: "github.com_a_b", + messages: [ + VALID_MESSAGE, + { + sender_id: "antigravity", + role: "assistant", + timestamp: 1789050001000, + content: "", + tool_calls: [ + { id: "t1", type: "function", function: { name: "read_file", arguments: "{}" } }, + ], + }, + { + sender_id: "antigravity", + role: "tool", + timestamp: 1789050002000, + content: "r", + tool_call_id: "t1", + }, + ], + }) + ).status, + 200, + ); + + assert.equal( + ( + await post(server, "/api/v2/memory/search", { + user_id: "u", + app_id: "antigravity", + project_id: "p", + query: "q", + include_profile: true, + }) + ).status, + 200, + ); + + assert.equal( + ( + await post(server, "/api/v2/memory/flush", { + session_id: "s", + app_id: "antigravity", + project_id: "p", + }) + ).status, + 200, + ); + } finally { + await server.close(); + } +}); + +test("the double rejects every shape EverOS rejects", async () => { + const server = await startFakeEveros(); + const cases = [ + [ + "role outside the literal", + "/api/v2/memory/add", + { session_id: "s", messages: [{ ...VALID_MESSAGE, role: "system" }] }, + ], + [ + "timestamp that is not an integer", + "/api/v2/memory/add", + { session_id: "s", messages: [{ ...VALID_MESSAGE, timestamp: 1789050000.5 }] }, + ], + [ + "project_id is a traversal token", + "/api/v2/memory/add", + { session_id: "s", project_id: "..", messages: [VALID_MESSAGE] }, + ], + [ + "project_id outside the charset", + "/api/v2/memory/add", + { session_id: "s", project_id: "a/b", messages: [VALID_MESSAGE] }, + ], + [ + "empty messages", + "/api/v2/memory/add", + { session_id: "s", messages: [] }, + ], + [ + "more than 500 messages", + "/api/v2/memory/add", + { session_id: "s", messages: Array.from({ length: 501 }, () => VALID_MESSAGE) }, + ], + [ + "tool row with no tool_call_id", + "/api/v2/memory/add", + { session_id: "s", messages: [{ ...VALID_MESSAGE, role: "tool" }] }, + ], + [ + "tool_calls arguments not a JSON string", + "/api/v2/memory/add", + { + session_id: "s", + messages: [ + { + ...VALID_MESSAGE, + role: "assistant", + tool_calls: [{ id: "t", type: "function", function: { name: "R", arguments: {} } }], + }, + ], + }, + ], + [ + "neither user_id nor agent_id", + "/api/v2/memory/search", + { app_id: "antigravity", query: "q" }, + ], + [ + "both user_id and agent_id", + "/api/v2/memory/search", + { user_id: "u", agent_id: "a", query: "q" }, + ], + [ + "an unknown search field (extra=forbid)", + "/api/v2/memory/search", + { user_id: "u", query: "q", limit: 5 }, + ], + [ + "top_k out of range", + "/api/v2/memory/search", + { user_id: "u", query: "q", top_k: 500 }, + ], + [ + "flush without a session_id", + "/api/v2/memory/flush", + { app_id: "antigravity" }, + ], + [ + "session_id longer than 128 chars in add (D8-04)", + "/api/v2/memory/add", + { session_id: "x".repeat(200), app_id: "antigravity", messages: [VALID_MESSAGE] }, + ], + [ + "session_id longer than 128 chars in flush (D8-04)", + "/api/v2/memory/flush", + { session_id: "x".repeat(200), app_id: "antigravity" }, + ], + ]; + + try { + for (const [name, path, body] of cases) { + const { status, body: payload } = await post(server, path, body); + assert.equal(status, 422, `${name}: expected 422, got ${status}`); + assert.match(payload.error.message, /^contract: /, name); + } + } finally { + await server.close(); + } +}); diff --git a/antigravity/tests/fixtures/live-sandbox/.agents/hooks.json b/antigravity/tests/fixtures/live-sandbox/.agents/hooks.json new file mode 100644 index 0000000..fc483c5 --- /dev/null +++ b/antigravity/tests/fixtures/live-sandbox/.agents/hooks.json @@ -0,0 +1,25 @@ +{ + "everos-antigravity": { + "SessionStart": [ + { + "type": "command", + "command": "node \"../../../hooks/scripts/session-start.js\"", + "timeout": 15 + } + ], + "PreInvocation": [ + { + "type": "command", + "command": "node \"../../../hooks/scripts/recall.js\"", + "timeout": 10 + } + ], + "Stop": [ + { + "type": "command", + "command": "node \"../../../hooks/scripts/capture.js\"", + "timeout": 30 + } + ] + } +} diff --git a/antigravity/tests/fixtures/live-sandbox/.agents/mcp_config.json b/antigravity/tests/fixtures/live-sandbox/.agents/mcp_config.json new file mode 100644 index 0000000..ade2f20 --- /dev/null +++ b/antigravity/tests/fixtures/live-sandbox/.agents/mcp_config.json @@ -0,0 +1,9 @@ +{ + "mcpServers": { + "everos": { + "command": "node", + "args": ["../../mcp/server.js"], + "env": {} + } + } +} diff --git a/antigravity/tests/fixtures/live-sandbox/package.json b/antigravity/tests/fixtures/live-sandbox/package.json new file mode 100644 index 0000000..e99d2b2 --- /dev/null +++ b/antigravity/tests/fixtures/live-sandbox/package.json @@ -0,0 +1,7 @@ +{ + "name": "sandbox-demo-project", + "version": "1.0.0", + "description": "Clean isolated sandbox for EverOS Antigravity plugin live verification", + "main": "src/index.js", + "type": "module" +} diff --git a/antigravity/tests/fixtures/live-sandbox/src/index.js b/antigravity/tests/fixtures/live-sandbox/src/index.js new file mode 100644 index 0000000..23b79eb --- /dev/null +++ b/antigravity/tests/fixtures/live-sandbox/src/index.js @@ -0,0 +1,18 @@ +/** + * Sandbox Demo Service for Live Verification + */ +export function calculateFibonacci(n) { + if (n <= 1) return n; + let a = 0; + let b = 1; + for (let i = 2; i <= n; i++) { + const next = a + b; + a = b; + b = next; + } + return b; +} + +export function greet(name = "World") { + return `Hello, ${name}! Welcome to EverOS Antigravity Sandbox.`; +} diff --git a/antigravity/tests/fixtures/transcript-antigravity.jsonl b/antigravity/tests/fixtures/transcript-antigravity.jsonl new file mode 100644 index 0000000..cb1bbdc --- /dev/null +++ b/antigravity/tests/fixtures/transcript-antigravity.jsonl @@ -0,0 +1,10 @@ +{"step_index":0,"source":"USER_EXPLICIT","type":"USER_INPUT","status":"DONE","created_at":"2026-10-20T02:00:00Z","content":"\nInitialize EverOS Antigravity Plugin\n"} +{"step_index":1,"source":"MODEL","type":"PLANNER_RESPONSE","status":"DONE","created_at":"2026-10-20T02:00:01Z","thinking":"Checking existing guidelines and files...","content":"I will inspect the guide first.","tool_calls":[{"name":"read_file","args":{"Path":"ANTIGRAVITY_DEV_GUIDE.md"}}]} +{"step_index":2,"source":"MODEL","type":"GENERIC","status":"DONE","created_at":"2026-10-20T02:00:02Z","content":"# Antigravity Dev Guide content"} +{"step_index":3,"source":"MODEL","type":"PLANNER_RESPONSE","status":"DONE","created_at":"2026-10-20T02:00:03Z","content":"Guide verified."} +{"step_index":4,"source":"USER_EXPLICIT","type":"USER_INPUT","status":"DONE","created_at":"2026-10-20T02:10:00Z","content":"Please invoke the code auditor subagent"} +{"step_index":5,"source":"MODEL","type":"PLANNER_RESPONSE","status":"DONE","created_at":"2026-10-20T02:10:01Z","thinking":"Invoking subagent for code audit...","content":"Launching subagent.","tool_calls":[{"name":"invoke_subagent","args":{"Subagents":[{"Role":"CodeAuditor","Prompt":"Perform deep architectural audit"}]}}]} +{"step_index":6,"source":"MODEL","type":"GENERIC","status":"DONE","created_at":"2026-10-20T02:10:05Z","content":"Subagent report: audit complete, 0 critical issues found."} +{"step_index":7,"source":"USER_EXPLICIT","type":"USER_INPUT","status":"DONE","created_at":"2026-10-20T02:20:00Z","content":"\n【空间归属】project_id: old | branch: main\n【既定规约】\n- Old rule\n\nRun tool and interrupt"} +{"step_index":8,"source":"MODEL","type":"PLANNER_RESPONSE","status":"DONE","created_at":"2026-10-20T02:20:01Z","content":"Running two tools in parallel","tool_calls":[{"name":"run_cmd","args":{"cmd":"err"}},{"name":"run_cmd","args":{"cmd":"cancel"}}]} +{"step_index":9,"source":"MODEL","type":"GENERIC","status":"ERROR","created_at":"2026-10-20T02:20:02Z","content":"Command crashed with code 1"} diff --git a/antigravity/tests/helpers/contract.js b/antigravity/tests/helpers/contract.js new file mode 100644 index 0000000..eefe77f --- /dev/null +++ b/antigravity/tests/helpers/contract.js @@ -0,0 +1,169 @@ +/** + * The shape checks EverOS actually performs, mirrored here so the unit suite + * fails on contract drift instead of leaving it for e2e runs. + * + * Every rule below is copied from real EverOS v2 source locations. + * Three rules are deliberately STRICTER than EverOS, marked `tighter:`. + * They encode a plugin invariant rather than a server one. + */ + +// routes/memorize.py ContentItemDTO +const CONTENT_TYPES = ["text", "image", "audio", "doc", "pdf", "html", "email"]; +const CONTENT_FIELDS = ["type", "text", "url", "path", "mime_type", "metadata"]; +// memory/search/dto.py SearchMethod +const SEARCH_METHODS = ["keyword", "vector", "hybrid", "agentic", "llm_multiround"]; + +// routes/memorize.py:41 _PATH_SAFE_CHARSET, and :43 _PATH_TRAVERSAL_TOKENS +const PATH_SAFE = /^[a-zA-Z0-9_.@+-]+$/; +const TRAVERSAL = new Set([".", ".."]); + +function pathSafeId(value, field, errors) { + if (typeof value !== "string") return errors.push(`${field}: must be a string`); + if (value.length < 1 || value.length > 128) return errors.push(`${field}: length must be 1..128`); + if (TRAVERSAL.has(value)) return errors.push(`${field}: '.' and '..' are reserved (path traversal)`); + if (!PATH_SAFE.test(value)) return errors.push(`${field}: charset ^[a-zA-Z0-9_.@+-]+$`); +} + +function sessionId(value, errors) { + // routes/memorize.py:116 - length only, NOT the path-safe charset. + if (typeof value !== "string") return errors.push("session_id: must be a string"); + if (value.length < 1 || value.length > 128) errors.push("session_id: length must be 1..128"); +} + +/** routes/memorize.py:115-137 MemorizeAddRequest + :89-112 MessageItemDTO */ +export function validateAdd(body) { + const errors = []; + if (!body || typeof body !== "object") return ["body: must be an object"]; + sessionId(body.session_id, errors); + // tighter: plugin invariant requires app_id to guarantee multi-host isolation + pathSafeId(body.app_id, "app_id", errors); + if ("project_id" in body) pathSafeId(body.project_id, "project_id", errors); + if (!Array.isArray(body.messages)) { + errors.push("messages: required, must be a list"); + } else if (body.messages.length < 1 || body.messages.length > 500) { + errors.push(`messages: length must be 1..500, got ${body.messages.length}`); + } else { + body.messages.forEach((m, i) => { + const at = `messages[${i}]`; + if (!m || typeof m !== "object") return errors.push(`${at}: must be an object`); + pathSafeId(m.sender_id, `${at}.sender_id`, errors); + if (!["user", "assistant", "tool"].includes(m.role)) { + errors.push(`${at}.role: must be user|assistant|tool, got ${JSON.stringify(m.role)}`); + } + // MessageItemDTO.timestamp: int, gt=0, Unix epoch MILLISECONDS. + if (!Number.isInteger(m.timestamp) || m.timestamp <= 0) { + errors.push(`${at}.timestamp: must be a positive integer of epoch ms, got ${JSON.stringify(m.timestamp)}`); + } + if (typeof m.content !== "string" && !Array.isArray(m.content)) { + errors.push(`${at}.content: must be a string or a list`); + } else if (Array.isArray(m.content)) { + m.content.forEach((c, j) => { + const where = `${at}.content[${j}]`; + if (!c || typeof c !== "object" || Array.isArray(c)) return errors.push(`${where}: must be an object`); + if (!CONTENT_TYPES.includes(c.type)) { + errors.push(`${where}.type: must be one of ${CONTENT_TYPES.join("|")}, got ${JSON.stringify(c.type)}`); + } + for (const key of Object.keys(c)) { + if (!CONTENT_FIELDS.includes(key)) errors.push(`${where}.${key}: not a ContentItemDTO field (extra="forbid")`); + } + }); + } + if (m.sender_name !== undefined && m.sender_name !== null && typeof m.sender_name !== "string") { + errors.push(`${at}.sender_name: must be a string`); + } + if (m.tool_calls !== undefined && m.tool_calls !== null) { + if (!Array.isArray(m.tool_calls)) errors.push(`${at}.tool_calls: must be a list`); + else { + m.tool_calls.forEach((c, j) => { + if (!c?.id) errors.push(`${at}.tool_calls[${j}].id: required`); + // tighter: ToolCallDTO.type is a plain `str = "function"` server-side. + if (c?.type !== "function") errors.push(`${at}.tool_calls[${j}].type: must be "function"`); + if (typeof c?.function?.name !== "string") errors.push(`${at}.tool_calls[${j}].function.name: required`); + if (typeof c?.function?.arguments !== "string") { + errors.push(`${at}.tool_calls[${j}].function.arguments: must be a JSON string`); + } + }); + } + } + if (m.tool_call_id !== undefined && m.tool_call_id !== null && typeof m.tool_call_id !== "string") { + errors.push(`${at}.tool_call_id: must be a string`); + } + if (m.role === "tool" && !m.tool_call_id) { + errors.push(`${at}: role="tool" needs a tool_call_id (boundary raises ValueError otherwise)`); + } + for (const key of Object.keys(m)) { + if (!["sender_id", "sender_name", "role", "timestamp", "content", "tool_calls", "tool_call_id"].includes(key)) { + errors.push(`${at}.${key}: not a MessageItemDTO field`); + } + } + }); + } + if ("defer_extraction" in body && typeof body.defer_extraction !== "boolean") { + errors.push("defer_extraction: must be a boolean"); + } + for (const key of Object.keys(body)) { + if (!["session_id", "app_id", "project_id", "messages", "defer_extraction"].includes(key)) { + errors.push(`${key}: not a MemorizeAddRequest field`); + } + } + return errors; +} + +/** memory/search/dto.py:71-126 SearchRequest, model_config extra="forbid" */ +const SEARCH_FIELDS = [ + "user_id", "agent_id", "app_id", "project_id", "query", "method", "top_k", + "radius", "min_score", "include_profile", "enable_llm_rerank", "filters", +]; + +export function validateSearch(body) { + const errors = []; + if (!body || typeof body !== "object") return ["body: must be an object"]; + // dto.py:116 - exactly one of user_id / agent_id. + const hasUser = body.user_id !== undefined && body.user_id !== null; + const hasAgent = body.agent_id !== undefined && body.agent_id !== null; + if (hasUser === hasAgent) errors.push("exactly one of user_id / agent_id must be provided"); + + if (hasUser) pathSafeId(body.user_id, "user_id", errors); + if (hasAgent) pathSafeId(body.agent_id, "agent_id", errors); + // tighter: plugin invariant requires app_id to guarantee multi-host isolation + pathSafeId(body.app_id, "app_id", errors); + if ("project_id" in body) pathSafeId(body.project_id, "project_id", errors); + if (typeof body.query !== "string" || body.query.length < 1) errors.push("query: required, min_length 1"); + if ("method" in body && !SEARCH_METHODS.includes(body.method)) { + errors.push(`method: must be one of ${SEARCH_METHODS.join("|")}, got ${JSON.stringify(body.method)}`); + } + for (const field of ["radius", "min_score"]) { + if (!(field in body) || body[field] === null) continue; + const v = body[field]; + if (typeof v !== "number" || Number.isNaN(v) || v < 0 || v > 1) { + errors.push(`${field}: must be a number in 0.0..1.0`); + } + } + for (const field of ["include_profile", "enable_llm_rerank"]) { + if (field in body && typeof body[field] !== "boolean") errors.push(`${field}: must be a boolean`); + } + if ("top_k" in body) { + const k = body.top_k; + if (!Number.isInteger(k) || k === 0 || k < -1 || k > 100) errors.push("top_k must be -1 or in 1..100"); + } + for (const key of Object.keys(body)) { + if (!SEARCH_FIELDS.includes(key)) errors.push(`${key}: not a SearchRequest field (extra="forbid")`); + } + return errors; +} + +/** routes/memorize.py MemorizeFlushRequest */ +export function validateFlush(body) { + const errors = []; + if (!body || typeof body !== "object") return ["body: must be an object"]; + sessionId(body.session_id, errors); + // tighter: plugin invariant requires app_id to guarantee multi-host isolation + pathSafeId(body.app_id, "app_id", errors); + if ("project_id" in body) pathSafeId(body.project_id, "project_id", errors); + for (const key of Object.keys(body)) { + if (!["session_id", "app_id", "project_id"].includes(key)) { + errors.push(`${key}: not a MemorizeFlushRequest field`); + } + } + return errors; +} diff --git a/antigravity/tests/helpers/fake-everos.js b/antigravity/tests/helpers/fake-everos.js new file mode 100644 index 0000000..1b996e9 --- /dev/null +++ b/antigravity/tests/helpers/fake-everos.js @@ -0,0 +1,131 @@ +import { createServer } from "node:http"; +import { validateAdd, validateSearch, validateFlush } from "./contract.js"; + +const EMPTY_SEARCH = { + episodes: [], + profiles: [], + agent_cases: [], + agent_skills: [], + unprocessed_messages: [], +}; + +/** + * In-process stand-in for a local EverOS. Records every request so tests can + * assert on wire payloads, and lets each route's behaviour be swapped at runtime. + */ +export async function startFakeEveros(options = {}) { + const requests = []; + const healthBody = options.health ?? { + status: "ok", + version: "1.3.1", + capabilities: { llm: true, embed: true, rerank: true, multimodal_llm: false, parser: false }, + disabled_features: [], + cascade: { healthy: true, pending: 0 }, + }; + const searchFn = options.searchFn ?? (() => EMPTY_SEARCH); + let addStatus = options.addStatus ?? 200; + let addHandler = null; + const flushStatus = options.flushStatus ?? 200; + const flushDelayMs = options.flushDelayMs ?? 0; + const stall = options.stall ?? false; + + const server = createServer((req, res) => { + let raw = ""; + req.on("data", (c) => { + raw += c; + }); + req.on("end", async () => { + const path = req.url.split("?")[0]; + let body = null; + if (raw) { + try { + body = JSON.parse(raw); + } catch { + body = raw; + } + } + requests.push({ method: req.method, path, body }); + + if (stall) return; // never answer: exercises the client deadline + + const send = (status, payload) => { + res.writeHead(status, { "content-type": "application/json" }); + res.end(JSON.stringify(payload)); + }; + const fail = (status, code) => + send(status, { + request_id: "0".repeat(32), + error: { code, message: `fake: ${code}`, timestamp: new Date().toISOString(), path }, + }); + + // Validate like EverOS does. An invalid body is a 422 here just as it is there. + const reject = (errors) => + send(422, { + request_id: "0".repeat(32), + error: { + code: "VALIDATION_ERROR", + message: `contract: ${errors.join("; ")}`, + timestamp: new Date().toISOString(), + path, + }, + }); + + if (path === "/health" && req.method === "GET") return send(200, healthBody); + + if (path === "/api/v2/memory/search") { + const bad = validateSearch(body); + if (bad.length) return reject(bad); + try { + const resData = await searchFn(body); + if (resData && typeof resData === "object" && !resData.profiles && resData.profile) { + resData.profiles = [resData.profile]; + } + return send(200, { request_id: "0".repeat(32), data: resData }); + } catch (error) { + return fail(500, "INTERNAL_ERROR"); + } + } + + if (path === "/api/v2/memory/add") { + const bad = validateAdd(body); + if (bad.length) return reject(bad); + if (addHandler && addHandler(body) === "fail") return fail(500, "INTERNAL_ERROR"); + if (addStatus !== 200) return fail(addStatus, "INTERNAL_ERROR"); + return send(200, { + request_id: "0".repeat(32), + data: { message_count: body?.messages?.length ?? 0, status: "accumulated" }, + }); + } + + if (path === "/api/v2/memory/flush") { + const bad = validateFlush(body); + if (bad.length) return reject(bad); + if (flushStatus !== 200) return fail(flushStatus, "INTERNAL_ERROR"); + if (flushDelayMs) await new Promise((r) => setTimeout(r, flushDelayMs)); + return send(200, { request_id: "0".repeat(32), data: { status: "extracted" } }); + } + + return fail(404, "NOT_FOUND"); + }); + }); + + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + const { port } = server.address(); + + return { + baseUrl: `http://127.0.0.1:${port}`, + requests, + only(path) { + return requests.filter((r) => r.path === path); + }, + setAddStatus(s) { + addStatus = s; + }, + setAddHandler(fn) { + addHandler = fn; + }, + close() { + return new Promise((resolve) => server.close(resolve)); + }, + }; +} diff --git a/antigravity/tests/helpers/run-hook.js b/antigravity/tests/helpers/run-hook.js new file mode 100644 index 0000000..f07376d --- /dev/null +++ b/antigravity/tests/helpers/run-hook.js @@ -0,0 +1,88 @@ +import os from "node:os"; +import fs from "node:fs"; +import { spawn } from "node:child_process"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", ".."); + +/** + * Temp directories created by this helper, removed when the process exits. + */ +const created = []; +process.on("exit", () => { + for (const dir of created) { + try { + fs.rmSync(dir, { recursive: true, force: true }); + } catch { + /* best effort cleanup */ + } + } +}); + +/** A data directory only when the caller did not specify one of its own. */ +function dataDirFor(env) { + if (env.EVEROS_AG_DATA_DIR) return env.EVEROS_AG_DATA_DIR; + if (env.EVEROS_ANTIGRAVITY_DATA_DIR) return env.EVEROS_ANTIGRAVITY_DATA_DIR; + const dir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-ag-hook-")); + created.push(dir); + return dir; +} + +/** Spawn a hook script as Antigravity does: JSON on stdin, JSON on stdout. */ +export function runHookScript(relativeScriptPath, stdinObject, env = {}) { + return new Promise((resolve, reject) => { + // Retain essential Windows & POSIX environment variables + const inheritedEnv = { + PATH: process.env.PATH, + HOME: process.env.HOME, + USERPROFILE: process.env.USERPROFILE, + USERNAME: process.env.USERNAME, + SYSTEMROOT: process.env.SYSTEMROOT, + SYSTEMDRIVE: process.env.SYSTEMDRIVE, + TEMP: process.env.TEMP, + TMP: process.env.TMP, + APPDATA: process.env.APPDATA, + LOCALAPPDATA: process.env.LOCALAPPDATA, + COMSPEC: process.env.COMSPEC, + ...env, + // Never let a test write to the user's real ~/.everos/.antigravity + EVEROS_AG_DATA_DIR: dataDirFor(env), + }; + + const child = spawn(process.execPath, [path.join(root, relativeScriptPath)], { + env: inheritedEnv, + stdio: ["pipe", "pipe", "pipe"], + }); + + let stdout = ""; + let stderr = ""; + child.stdout.on("data", (c) => { + stdout += c; + }); + child.stderr.on("data", (c) => { + stderr += c; + }); + + const killer = setTimeout(() => { + child.kill("SIGKILL"); + reject(new Error("hook did not exit within 20s")); + }, 20000); + + child.on("error", reject); + child.on("close", (code) => { + clearTimeout(killer); + let json = null; + if (stdout.trim()) { + try { + json = JSON.parse(stdout); + } catch { + /* leave null; assertions can inspect stdout string */ + } + } + resolve({ code, stdout, stderr, json }); + }); + + child.stdin.end(JSON.stringify(stdinObject)); + }); +} diff --git a/antigravity/tests/hook-io.test.js b/antigravity/tests/hook-io.test.js new file mode 100644 index 0000000..c648f1a --- /dev/null +++ b/antigravity/tests/hook-io.test.js @@ -0,0 +1,112 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { spawnSync } from "node:child_process"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { writeStdoutJson, safeExit } from "../hooks/scripts/lib/hook-io.js"; + +const __dirname = path.dirname(fileURLToPath(import.meta.url)); + +test("hook-io: writeStdoutJson writes valid json to stdout", () => { + // Capture stdout + let captured = ""; + const originalWrite = process.stdout.write; + try { + process.stdout.write = (chunk) => { + captured += chunk; + return true; + }; + writeStdoutJson({ status: "ok", count: 42 }); + assert.equal(captured, JSON.stringify({ status: "ok", count: 42 }) + "\n"); + } finally { + process.stdout.write = originalWrite; + } +}); + +test("hook-io: writeStdoutJson defaults null or undefined to empty object", () => { + let captured = ""; + const originalWrite = process.stdout.write; + try { + process.stdout.write = (chunk) => { + captured += chunk; + return true; + }; + writeStdoutJson(null); + assert.equal(captured, "{}\n"); + } finally { + process.stdout.write = originalWrite; + } +}); + +test("hook-io: safeExit sets exitCode without killing immediately", () => { + const originalCode = process.exitCode; + try { + safeExit(0); + assert.equal(process.exitCode, 0); + safeExit(2); + assert.equal(process.exitCode, 2); + } finally { + process.exitCode = originalCode; + } +}); + +test("hook-io: readStdinJson & wrapHook fail-open in actual child process", () => { + const snippet = ` + import { readStdinJson, writeStdoutJson, wrapHook } from "./hooks/scripts/lib/hook-io.js"; + wrapHook(async () => { + const input = readStdinJson(); + if (input.triggerError) { + throw new Error("Simulated fatal failure in hook"); + } + writeStdoutJson({ received: input.message || "none" }); + }); + `; + + // Case 1: valid input + const res1 = spawnSync(process.execPath, ["--input-type=module", "-e", snippet], { + input: JSON.stringify({ message: "hello" }), + encoding: "utf8", + cwd: path.resolve(__dirname, ".."), + }); + assert.equal(res1.status, 0); + assert.deepEqual(JSON.parse(res1.stdout.trim()), { received: "hello" }); + + // Case 2: malformed input (fail-open returns {}) + const res2 = spawnSync(process.execPath, ["--input-type=module", "-e", snippet], { + input: "NOT_VALID_JSON{[[", + encoding: "utf8", + cwd: path.resolve(__dirname, ".."), + }); + assert.equal(res2.status, 0); + assert.deepEqual(JSON.parse(res2.stdout.trim()), { received: "none" }); + + // Case 3: hook throws unhandled exception -> wrapHook outputs {} with code 0 and logs stderr + const res3 = spawnSync(process.execPath, ["--input-type=module", "-e", snippet], { + input: JSON.stringify({ triggerError: true }), + encoding: "utf8", + cwd: path.resolve(__dirname, ".."), + }); + assert.equal(res3.status, 0); + assert.deepEqual(JSON.parse(res3.stdout.trim()), {}); + assert.match(res3.stderr, /Simulated fatal failure in hook/); + + // Case 4: double stdout protection: if output already written, do not write {} again + const doubleSnippet = ` + import { writeStdoutJson, wrapHook } from "./hooks/scripts/lib/hook-io.js"; + wrapHook(async () => { + writeStdoutJson({ injectSteps: ["step1"] }); + throw new Error("Post-write explosion"); + }); + `; + const res4 = spawnSync(process.execPath, ["--input-type=module", "-e", doubleSnippet], { + encoding: "utf8", + cwd: path.resolve(__dirname, ".."), + }); + assert.equal(res4.status, 0); + // Stderr has the warning + assert.match(res4.stderr, /Post-write explosion/); + // Stdout must contain EXACTLY ONE JSON line (no trailing {}) + const lines = res4.stdout.trim().split("\n"); + assert.equal(lines.length, 1); + assert.deepEqual(JSON.parse(lines[0]), { injectSteps: ["step1"] }); +}); diff --git a/antigravity/tests/identity.test.js b/antigravity/tests/identity.test.js new file mode 100644 index 0000000..3040861 --- /dev/null +++ b/antigravity/tests/identity.test.js @@ -0,0 +1,161 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { + sanitizeId, + sanitizeBranch, + resolveProjectId, + resolveBranch, + resolveIdentity, +} from "../hooks/scripts/lib/identity.js"; + +const cfg = { projectIdOverride: null, userId: "tester" }; + +function runnerFor(map) { + return (args) => map[args.join(" ")] ?? null; +} + +test("sanitizeId keeps the path-safe charset and replaces the rest", () => { + assert.equal(sanitizeId("EverOS", "default"), "EverOS"); + assert.match(sanitizeId("my repo/name", "default"), /^my_repo_name_[0-9a-f]{8}$/); + assert.equal(sanitizeId("a.b@c+d-e_f", "default"), "a.b@c+d-e_f"); +}); + +test("sanitizeId rejects the directory-traversal names EverOS forbids", () => { + assert.equal(sanitizeId(".", "default"), "default"); + assert.equal(sanitizeId("..", "default"), "default"); + assert.equal(sanitizeId("", "default"), "default"); + assert.equal(sanitizeId(null, "default"), "default"); +}); + +test("sanitizeId clips to 128 characters", () => { + assert.equal(sanitizeId("x".repeat(200), "default").length, 128); +}); + +test("the origin remote wins over the toplevel, so every worktree shares one project", () => { + const runner = runnerFor({ + "config --get remote.origin.url": "git@github.com:EverMind-AI/Plugins.git", + "rev-parse --show-toplevel": "/Users/me/Plugins-a", + }); + assert.equal(resolveProjectId("/Users/me/Plugins-a", cfg, runner), "github.com_EverMind-AI_Plugins"); + assert.equal(resolveProjectId("/Users/me/Plugins", cfg, runner), "github.com_EverMind-AI_Plugins"); +}); + +test("the project id carries host and owner, host is lowercase", () => { + const mine = resolveProjectId("/w", cfg, runnerFor({ "config --get remote.origin.url": "https://GitHub.com/acme/api.git" })); + const theirs = resolveProjectId("/w", cfg, runnerFor({ "config --get remote.origin.url": "https://evil.example/mallory/api.git" })); + assert.notEqual(mine, theirs); + assert.equal(mine, "github.com_acme_api"); + assert.equal(theirs, "evil.example_mallory_api"); +}); + +test("ssh, https and scp-style remotes all resolve to the same id", () => { + const expected = "github.com_EverMind-AI_EverOS"; + for (const url of [ + "git@github.com:EverMind-AI/EverOS.git", + "https://github.com/EverMind-AI/EverOS.git", + "https://github.com/EverMind-AI/EverOS", + "ssh://git@github.com/EverMind-AI/EverOS.git", + ]) { + assert.equal(resolveProjectId("/w", cfg, runnerFor({ "config --get remote.origin.url": url })), expected, url); + } +}); + +test("remotes with explicit non-standard ports retain host and strip port", () => { + // SSH URL with explicit port :2222 + assert.equal( + resolveProjectId("/w", cfg, runnerFor({ "config --get remote.origin.url": "ssh://git@gitlab.corp.com:2222/team/repo.git" })), + "gitlab.corp.com_team_repo", + ); + // HTTP URL with port :8080 + assert.equal( + resolveProjectId("/w", cfg, runnerFor({ "config --get remote.origin.url": "http://host:8080/org/repo.git" })), + "host_org_repo", + ); + // SSH URL with port :22 + assert.equal( + resolveProjectId("/w", cfg, runnerFor({ "config --get remote.origin.url": "ssh://git@github.com:22/org/repo.git" })), + "github.com_org_repo", + ); + // SCP-style with port + assert.equal( + resolveProjectId("/w", cfg, runnerFor({ "config --get remote.origin.url": "git@gitlab.internal:2222/group/proj.git" })), + "gitlab.internal_group_proj", + ); +}); + +test("a remote with no owner segment still yields something usable", () => { + assert.equal( + resolveProjectId("/w", cfg, runnerFor({ "config --get remote.origin.url": "/srv/git/bare-repo.git" })), + "srv_git_bare-repo", + ); +}); + +test("no remote falls back to toplevel basename (Windows path normalized to lowercase)", () => { + const runnerPosix = runnerFor({ "rev-parse --show-toplevel": "/Users/me/code/local-only" }); + assert.equal(resolveProjectId("/Users/me/code/local-only/src", cfg, runnerPosix), "local-only"); + + const runnerWin = runnerFor({ "rev-parse --show-toplevel": "C:\\Workspace\\MockRepo" }); + assert.equal(resolveProjectId("C:\\Workspace\\MockRepo\\src", cfg, runnerWin), "mockrepo"); +}); + +test("no git at all falls back to cwd basename (Windows path anti-drift to lowercase)", () => { + assert.equal(resolveProjectId("/Users/me/scratch", cfg, runnerFor({})), "scratch"); + assert.equal(resolveProjectId("D:\\Projects\\SampleApp", cfg, runnerFor({})), "sampleapp"); + assert.equal(resolveProjectId("d:\\projects\\sampleapp", cfg, runnerFor({})), "sampleapp"); +}); + +test("the override beats every derivation", () => { + const runner = runnerFor({ "config --get remote.origin.url": "git@github.com:x/y.git" }); + assert.equal(resolveProjectId("/w", { ...cfg, projectIdOverride: "forced" }, runner), "forced"); +}); + +test("names that sanitize to the same thing still get their own partition", () => { + const ids = ["项目", "测试", "笔记"].map((n) => sanitizeId(n, "default")); + assert.equal(new Set(ids).size, 3, `collided: ${ids.join(" ")}`); + for (const id of ids) assert.match(id, /^[A-Za-z0-9_.@+-]+$/, "still path-safe for EverOS"); + assert.equal(sanitizeId("项目", "default"), sanitizeId("项目", "default"), "and stable across runs"); +}); + +test("resolveBranch resolves active branch, detached HEAD and fallback", () => { + // branch --show-current takes precedence + const r1 = runnerFor({ "branch --show-current": "feature/antigravity" }); + assert.equal(resolveBranch("/w", r1), "feature/antigravity"); + + // rev-parse fallback + const r2 = runnerFor({ "rev-parse --abbrev-ref HEAD": "main" }); + assert.equal(resolveBranch("/w", r2), "main"); + + // detached HEAD + const r3 = runnerFor({ "rev-parse --abbrev-ref HEAD": "HEAD" }); + assert.equal(resolveBranch("/w", r3), "detached"); + + // unknown when no git + const r4 = runnerFor({}); + assert.equal(resolveBranch("/w", r4), "unknown"); +}); + +test("sanitizeBranch handles control characters, newlines and xml tags", () => { + assert.equal(sanitizeBranch("main\n"), "main"); + assert.equal(sanitizeBranch("feature/\tlogin"), "feature/ login"); + assert.equal(sanitizeBranch("fix/"), "fix/issue-123"); + assert.equal(sanitizeBranch("<>"), "danger"); + assert.equal(sanitizeBranch(""), "unknown"); + assert.equal(sanitizeBranch(null), "unknown"); +}); + +test("resolveIdentity returns the five identity fields", () => { + const runner = runnerFor({ "branch --show-current": "dev" }); + const id = resolveIdentity("/Users/me/scratch", cfg, runner); + assert.deepEqual(id, { + appId: "antigravity", + projectId: "scratch", + branch: "dev", + userId: "tester", + agentId: "antigravity", + }); +}); + +test("a missing userId is reported as null so callers can disable user track", () => { + const id = resolveIdentity("/Users/me/scratch", { ...cfg, userId: null }, runnerFor({})); + assert.equal(id.userId, null); +}); diff --git a/antigravity/tests/lifecycle.test.js b/antigravity/tests/lifecycle.test.js new file mode 100644 index 0000000..a4d6bb4 --- /dev/null +++ b/antigravity/tests/lifecycle.test.js @@ -0,0 +1,516 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { startFakeEveros } from "./helpers/fake-everos.js"; +import { runHookScript } from "./helpers/run-hook.js"; +import { + loadSessionState, + saveSessionState, + getSessionFilePath, + createDefaultSessionState, +} from "../hooks/scripts/lib/state.js"; + +function makeTempDir() { + return fs.mkdtempSync(path.join(os.tmpdir(), "everos-lifecycle-test-")); +} + +function createMockSearch(includeProfileByDefault = false) { + return (body) => { + const shouldIncludeProfile = body.include_profile ?? includeProfileByDefault; + return { + episodes: [ + { + subject: "Architecture Design", + summary: "Decoupled state machine", + atomic_facts: ["All hooks are stateless and fail-open"], + }, + ], + agent_cases: [ + { + task_intent: "Event bus design", + key_insight: "Zero runtime dependencies", + }, + ], + profile: shouldIncludeProfile + ? { + profile_data: { + explicit_info: { encoding: "utf-8", dependencies: "pure ESM zero-dep" }, + implicit_traits: ["Prefers two-phase commit over optimistic mutation"], + }, + } + : null, + }; + }; +} + +test("lifecycle: full end-to-end integration flow", async (t) => { + const fake = await startFakeEveros({ searchFn: createMockSearch(true) }); + const testDataDir = makeTempDir(); + const transcriptDir = makeTempDir(); + const transcriptFile = path.join(transcriptDir, "transcript.jsonl"); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + fs.rmSync(transcriptDir, { recursive: true, force: true }); + }); + + const baseEnv = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_USER_ID: "tester", + EVEROS_AG_PROJECT_ID: "github.com_artemis_repo", + EVEROS_AG_RECALL_TIMEOUT_MS: "2000", + }; + + const conversationId = "conv_lifecycle_001"; + + // ------------------------------------------------------------- + // Step 1: SessionStart - Daemon health check + L1 Profile injection + // ------------------------------------------------------------- + const sessionStartRes = await runHookScript( + "hooks/scripts/session-start.js", + { + conversationId, + workspacePaths: ["C:/Workspace/MockRepo"], + transcriptPath: transcriptFile, + }, + baseEnv + ); + + assert.equal(sessionStartRes.code, 0); + assert.ok(sessionStartRes.json); + assert.ok(sessionStartRes.json.injectSteps); + assert.equal(sessionStartRes.json.injectSteps.length, 1); + const sysMsg = sessionStartRes.json.injectSteps[0].systemMessage.systemMessage; + assert.match(sysMsg, //); + assert.match(sysMsg, /【既定规约】/); + assert.match(sysMsg, /pure ESM zero-dep/); + + // Verify state has_injected_profile + const stateAfterStart = loadSessionState(testDataDir, conversationId); + assert.equal(stateAfterStart.has_injected_profile, true); + + // ------------------------------------------------------------- + // Step 2: PreInvocation (Recall) - Turn 0 + // ------------------------------------------------------------- + fs.writeFileSync( + transcriptFile, + JSON.stringify({ + step_index: 0, + type: "USER_INPUT", + source: "USER_EXPLICIT", + content: "请设计一个零依赖的高性能事件总线系统", + }) + "\n", + "utf8" + ); + + const recall1Res = await runHookScript( + "hooks/scripts/recall.js", + { + conversationId, + invocationNum: 1, + transcriptPath: transcriptFile, + }, + baseEnv + ); + + assert.equal(recall1Res.code, 0); + assert.ok(recall1Res.json.injectSteps); + const ephemeralMsg = recall1Res.json.injectSteps[0].ephemeralMessage; + assert.match(ephemeralMsg, //); + assert.match(ephemeralMsg, /【空间归属】project_id: github.com_artemis_repo/); + assert.match(ephemeralMsg, /【曾有范例】/); + assert.match(ephemeralMsg, /Event bus design/); + + // State should have turn_0 recorded in recalled_turn_ids (turnId includes sha1 digest) + const stateAfterRecall1 = loadSessionState(testDataDir, conversationId); + assert.equal(stateAfterRecall1.recalled_turn_ids.length, 1); + assert.match(stateAfterRecall1.recalled_turn_ids[0], /^turn_0_[0-9a-f]{8}$/); + + // ------------------------------------------------------------- + // Step 3: Tool Loop Double-Lock - Turn 0 repeated invocation + // ------------------------------------------------------------- + const recall2Res = await runHookScript( + "hooks/scripts/recall.js", + { + conversationId, + invocationNum: 2, + transcriptPath: transcriptFile, + }, + baseEnv + ); + + assert.equal(recall2Res.code, 0); + assert.deepEqual(recall2Res.json, {}); // Double-lock intercepted! + + // ------------------------------------------------------------- + // Step 4: Stop (Capture) - Turn 0 completion & 2PC Ingestion + // ------------------------------------------------------------- + fs.appendFileSync( + transcriptFile, + [ + JSON.stringify({ + step_index: 1, + type: "PLANNER_RESPONSE", + thinking: "internal thoughts that should be stripped", + tool_calls: [ + { + tool: "write_file", + arguments: { Path: "bus.js", Content: "export class Bus {}" }, + }, + ], + }), + JSON.stringify({ + step_index: 2, + type: "GENERIC", + content: "File written successfully", + }), + JSON.stringify({ + step_index: 3, + type: "PLANNER_RESPONSE", + content: "事件总线已设计完成并落盘。", + }), + ].join("\n") + "\n", + "utf8" + ); + + const initialAddCalls = fake.only("/api/v2/memory/add").length; + + const captureRes = await runHookScript( + "hooks/scripts/capture.js", + { + conversationId, + transcriptPath: transcriptFile, + terminationReason: "turn_completed", + }, + baseEnv + ); + + assert.equal(captureRes.code, 0); + assert.deepEqual(captureRes.json, {}); + + // Verify fake received /add + const addCallsAfter = fake.only("/api/v2/memory/add"); + assert.equal(addCallsAfter.length, initialAddCalls + 1); + const addPayload = addCallsAfter[addCallsAfter.length - 1].body; + assert.equal(addPayload.project_id, "github.com_artemis_repo"); + assert.equal(addPayload.session_id, conversationId); + // Verify thinking is stripped + assert.equal(JSON.stringify(addPayload).includes("internal thoughts"), false); + + // Verify 2PC settlement advanced + const stateAfterCapture = loadSessionState(testDataDir, conversationId); + assert.equal(stateAfterCapture.observed_turn_index, 3); + assert.equal(stateAfterCapture.settled_turn_index, 3); + + // ------------------------------------------------------------- + // Step 5: 2PC Resilience - Network Error Keeps Settled Turn Unadvanced + // ------------------------------------------------------------- + fs.appendFileSync( + transcriptFile, + JSON.stringify({ + step_index: 4, + type: "USER_INPUT", + source: "USER_EXPLICIT", + content: "请继续添加单元测试", + }) + "\n", + "utf8" + ); + + // Simulate network failure by pointing to non-existent port + const badEnv = { ...baseEnv, EVEROS_AG_BASE_URL: "http://127.0.0.1:59999" }; + const captureFailRes = await runHookScript( + "hooks/scripts/capture.js", + { + conversationId, + transcriptPath: transcriptFile, + }, + badEnv + ); + + assert.equal(captureFailRes.code, 0); // Fail-open: exit code 0 + const stateAfterFailedCapture = loadSessionState(testDataDir, conversationId); + // Observed was updated to 4, but settled index remains 3 (Nack!) + assert.equal(stateAfterFailedCapture.observed_turn_index, 4); + assert.equal(stateAfterFailedCapture.settled_turn_index, 3); + + // ------------------------------------------------------------- + // Step 6: Stale Sweep 2PC Compensation in SessionStart + // ------------------------------------------------------------- + // Create an orphan stale session in dataDir + const staleSessionId = "conv_stale_999"; + const staleState = createDefaultSessionState(staleSessionId, { + projectId: "github.com_other_repo", + flushed: false, + }); + staleState.updated_at = Date.now() - 3600 * 1000; // 1 hour ago + const staleFile = getSessionFilePath(testDataDir, staleSessionId); + fs.writeFileSync(staleFile, JSON.stringify(staleState, null, 2), "utf8"); + + // Run SessionStart for a new session + const res2 = await runHookScript( + "hooks/scripts/session-start.js", + { + conversationId: "conv_new_002", + workspacePaths: ["C:/Workspace/MockRepo"], + transcriptPath: transcriptFile, + }, + baseEnv + ); + + // Verify fake received /flush for github.com_other_repo (detached background flush) + for (let attempt = 0; attempt < 40; attempt++) { + const calls = fake + .only("/api/v2/memory/flush") + .filter((c) => c.body?.project_id === "github.com_other_repo"); + if (calls.length >= 1) break; + await new Promise((r) => setTimeout(r, 50)); + } + const flushCalls = fake + .only("/api/v2/memory/flush") + .filter((c) => c.body?.project_id === "github.com_other_repo"); + assert.equal(flushCalls.length, 1); + + // Verify stale state was marked flushed: true + for (let attempt = 0; attempt < 40; attempt++) { + const s = loadSessionState(testDataDir, staleSessionId); + if (s.flushed) break; + await new Promise((r) => setTimeout(r, 50)); + } + const reloadedStale = loadSessionState(testDataDir, staleSessionId); + assert.equal(reloadedStale.flushed, true); + + // ------------------------------------------------------------- + // Step 7: Flush Script (Explicit 2PC Seal) + // ------------------------------------------------------------- + const flushRes = await runHookScript( + "hooks/scripts/flush.js", + { + conversationId, + }, + baseEnv + ); + assert.equal(flushRes.code, 0); + assert.equal(flushRes.json.success, true); + const reloadedMain = loadSessionState(testDataDir, conversationId); + assert.equal(reloadedMain.flushed, true); + + // ------------------------------------------------------------- + // Step 8: Strict Audit Verification - Wire Payload app_id Invariant + // ------------------------------------------------------------- + const everosRequests = fake.requests.filter((r) => r.path.startsWith("/api/v2/memory/")); + assert.ok(everosRequests.length >= 4); + for (const req of everosRequests) { + assert.equal( + req.body?.app_id, + "antigravity", + `Expected app_id: 'antigravity' on ${req.method} ${req.path}` + ); + } +}); + +test("lifecycle: cold-start profile fallback in PreInvocation", async (t) => { + const fake = await startFakeEveros({ searchFn: createMockSearch(false) }); + const testDataDir = makeTempDir(); + const transcriptDir = makeTempDir(); + const transcriptFile = path.join(transcriptDir, "transcript.jsonl"); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + fs.rmSync(transcriptDir, { recursive: true, force: true }); + }); + + const baseEnv = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_USER_ID: "tester", + EVEROS_AG_PROJECT_ID: "github.com_cold_start", + }; + + const conversationId = "conv_cold_fallback"; + + // Simulate SessionStart when server was dead: + // We manually write state with has_injected_profile: false + const state = createDefaultSessionState(conversationId, { + projectId: "github.com_cold_start", + has_injected_profile: false, + }); + saveSessionState(testDataDir, state); + + // User input prompt in transcript + fs.writeFileSync( + transcriptFile, + JSON.stringify({ + step_index: 0, + type: "USER_INPUT", + source: "USER_EXPLICIT", + content: "如何配置零运行时依赖构建系统？", + }) + "\n", + "utf8" + ); + + // Trigger recall when server is now healthy + const recallRes = await runHookScript( + "hooks/scripts/recall.js", + { + conversationId, + invocationNum: 1, + transcriptPath: transcriptFile, + }, + baseEnv + ); + + assert.equal(recallRes.code, 0); + assert.ok(recallRes.json); + assert.ok(recallRes.json.injectSteps); + const ephemeralMsg = recallRes.json.injectSteps[0].ephemeralMessage; + // Should contain BOTH profile fallback () and memory () + assert.match(ephemeralMsg, //); + assert.match(ephemeralMsg, //); + + // State should be updated: has_injected_profile becomes true + const stateAfterFallback = loadSessionState(testDataDir, conversationId); + assert.equal(stateAfterFallback.has_injected_profile, true); +}); + +test("lifecycle: stale sweep preserves unflushed Nack when flush returns 500", async (t) => { + const fake = await startFakeEveros({ flushStatus: 500 }); + const testDataDir = makeTempDir(); + const transcriptDir = makeTempDir(); + const transcriptFile = path.join(transcriptDir, "transcript.jsonl"); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + fs.rmSync(transcriptDir, { recursive: true, force: true }); + }); + + const baseEnv = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_PROJECT_ID: "github.com_fail_flush", + }; + + const staleSessionId = "conv_stale_fail"; + const staleState = createDefaultSessionState(staleSessionId, { + projectId: "github.com_fail_flush", + flushed: false, + }); + staleState.updated_at = Date.now() - 3600 * 1000; + fs.writeFileSync( + getSessionFilePath(testDataDir, staleSessionId), + JSON.stringify(staleState) + ); + + const res = await runHookScript( + "hooks/scripts/session-start.js", + { + conversationId: "conv_fresh", + transcriptPath: transcriptFile, + }, + baseEnv + ); + assert.equal(res.code, 0); + + // Stale session must remain unflushed (Nack) + const reloaded = loadSessionState(testDataDir, staleSessionId); + assert.equal(reloaded.flushed, false); +}); + +test("lifecycle: capture chunks messages when count exceeds ADD_MAX_MESSAGES (500)", async (t) => { + const fake = await startFakeEveros(); + const testDataDir = makeTempDir(); + const transcriptDir = makeTempDir(); + const transcriptFile = path.join(transcriptDir, "transcript.jsonl"); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + fs.rmSync(transcriptDir, { recursive: true, force: true }); + }); + + const baseEnv = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_PROJECT_ID: "github.com_large_turn", + }; + + const conversationId = "conv_large_batch"; + + // Generate 600 turns/steps to exceed 500 limit + const lines = []; + lines.push( + JSON.stringify({ + step_index: 0, + type: "USER_INPUT", + source: "USER_EXPLICIT", + content: "Start heavy batch task", + }) + ); + + for (let i = 1; i <= 600; i++) { + lines.push( + JSON.stringify({ + step_index: i, + type: "PLANNER_RESPONSE", + content: `Step chunk item ${i}`, + }) + ); + } + + fs.writeFileSync(transcriptFile, lines.join("\n") + "\n", "utf8"); + + const captureRes = await runHookScript( + "hooks/scripts/capture.js", + { + conversationId, + transcriptPath: transcriptFile, + }, + baseEnv + ); + + assert.equal(captureRes.code, 0); + + // Verify fake received multiple /add requests, each strictly <= 500 messages + const addRequests = fake.only("/api/v2/memory/add"); + assert.ok(addRequests.length >= 2, `Expected at least 2 chunked batches, got ${addRequests.length}`); + for (const req of addRequests) { + assert.ok(req.body.messages.length <= 500); + assert.equal(req.body.app_id, "antigravity"); + } + + // 2PC Settle Phase advanced to step 600 + const state = loadSessionState(testDataDir, conversationId); + assert.equal(state.settled_turn_index, 600); +}); + +test("lifecycle: root hooks.json adheres to schema and referenced script files exist", () => { + const pluginRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); + const hooksJsonPath = path.join(pluginRoot, "hooks.json"); + + assert.ok(fs.existsSync(hooksJsonPath), "hooks.json must exist in plugin root"); + const raw = fs.readFileSync(hooksJsonPath, "utf8"); + const parsed = JSON.parse(raw); + + assert.ok(parsed["everos-antigravity"]); + const config = parsed["everos-antigravity"]; + assert.ok(Array.isArray(config.SessionStart)); + assert.ok(Array.isArray(config.PreInvocation)); + assert.ok(Array.isArray(config.Stop)); + + for (const event of ["SessionStart", "PreInvocation", "Stop"]) { + for (const hook of config[event]) { + assert.equal(hook.type, "command"); + const match = hook.command.match(/node\s+"([^"]+)"/); + assert.ok(match, `Invalid command format in ${event}`); + const scriptRel = match[1].replace(/^\$\{[A-Z_]*PLUGIN_ROOT:-?\.?\}\//, ""); + const targetScript = path.join(pluginRoot, scriptRel); + assert.ok(fs.existsSync(targetScript), `Script file ${scriptRel} does not exist`); + } + } +}); diff --git a/antigravity/tests/manifests.test.js b/antigravity/tests/manifests.test.js new file mode 100644 index 0000000..a60f1dc --- /dev/null +++ b/antigravity/tests/manifests.test.js @@ -0,0 +1,101 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { execFileSync, spawnSync } from "node:child_process"; +import { fileURLToPath } from "node:url"; + +const here = path.dirname(fileURLToPath(import.meta.url)); +const root = path.resolve(here, ".."); + +test("manifests: hooks.json exists uniquely and target scripts exist", () => { + const rootHooks = path.join(root, "hooks.json"); + const nestedHooks = path.join(root, "hooks", "hooks.json"); + + assert.ok(fs.existsSync(rootHooks), "root hooks.json must exist"); + assert.ok(!fs.existsSync(nestedHooks), "hooks/hooks.json must not exist"); + + const doc = JSON.parse(fs.readFileSync(rootHooks, "utf8")); + const events = doc["everos-antigravity"]; + assert.ok(events, "everos-antigravity namespace must be present"); + + for (const [ev, arr] of Object.entries(events)) { + for (const item of arr) { + assert.equal(item.type, "command"); + const clean = item.command + .replace(/^node\s+/, "") + .replace(/^"|"$/g, "") + .replace(/^\$\{[A-Z_]*PLUGIN_ROOT:-?\.?\}\//, ""); + const abs = path.resolve(root, clean); + assert.ok(fs.existsSync(abs), `${ev} script must exist at ${abs}`); + } + } +}); + +test("manifests: install.mjs injects absolute paths and hooks execute in foreign cwd", () => { + const tmpWs = fs.mkdtempSync(path.join(os.tmpdir(), "everos-install-test-")); + + try { + const installScript = path.join(root, "scripts", "install.mjs"); + execFileSync(process.execPath, [installScript, "--workspace", tmpWs], { + stdio: "pipe", + }); + + const targetHooksPath = path.join(tmpWs, ".agents", "hooks.json"); + assert.ok(fs.existsSync(targetHooksPath), "installed hooks.json must exist"); + + const targetHooks = JSON.parse(fs.readFileSync(targetHooksPath, "utf8")); + const commands = targetHooks["everos-antigravity"]; + + // Execute SessionStart in foreign cwd + const startCmd = commands.SessionStart[0].command; + const startRes = spawnSync(startCmd, { + shell: true, + cwd: tmpWs, + input: JSON.stringify({ + conversationId: "test_foreign_cwd", + workspacePaths: [tmpWs], + }), + encoding: "utf8", + }); + + assert.equal(startRes.status, 0, `SessionStart stderr: ${startRes.stderr}`); + const startJson = JSON.parse(startRes.stdout.trim() || "{}"); + assert.ok(typeof startJson === "object"); + + // Execute PreInvocation in foreign cwd + const recallCmd = commands.PreInvocation[0].command; + const recallRes = spawnSync(recallCmd, { + shell: true, + cwd: tmpWs, + input: JSON.stringify({ + conversationId: "test_foreign_cwd", + workspacePaths: [tmpWs], + }), + encoding: "utf8", + }); + + assert.equal(recallRes.status, 0, `PreInvocation stderr: ${recallRes.stderr}`); + const recallJson = JSON.parse(recallRes.stdout.trim() || "{}"); + assert.ok(typeof recallJson === "object"); + + // Execute Stop in foreign cwd + const stopCmd = commands.Stop[0].command; + const stopRes = spawnSync(stopCmd, { + shell: true, + cwd: tmpWs, + input: JSON.stringify({ + conversationId: "test_foreign_cwd", + workspacePaths: [tmpWs], + }), + encoding: "utf8", + }); + + assert.equal(stopRes.status, 0, `Stop stderr: ${stopRes.stderr}`); + const stopJson = JSON.parse(stopRes.stdout.trim() || "{}"); + assert.ok(typeof stopJson === "object"); + } finally { + fs.rmSync(tmpWs, { recursive: true, force: true }); + } +}); diff --git a/antigravity/tests/mcp-server.test.js b/antigravity/tests/mcp-server.test.js new file mode 100644 index 0000000..09518a7 --- /dev/null +++ b/antigravity/tests/mcp-server.test.js @@ -0,0 +1,406 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { spawn } from "node:child_process"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import readline from "node:readline"; +import { startFakeEveros } from "./helpers/fake-everos.js"; + +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); + +function spawnMcpClient(env = {}) { + const child = spawn(process.execPath, [path.join(root, "mcp", "server.js")], { + env: { + ...process.env, + ...env, + }, + stdio: ["pipe", "pipe", "pipe"], + }); + + const rl = readline.createInterface({ input: child.stdout, terminal: false }); + const pendingRequests = new Map(); + const listeners = []; + + rl.on("line", (line) => { + const trimmed = line.trim(); + if (!trimmed) return; + try { + const msg = JSON.parse(trimmed); + for (const listener of [...listeners]) { + listener(msg); + } + if (msg.id !== undefined && pendingRequests.has(msg.id)) { + const { resolve } = pendingRequests.get(msg.id); + pendingRequests.delete(msg.id); + resolve(msg); + } + } catch {} + }); + + let nextId = 1; + function sendRequest(method, params = {}) { + return new Promise((resolve, reject) => { + const id = nextId++; + pendingRequests.set(id, { resolve, reject }); + child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n", "utf8"); + }); + } + + function sendRaw(raw) { + child.stdin.write(raw, "utf8"); + } + + function waitForMessage(predicate, timeoutMs = 3000) { + return new Promise((resolve, reject) => { + const timer = setTimeout(() => { + const idx = listeners.indexOf(onMsg); + if (idx !== -1) listeners.splice(idx, 1); + reject(new Error(`Timed out waiting for message after ${timeoutMs}ms`)); + }, timeoutMs); + + const onMsg = (msg) => { + if (predicate(msg)) { + clearTimeout(timer); + const idx = listeners.indexOf(onMsg); + if (idx !== -1) listeners.splice(idx, 1); + resolve(msg); + } + }; + + listeners.push(onMsg); + }); + } + + function close() { + return new Promise((resolve) => { + child.kill(); + child.on("close", resolve); + }); + } + + return { sendRequest, sendRaw, waitForMessage, close, child }; +} + +function createMockSearchData() { + return (body) => { + return { + episodes: [ + { + subject: "Architecture Seam", + summary: "Decoupled MCP from lifecycle", + atomic_facts: ["Stdio line-buffering prevents fragmentation"], + }, + ], + agent_cases: [ + { + task_intent: "MCP Protocol Conformance", + key_insight: "CallToolResult content wrapping is mandatory", + }, + ], + profile: { + profile_data: { + explicit_info: { dependencies: "zero-dep pure ESM" }, + implicit_traits: ["Prefers fail-open error containment"], + }, + }, + }; + }; +} + +test("mcp-server: initialize and ping handshake", async (t) => { + const fake = await startFakeEveros(); + const client = spawnMcpClient({ EVEROS_AG_BASE_URL: fake.baseUrl }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + // 1. initialize + const initRes = await client.sendRequest("initialize"); + assert.equal(initRes.result.serverInfo.name, "everos-antigravity"); + assert.equal(initRes.result.protocolVersion, "2024-11-05"); + assert.ok(initRes.result.capabilities.tools); + + // 2. ping + const pingRes = await client.sendRequest("ping"); + assert.deepEqual(pingRes.result, {}); +}); + +test("mcp-server: tools/list lists 3 prefixed tools with valid schemas", async (t) => { + const fake = await startFakeEveros(); + const client = spawnMcpClient({ EVEROS_AG_BASE_URL: fake.baseUrl }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + const res = await client.sendRequest("tools/list"); + assert.ok(res.result.tools); + assert.equal(res.result.tools.length, 3); + + const toolNames = res.result.tools.map((t) => t.name); + assert.deepEqual(toolNames, [ + "everos_search_memory", + "everos_get_profile", + "everos_add_memory", + ]); + + // Verify search tool schema + const searchTool = res.result.tools.find((t) => t.name === "everos_search_memory"); + assert.equal(searchTool.inputSchema.required[0], "query"); + assert.ok(searchTool.inputSchema.properties.raw); +}); + +test("mcp-server: everos_search_memory supports progressive disclosure (Markdown vs raw JSON)", async (t) => { + const fake = await startFakeEveros({ searchFn: createMockSearchData() }); + const client = spawnMcpClient({ + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_PROJECT_ID: "github.com_mcp_test", + }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + // 1. Default mode: clean Markdown with raw hint + const mdRes = await client.sendRequest("tools/call", { + name: "everos_search_memory", + arguments: { query: "MCP protocol" }, + }); + + assert.equal(mdRes.result.isError, false); + assert.ok(Array.isArray(mdRes.result.content)); + const text = mdRes.result.content[0].text; + assert.match(text, //); + assert.match(text, /【曾有范例】/); + assert.match(text, /CallToolResult content wrapping is mandatory/); + assert.match(text, /raw: true/); // Progressive disclosure hint! + + // 2. Raw JSON mode: full metadata + const rawRes = await client.sendRequest("tools/call", { + name: "everos_search_memory", + arguments: { query: "MCP protocol", raw: true }, + }); + + assert.equal(rawRes.result.isError, false); + const rawText = rawRes.result.content[0].text; + const parsedRaw = JSON.parse(rawText); + assert.ok(Array.isArray(parsedRaw.episodes)); + assert.ok(Array.isArray(parsedRaw.agent_cases)); + assert.equal(parsedRaw.agent_cases[0].task_intent, "MCP Protocol Conformance"); + + // 3. Validation error on missing query + const errRes = await client.sendRequest("tools/call", { + name: "everos_search_memory", + arguments: {}, + }); + assert.equal(errRes.result.isError, true); + assert.match(errRes.result.content[0].text, /query parameter is required/); + + // 4. Strict wire payload assertion: verify app_id and project_id on wire + const searchReqs = fake.only("/api/v2/memory/search"); + assert.ok(searchReqs.length >= 2); + for (const req of searchReqs) { + assert.equal(req.body.app_id, "antigravity"); + assert.equal(req.body.project_id, "github.com_mcp_test"); + assert.equal(req.body.query, "MCP protocol"); + } +}); + +test("mcp-server: everos_get_profile returns clean Markdown or raw JSON", async (t) => { + const fake = await startFakeEveros({ searchFn: createMockSearchData() }); + const client = spawnMcpClient({ + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_PROJECT_ID: "github.com_mcp_test", + }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + // Markdown mode + const mdRes = await client.sendRequest("tools/call", { + name: "everos_get_profile", + arguments: {}, + }); + + assert.equal(mdRes.result.isError, false); + const text = mdRes.result.content[0].text; + assert.match(text, //); + assert.match(text, /【既定规约】/); + assert.match(text, /zero-dep pure ESM/); + + // Raw JSON mode + const rawRes = await client.sendRequest("tools/call", { + name: "everos_get_profile", + arguments: { raw: true }, + }); + + assert.equal(rawRes.result.isError, false); + const parsed = JSON.parse(rawRes.result.content[0].text); + assert.equal(parsed.profile_data.explicit_info.dependencies, "zero-dep pure ESM"); + + // Strict wire payload assertion + const profileReqs = fake.only("/api/v2/memory/search"); + assert.ok(profileReqs.length >= 1); + for (const req of profileReqs) { + assert.equal(req.body.app_id, "antigravity"); + assert.equal(req.body.project_id, "github.com_mcp_test"); + assert.equal(req.body.include_profile, true); + } +}); + +test("mcp-server: everos_add_memory successfully ingests memory with app_id", async (t) => { + const fake = await startFakeEveros(); + const client = spawnMcpClient({ + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_PROJECT_ID: "github.com_mcp_test", + }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + const addRes = await client.sendRequest("tools/call", { + name: "everos_add_memory", + arguments: { + content: "Always use readline interface for line-buffered stdio framing in Node.js", + category: "case", + }, + }); + + assert.equal(addRes.result.isError, false); + assert.match(addRes.result.content[0].text, /Successfully ingested memory/); + + // Verify fake received /add with app_id: "antigravity" + const addRequests = fake.only("/api/v2/memory/add"); + assert.equal(addRequests.length, 1); + assert.equal(addRequests[0].body.app_id, "antigravity"); + assert.equal(addRequests[0].body.project_id, "github.com_mcp_test"); + assert.match(addRequests[0].body.messages[0].content, /Always use readline interface/); +}); + +test("mcp-server: returns appropriate error codes for unknown method and unknown tool", async (t) => { + const fake = await startFakeEveros(); + const client = spawnMcpClient({ EVEROS_AG_BASE_URL: fake.baseUrl }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + // Unknown method + const methodRes = await client.sendRequest("invalid_method"); + assert.equal(methodRes.error.code, -32601); + assert.match(methodRes.error.message, /Method not found/); + + // Unknown tool + const toolRes = await client.sendRequest("tools/call", { + name: "non_existent_tool", + }); + assert.equal(toolRes.result.isError, true); + assert.match(toolRes.result.content[0].text, /Unknown tool/); +}); + +test("mcp-server: handles chunked (split-packet) and coalesced (sticky-packet) stdio frames", async (t) => { + const fake = await startFakeEveros(); + const client = spawnMcpClient({ EVEROS_AG_BASE_URL: fake.baseUrl }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + // 1. Chunked (split-packet) delivery + const chunkWait = client.waitForMessage((m) => m.id === 501); + client.sendRaw('{"jsonrpc":"2.0","id":501,'); + await new Promise((r) => setTimeout(r, 20)); + client.sendRaw('"method":"ping"}\n'); + + const chunkRes = await chunkWait; + assert.equal(chunkRes.id, 501); + assert.deepEqual(chunkRes.result, {}); + + // 2. Coalesced (sticky-packet) delivery: two complete JSON frames in one buffer write + const wait601 = client.waitForMessage((m) => m.id === 601); + const wait602 = client.waitForMessage((m) => m.id === 602); + client.sendRaw( + '{"jsonrpc":"2.0","id":601,"method":"ping"}\n{"jsonrpc":"2.0","id":602,"method":"ping"}\n' + ); + + const [res601, res602] = await Promise.all([wait601, wait602]); + assert.equal(res601.id, 601); + assert.equal(res602.id, 602); +}); + +test("mcp-server: returns -32700 Parse error on malformed JSON without crashing", async (t) => { + const fake = await startFakeEveros(); + const client = spawnMcpClient({ EVEROS_AG_BASE_URL: fake.baseUrl }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + const parseErrorWait = client.waitForMessage((m) => m.error?.code === -32700); + client.sendRaw('{"jsonrpc":"2.0", broken json...\n'); + + const errRes = await parseErrorWait; + assert.equal(errRes.id, null); + assert.equal(errRes.error.code, -32700); + assert.match(errRes.error.message, /Parse error: invalid JSON/); + + // Verify server is still alive and processes subsequent valid requests + const pingRes = await client.sendRequest("ping"); + assert.deepEqual(pingRes.result, {}); +}); + +test("mcp-server: silently consumes notifications without replying or crashing", async (t) => { + const fake = await startFakeEveros(); + const client = spawnMcpClient({ EVEROS_AG_BASE_URL: fake.baseUrl }); + + t.after(async () => { + await client.close(); + fake.close(); + }); + + // Send initialized notification (no id) + client.sendRaw('{"jsonrpc":"2.0","method":"notifications/initialized"}\n'); + + // Send a subsequent ping request to confirm notification produced no phantom reply + const pingRes = await client.sendRequest("ping"); + assert.deepEqual(pingRes.result, {}); +}); + +test("mcp-server: returns isError: true when EverOS backend is unreachable", async (t) => { + // Use a non-routable port to simulate complete outage + const client = spawnMcpClient({ EVEROS_AG_BASE_URL: "http://127.0.0.1:1" }); + + t.after(async () => { + await client.close(); + }); + + const res = await client.sendRequest("tools/call", { + name: "everos_search_memory", + arguments: { query: "fail-test" }, + }); + + assert.equal(res.result.isError, true); + assert.match(res.result.content[0].text, /EverOS search unavailable:/); + + // Also test everos_get_profile resilience under outage + const profileRes = await client.sendRequest("tools/call", { + name: "everos_get_profile", + }); + assert.equal(profileRes.result.isError, true); + assert.match(profileRes.result.content[0].text, /EverOS profile unavailable:/); + + // Process should remain healthy and answer ping + const pingRes = await client.sendRequest("ping"); + assert.deepEqual(pingRes.result, {}); +}); diff --git a/antigravity/tests/provision.test.js b/antigravity/tests/provision.test.js new file mode 100644 index 0000000..7e53bf9 --- /dev/null +++ b/antigravity/tests/provision.test.js @@ -0,0 +1,187 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { ensureServerRunning, resetSpawnThrottle } from "../hooks/scripts/lib/provision.js"; + +test.beforeEach(() => { + resetSpawnThrottle(); +}); + +test("provision: returns ok: true, spawned: false when already healthy", async () => { + let healthCalls = 0; + const fakeClient = { + async health() { + healthCalls++; + return { status: "ok" }; + }, + }; + + let spawnCalls = 0; + const fakeSpawn = () => { + spawnCalls++; + return { unref() {} }; + }; + + const res = await ensureServerRunning( + { baseUrl: "http://127.0.0.1:8000", startCmd: ["echo", "start"] }, + { client: fakeClient, spawnImpl: fakeSpawn } + ); + + assert.equal(res.ok, true); + assert.equal(res.spawned, false); + assert.equal(healthCalls, 1); + assert.equal(spawnCalls, 0); +}); + +test("provision: does not spawn on non-loopback host", async () => { + const fakeClient = { + async health() { + throw new Error("network error"); + }, + }; + + let spawnCalls = 0; + const fakeSpawn = () => { + spawnCalls++; + return { unref() {} }; + }; + + const res = await ensureServerRunning( + { baseUrl: "https://remote.everos.internal:8000", startCmd: ["echo", "start"] }, + { client: fakeClient, spawnImpl: fakeSpawn } + ); + + assert.equal(res.ok, false); + assert.equal(res.spawned, false); + assert.equal(res.reason, "server_offline"); + assert.equal(spawnCalls, 0); +}); + +test("provision: spawns and succeeds after polling", async () => { + let healthCount = 0; + const fakeClient = { + async health() { + healthCount++; + if (healthCount === 1) { + throw new Error("offline"); + } + return { status: "ok" }; + }, + }; + + let spawnedWith = null; + const fakeSpawn = (cmd, args, opts) => { + spawnedWith = { cmd, args, opts }; + return { unref() {} }; + }; + + const res = await ensureServerRunning( + { + baseUrl: "http://127.0.0.1:8000", + startCmd: ["everos", "server", "start"], + everosDir: "f:/EverOS", + }, + { + client: fakeClient, + spawnImpl: fakeSpawn, + retries: 2, + retryDelayMs: 10, + } + ); + + assert.equal(res.ok, true); + assert.equal(res.spawned, true); + assert.equal(spawnedWith.cmd, "everos"); + assert.deepEqual(spawnedWith.args, ["server", "start"]); + assert.equal(spawnedWith.opts.detached, true); +}); + +test("provision: fails open with timeout if server does not come up", async () => { + const fakeClient = { + async health() { + throw new Error("connection refused"); + }, + }; + + let spawnCount = 0; + const fakeSpawn = () => { + spawnCount++; + return { unref() {} }; + }; + + const res = await ensureServerRunning( + { baseUrl: "http://127.0.0.1:8000", startCmd: ["everos", "start"] }, + { + client: fakeClient, + spawnImpl: fakeSpawn, + retries: 2, + retryDelayMs: 10, + } + ); + + assert.equal(res.ok, false); + assert.equal(res.spawned, true); + assert.equal(res.error, "timeout"); + assert.equal(spawnCount, 1); +}); + +test("provision: throttles repeated spawn attempts", async () => { + const fakeClient = { + async health() { + throw new Error("offline"); + }, + }; + + let spawnCount = 0; + const fakeSpawn = () => { + spawnCount++; + return { unref() {} }; + }; + + const config = { baseUrl: "http://127.0.0.1:8000", startCmd: ["echo", "start"] }; + const opts = { + client: fakeClient, + spawnImpl: fakeSpawn, + retries: 1, + retryDelayMs: 5, + throttleMs: 5000, + }; + + // First call spawns + const res1 = await ensureServerRunning(config, opts); + assert.equal(res1.spawned, true); + assert.equal(spawnCount, 1); + + // Second immediate call is throttled + const res2 = await ensureServerRunning(config, opts); + assert.equal(res2.ok, false); + assert.equal(res2.spawned, false); + assert.equal(res2.reason, "throttled"); + assert.equal(spawnCount, 1); +}); + +test("provision: returns ok: false, reason: 'unhealthy' and does not spawn when /health 200 has healthy: false (D3-03)", async () => { + let healthCalls = 0; + const fakeClient = { + async health() { + healthCalls++; + return { status: "ok", healthy: false, cascade: { healthy: false } }; + }, + }; + + let spawnCalls = 0; + const fakeSpawn = () => { + spawnCalls++; + return { unref() {} }; + }; + + const res = await ensureServerRunning( + { baseUrl: "http://127.0.0.1:8000", startCmd: ["echo", "start"] }, + { client: fakeClient, spawnImpl: fakeSpawn } + ); + + assert.equal(res.ok, false); + assert.equal(res.spawned, false); + assert.equal(res.reason, "unhealthy"); + assert.equal(healthCalls, 1); + assert.equal(spawnCalls, 0); // Must NOT spawn when process is running but unhealthy +}); diff --git a/antigravity/tests/query.test.js b/antigravity/tests/query.test.js new file mode 100644 index 0000000..6350147 --- /dev/null +++ b/antigravity/tests/query.test.js @@ -0,0 +1,60 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { + stripHostWrappers, + stripNoise, + countTokens, + shouldRecall, + buildQuery, +} from "../hooks/scripts/lib/query.js"; + +test("stripHostWrappers removes host metadata and memory wrappers", () => { + const input = `\nPlease optimize this function\nHost reminderOld memory`; + assert.equal(stripHostWrappers(input).trim(), "Please optimize this function"); +}); + +test("stripNoise folds code fences and long runs into placeholders", () => { + const code = "Check this code:\n```javascript\nconst a = 1;\nconsole.log(a);\n```\nDone."; + assert.equal(stripNoise(code), "Check this code:\n[code]\nDone."); + + const longRun = "word " + "a".repeat(500) + " end"; + assert.equal(stripNoise(longRun), "word […] end"); +}); + +test("countTokens counts individual CJK glyphs and Latin words accurately", () => { + assert.equal(countTokens("Hello world"), 2); + assert.equal(countTokens("你好世界"), 4); + assert.equal(countTokens("修复 bug 流程"), 5); // 修复流程 (4 CJK) + bug (1 Latin) = 5 + assert.equal(countTokens(""), 0); + assert.equal(countTokens(null), 0); +}); + +test("shouldRecall rejects slash commands even when wrapped in host tags", () => { + assert.equal(shouldRecall("/plan"), false); + assert.equal(shouldRecall("/everos:status"), false); + assert.equal(shouldRecall("/compact"), false); + // Wrapped in host tags as Antigravity actually delivers them: + assert.equal(shouldRecall("\n/plan build something new\n"), false); + assert.equal(shouldRecall("/everos:flush"), false); +}); + +test("shouldRecall rejects trivial acknowledgements", () => { + assert.equal(shouldRecall("ok"), false); + assert.equal(shouldRecall("收到"), false); + assert.equal(shouldRecall("好的"), false); + assert.equal(shouldRecall(""), false); + assert.equal(shouldRecall(" "), false); +}); + +test("shouldRecall accepts substantive questions and engineering prompts", () => { + assert.equal(shouldRecall("请帮我实现转录状态机清洗函数"), true); + assert.equal(shouldRecall("How do we fix the NTFS EBUSY issue?"), true); + assert.equal(shouldRecall("\n优化当前阶段的代码结构并跑单元测试\n"), true); +}); + +test("buildQuery clips long prompts at the head to preserve core intent", () => { + const text = "Core intent here. " + "Details details details. ".repeat(50); + const query = buildQuery(text, 50); + assert.equal(query.length <= 50, true); + assert.match(query, /^Core intent here\./); +}); diff --git a/antigravity/tests/recall-turnid.test.js b/antigravity/tests/recall-turnid.test.js new file mode 100644 index 0000000..0bbf04d --- /dev/null +++ b/antigravity/tests/recall-turnid.test.js @@ -0,0 +1,130 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { startFakeEveros } from "./helpers/fake-everos.js"; +import { runHookScript } from "./helpers/run-hook.js"; +import { loadSessionState } from "../hooks/scripts/lib/state.js"; + +function makeTempDir() { + return fs.mkdtempSync(path.join(os.tmpdir(), "everos-recall-turnid-test-")); +} + +test("recall: turnId binds to step_index and contentDigest (D2-03)", async (t) => { + let searchCallCount = 0; + const fake = await startFakeEveros({ + searchFn: (body) => { + searchCallCount++; + return { + episodes: [ + { + subject: "Turn ID Test", + summary: `Recall hit #${searchCallCount}`, + atomic_facts: ["Verified digest binding"], + }, + ], + profiles: [], + }; + }, + }); + + const testDataDir = makeTempDir(); + const transcriptDir = makeTempDir(); + const transcriptFile = path.join(transcriptDir, "transcript.jsonl"); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + fs.rmSync(transcriptDir, { recursive: true, force: true }); + }); + + const conversationId = "conv_turnid_test"; + const baseEnv = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_USER_ID: "tester", + EVEROS_AG_PROJECT_ID: "project_turnid", + EVEROS_AG_RECALL_TIMEOUT_MS: "2000", + }; + + // Run 1: First turn with step_index 0, content "First complex design question about architecture" + fs.writeFileSync( + transcriptFile, + JSON.stringify({ + step_index: 0, + type: "USER_INPUT", + source: "USER_EXPLICIT", + created_at: "2026-10-22T10:00:00Z", + content: "First complex design question about architecture", + }) + "\n", + "utf8" + ); + + const res1 = await runHookScript( + "hooks/scripts/recall.js", + { + conversationId, + workspacePaths: ["/mock/workspace"], + transcriptPath: transcriptFile, + }, + baseEnv + ); + + assert.equal(res1.code, 0); + assert.equal(searchCallCount, 2); // Dual track (user + agent) + assert.ok(res1.json?.injectSteps?.[0]?.ephemeralMessage?.includes("Turn ID Test")); + + const state1 = loadSessionState(testDataDir, conversationId); + assert.equal(state1.recalled_turn_ids.length, 1); + const turnId1 = state1.recalled_turn_ids[0]; + assert.match(turnId1, /^turn_0_[0-9a-f]{8}$/); + + // Run 2: Exact same step, same content -> should be deduped (short-circuit) + const res2 = await runHookScript( + "hooks/scripts/recall.js", + { + conversationId, + workspacePaths: ["/mock/workspace"], + transcriptPath: transcriptFile, + }, + baseEnv + ); + + assert.equal(res2.code, 0); + assert.equal(searchCallCount, 2); // No new search calls made + assert.deepEqual(res2.json, {}); // Short-circuited with {} + + // Run 3: Same step_index 0, but different content -> should generate different turnId and trigger search! + fs.writeFileSync( + transcriptFile, + JSON.stringify({ + step_index: 0, + type: "USER_INPUT", + source: "USER_EXPLICIT", + created_at: "2026-10-22T10:05:00Z", + content: "Different prompt at step 0 requiring recall", + }) + "\n", + "utf8" + ); + + const res3 = await runHookScript( + "hooks/scripts/recall.js", + { + conversationId, + workspacePaths: ["/mock/workspace"], + transcriptPath: transcriptFile, + }, + baseEnv + ); + + assert.equal(res3.code, 0); + assert.equal(searchCallCount, 4); // 2 more search calls executed! + assert.ok(res3.json?.injectSteps?.[0]?.ephemeralMessage?.includes("Turn ID Test")); + + const state3 = loadSessionState(testDataDir, conversationId); + assert.equal(state3.recalled_turn_ids.length, 2); + const turnId2 = state3.recalled_turn_ids[1]; + assert.notEqual(turnId1, turnId2); + assert.match(turnId2, /^turn_0_[0-9a-f]{8}$/); +}); diff --git a/antigravity/tests/render.test.js b/antigravity/tests/render.test.js new file mode 100644 index 0000000..72608b0 --- /dev/null +++ b/antigravity/tests/render.test.js @@ -0,0 +1,127 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { + neutralizeFenceTokens, + stripInjectedMemory, + renderProfileBlock, + renderMemoryBlock, + resolveAnchors, +} from "../hooks/scripts/lib/render.js"; + +test("neutralizeFenceTokens converts fence tags to inert brackets while preserving code generics (D7-01)", () => { + assert.equal(neutralizeFenceTokens(""), "[/everos_memory]"); + assert.equal( + neutralizeFenceTokens('injected'), + '[everos_memory type="fake"]injected[/everos_memory]', + ); + assert.equal(neutralizeFenceTokens("profile"), "[everos_profile]profile[/everos_profile]"); + // Preserves normal generic code and HTML/JSX + assert.equal(neutralizeFenceTokens("Array"), "Array"); + assert.equal(neutralizeFenceTokens("List>"), "List>"); + assert.equal(neutralizeFenceTokens('
hi
'), '
hi
'); + assert.equal(neutralizeFenceTokens("a < b and c > d"), "a < b and c > d"); +}); + +test("stripInjectedMemory removes memory and profile blocks without greedy EOF swallowing (D7-01)", () => { + const raw = `Prefix text\n\n【空间归属】\nSecret memory\n\nMiddle\n\nProfile data\n\nSuffix`; + assert.equal(stripInjectedMemory(raw), "Prefix text\n\nMiddle\n\nSuffix"); + + // Uppercase and tags with attributes: + const withAttrs = `Before\nInjected memory\nInjected profile\nAfter`; + assert.equal(stripInjectedMemory(withAttrs), "Before\n\nAfter"); + + // Unclosed fence tag does NOT swallow user text to EOF: + const unclosed = "先看 这个标签的用法，然后请解释 closure。"; + const stripped = stripInjectedMemory(unclosed); + assert.equal(stripped.includes("closure"), true); + assert.equal(stripped.includes(""), false); +}); + +test("renderProfileBlock renders Chinese anchors by default", () => { + const profile = { + profile_data: { + explicit_info: { encoding: "utf-8", runtime: "pure ESM" }, + implicit_traits: ["Prefers two-phase commit over optimistic mutation"], + }, + }; + const rendered = renderProfileBlock(profile, { projectId: "test_proj", branch: "main", locale: "zh" }); + assert.match(rendered, /^/); + assert.match(rendered, /【空间归属】project_id: test_proj \| branch: main/); + assert.match(rendered, /【使用准则】/); + assert.match(rendered, /【既定规约】\n- encoding: utf-8\n- runtime: pure ESM/); + assert.match(rendered, /【意趣默契】\n- Prefers two-phase commit over optimistic mutation/); + assert.match(rendered, /<\/everos_profile>$/); +}); + +test("renderProfileBlock renders English anchors when locale is en", () => { + const profile = { + profile_data: { + explicit_info: { encoding: "utf-8" }, + implicit_traits: ["Prefers defensive coding"], + }, + }; + const rendered = renderProfileBlock(profile, { projectId: "test_proj", branch: "main", locale: "en" }); + assert.match(rendered, /^/); + assert.match(rendered, /\[Spatial Scope\] project_id: test_proj \| branch: main/); + assert.match(rendered, /\[Operating Guidelines\]/); + assert.match(rendered, /\[Prescriptive Covenants\]\n- encoding: utf-8/); + assert.match(rendered, /\[Tacit Affinities\]\n- Prefers defensive coding/); + assert.match(rendered, /<\/everos_profile>$/); +}); + +test("renderMemoryBlock renders Top-3 cases and episodes with deduplication in Chinese", () => { + const searchResult = { + agent_cases: [ + { task_intent: "Resolve NTFS EBUSY", key_insight: "Atomic write with backoff" }, + { task_intent: "Fix port parsing", key_insight: "Strip port before host joining" }, + { task_intent: "Third case", key_insight: "Valid insight" }, + { task_intent: "Fourth case to be truncated", key_insight: "Should not appear" }, + ], + episodes: [ + { + subject: "Phase 1 Initialization", + summary: "Created basic infrastructure", + atomic_facts: [ + "Zero runtime dependencies", + { statement: "Node >= 20.0.0" }, // object fact support + "Zero runtime dependencies", // duplicate fact + ], + }, + { + subject: "Audit review", + summary: "Completed Subagent review", + atomic_facts: ["2 Critical bugs fixed"], + }, + ], + }; + + const rendered = renderMemoryBlock(searchResult, { projectId: "my_proj", branch: "dev", locale: "zh" }); + assert.match(rendered, /^/); + assert.match(rendered, /【空间归属】project_id: my_proj \| branch: dev/); + assert.match(rendered, /【曾有范例】/); + assert.match(rendered, /- Resolve NTFS EBUSY\n · Atomic write with backoff/); + assert.doesNotMatch(rendered, /Fourth case to be truncated/); + assert.match(rendered, /【交互脉络】/); + assert.match(rendered, /Phase 1 Initialization — Created basic infrastructure/); + assert.match(rendered, /· Node >= 20.0.0/); + // Verify deduplication: "Zero runtime dependencies" should appear only once under this episode + const count = (rendered.match(/· Zero runtime dependencies/g) || []).length; + assert.equal(count, 1); + assert.match(rendered, /<\/everos_memory>$/); +}); + +test("renderMemoryBlock renders clean English anchors when locale is en", () => { + const searchResult = { + agent_cases: [{ task_intent: "Bugfix", key_insight: "Patched" }], + episodes: [{ subject: "Release v1", summary: "Shipped", atomic_facts: ["Deployed"] }], + }; + const rendered = renderMemoryBlock(searchResult, { projectId: "p", branch: "main", locale: "en" }); + assert.match(rendered, /\[Spatial Scope\] project_id: p \| branch: main/); + assert.match(rendered, /\[Erstwhile Exemplars\]/); + assert.match(rendered, /\[Interwoven Vestiges\]/); +}); + +test("renderMemoryBlock returns null when all search result sections are empty", () => { + assert.equal(renderMemoryBlock({}, { locale: "zh" }), null); + assert.equal(renderMemoryBlock({ episodes: [], agent_cases: [], profiles: [] }, { locale: "zh" }), null); +}); diff --git a/antigravity/tests/search-tracks.test.js b/antigravity/tests/search-tracks.test.js new file mode 100644 index 0000000..1d6e4bb --- /dev/null +++ b/antigravity/tests/search-tracks.test.js @@ -0,0 +1,65 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { interleave, dualTrackSearch } from "../hooks/scripts/lib/search-tracks.js"; +import { renderMemoryBlock } from "../hooks/scripts/lib/render.js"; + +test("interleave: combines two arrays alternatingly without starving either (D2-04)", () => { + const user = ["u1", "u2", "u3", "u4", "u5"]; + const agent = ["a1", "a2"]; + const merged = interleave(user, agent); + assert.deepEqual(merged, ["u1", "a1", "u2", "a2", "u3", "u4", "u5"]); +}); + +test("dualTrackSearch: user track with 5 items does not starve agent cases in renderMemoryBlock (D2-04)", async () => { + const fakeClient = { + async search(body) { + if (body.user_id) { + return { + episodes: [ + { subject: "User Ep 1", summary: "E1", atomic_facts: ["f1"] }, + { subject: "User Ep 2", summary: "E2", atomic_facts: ["f2"] }, + { subject: "User Ep 3", summary: "E3", atomic_facts: ["f3"] }, + { subject: "User Ep 4", summary: "E4", atomic_facts: ["f4"] }, + { subject: "User Ep 5", summary: "E5", atomic_facts: ["f5"] }, + ], + agent_cases: [], + profiles: [], + }; + } + return { + episodes: [], + agent_cases: [ + { task_intent: "Agent Case 1", key_insight: "Insight 1" }, + { task_intent: "Agent Case 2", key_insight: "Insight 2" }, + ], + profiles: [], + }; + }, + }; + + const res = await dualTrackSearch(fakeClient, { + identity: { + appId: "antigravity", + projectId: "proj_dual_track", + userId: "user_alice", + agentId: "antigravity", + }, + query: "event bus", + }); + + assert.equal(res.episodes.length, 5); + assert.equal(res.agent_cases.length, 2); + + // When rendering with SECTION_MAX_ITEMS=3, agent cases section must still exist and be visible! + const rendered = renderMemoryBlock(res, { + projectId: "proj_dual_track", + branch: "main", + locale: "zh", + }); + + assert.ok(rendered); + assert.match(rendered, /【曾有范例】/); + assert.match(rendered, /Agent Case 1/); + assert.match(rendered, /【交互脉络】/); + assert.match(rendered, /User Ep 1/); +}); diff --git a/antigravity/tests/session-start-detached.test.js b/antigravity/tests/session-start-detached.test.js new file mode 100644 index 0000000..ff63d1d --- /dev/null +++ b/antigravity/tests/session-start-detached.test.js @@ -0,0 +1,120 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { startFakeEveros } from "./helpers/fake-everos.js"; +import { runHookScript } from "./helpers/run-hook.js"; +import { saveSessionState, loadSessionState } from "../hooks/scripts/lib/state.js"; + +test("session-start: sweep dispatches flush detached without blocking SessionStart budget (D4-01 / D3-02)", async (t) => { + // Fake EverOS with 1500ms flush delay + const fake = await startFakeEveros({ + flushDelayMs: 1500, + }); + + const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-test-sweep-")); + const wsDir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-test-ws-")); + + t.after(async () => { + await fake.close(); + fs.rmSync(dataDir, { recursive: true, force: true }); + fs.rmSync(wsDir, { recursive: true, force: true }); + }); + + const staleSid = "conv_stale_orphan"; + const staleState = { + session_id: staleSid, + project_id: "github.com_test_sweep", + app_id: "antigravity", + flushed: false, + observed_turn_index: 6, // Unsettled debt: observed (6) > settled (5) + settled_turn_index: 5, + }; + saveSessionState(dataDir, staleState); + + const env = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: dataDir, + EVEROS_AG_PROJECT_ID: "github.com_test_sweep", + EVEROS_AG_USER_ID: "tester", + }; + + const start = Date.now(); + const res = await runHookScript( + "hooks/scripts/session-start.js", + { + conversationId: "conv_current_active", + workspacePaths: [wsDir], + }, + env + ); + const elapsed = Date.now() - start; + + assert.equal(res.code, 0, `session-start stderr: ${res.stderr}`); + assert.ok( + elapsed < 3000, + `SessionStart hook must exit under 3000ms (took ${elapsed}ms) without blocking on flush` + ); + + // Wait for the background detached flush process to complete (flush takes 1500ms) + let flushed = false; + for (let i = 0; i < 30; i++) { + await new Promise((r) => setTimeout(r, 200)); + const updated = loadSessionState(dataDir, staleSid); + if (updated.flushed === true) { + flushed = true; + break; + } + } + + assert.ok(flushed, "Stale session should be marked flushed by the background detached process"); +}); + +test("flush: retry attempts are capped at 3 and abandoned thereafter (D4-01b)", async (t) => { + const fake = await startFakeEveros({ + flushStatus: 500, + }); + + const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-test-abandon-")); + const wsDir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-test-ws-")); + + t.after(async () => { + await fake.close(); + fs.rmSync(dataDir, { recursive: true, force: true }); + fs.rmSync(wsDir, { recursive: true, force: true }); + }); + + const sid = "conv_failing_session"; + const state = { + session_id: sid, + project_id: "github.com_test_fail", + app_id: "antigravity", + flushed: false, + flush_attempts: 2, // already failed twice + updated_at: Date.now() - 35 * 60 * 1000, + }; + saveSessionState(dataDir, state); + + const env = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: dataDir, + EVEROS_AG_PROJECT_ID: "github.com_test_fail", + EVEROS_AG_USER_ID: "tester", + }; + + // Run flush (3rd attempt) + const res = await runHookScript( + "hooks/scripts/flush.js", + { + conversationId: sid, + workspacePaths: [wsDir], + }, + env + ); + + assert.equal(res.code, 0); + const updated = loadSessionState(dataDir, sid); + assert.equal(updated.flush_attempts, 3, "flush_attempts should reach 3"); + assert.equal(updated.flush_abandoned, true, "Session should be marked flush_abandoned after 3 failed attempts"); +}); diff --git a/antigravity/tests/skills.test.js b/antigravity/tests/skills.test.js new file mode 100644 index 0000000..34920cb --- /dev/null +++ b/antigravity/tests/skills.test.js @@ -0,0 +1,232 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { spawn } from "node:child_process"; +import { startFakeEveros } from "./helpers/fake-everos.js"; +import { loadSessionState, saveSessionState } from "../hooks/scripts/lib/state.js"; + +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); + +function makeTempDir() { + return fs.mkdtempSync(path.join(os.tmpdir(), "everos-skills-test-")); +} + +function runCli(args = [], env = {}) { + return new Promise((resolve, reject) => { + const cliScript = path.join(root, "skills", "everos", "cli.js"); + const child = spawn(process.execPath, [cliScript, ...args], { + env: { + ...process.env, + ...env, + }, + stdio: ["pipe", "pipe", "pipe"], + }); + + let stdout = ""; + let stderr = ""; + child.stdout.on("data", (c) => (stdout += c)); + child.stderr.on("data", (c) => (stderr += c)); + child.on("close", (status) => resolve({ status, stdout, stderr })); + child.on("error", reject); + }); +} + +test("skills: cli status outputs well-formatted diagnostics", async (t) => { + const fake = await startFakeEveros(); + const testDataDir = makeTempDir(); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + }); + + const res = await runCli(["status"], { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_PROJECT_ID: "github.com_skills_status", + EVEROS_AG_USER_ID: "tester", + }); + + assert.equal(res.status, 0); + assert.match(res.stdout, /EverOS Memory Engine for Google Antigravity/); + assert.match(res.stdout, /🟢 Online \(HTTP 200\)/); + assert.match(res.stdout, /github\.com_skills_status/); + assert.match(res.stdout, /App Partition\s+antigravity/); +}); + +test("skills: cli flush executes 2PC seal and updates session state", async (t) => { + const fake = await startFakeEveros(); + const testDataDir = makeTempDir(); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + }); + + const conversationId = "conv_cli_flush_01"; + const res = await runCli(["flush", conversationId], { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_PROJECT_ID: "github.com_skills_flush", + }); + + assert.equal(res.status, 0); + assert.match(res.stdout, /2PC Flush Acknowledged/); + + // Verify fake received /flush with app_id: "antigravity" + const flushCalls = fake.only("/api/v2/memory/flush"); + assert.equal(flushCalls.length, 1); + assert.equal(flushCalls[0].body.app_id, "antigravity"); + assert.equal(flushCalls[0].body.session_id, conversationId); + assert.equal(flushCalls[0].body.project_id, "github.com_skills_flush"); + + // Verify state marked flushed: true + const state = loadSessionState(testDataDir, conversationId); + assert.equal(state.flushed, true); +}); + +test("skills: cli search supports clean Markdown and --raw JSON modes", async (t) => { + const mockSearch = () => ({ + episodes: [ + { + subject: "Search Skill", + summary: "CLI provides manual exploration", + atomic_facts: ["Raw flag toggles JSON vs Markdown"], + }, + ], + agent_cases: [ + { + task_intent: "Manual verification", + key_insight: "Engineers can verify memories directly via CLI", + }, + ], + profile: null, + }); + + const fake = await startFakeEveros({ searchFn: mockSearch }); + const testDataDir = makeTempDir(); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + }); + + const env = { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_PROJECT_ID: "github.com_skills_search", + }; + + // 1. Markdown mode + const resMd = await runCli(["search", "verification"], env); + assert.equal(resMd.status, 0); + assert.match(resMd.stdout, //); + assert.match(resMd.stdout, /【曾有范例】/); + assert.match(resMd.stdout, /Engineers can verify memories directly via CLI/); + + // 2. Raw JSON mode + const resRaw = await runCli(["search", "verification", "--raw"], env); + assert.equal(resRaw.status, 0); + const parsed = JSON.parse(resRaw.stdout.trim()); + assert.ok(Array.isArray(parsed.episodes)); + assert.equal(parsed.episodes[0].subject, "Search Skill"); +}); + +test("skills: SKILL.md definitions adhere to schema and referenced cli scripts exist", () => { + const skillsDir = path.join(root, "skills"); + + for (const skillName of ["everos", "everos-flush"]) { + const skillMdPath = path.join(skillsDir, skillName, "SKILL.md"); + assert.ok(fs.existsSync(skillMdPath), `${skillMdPath} must exist`); + + const content = fs.readFileSync(skillMdPath, "utf8"); + assert.match(content, /^---\r?\n/); + + // Strict frontmatter schema: name must match ^[a-z0-9-]+$ and be identical to folder name + const nameMatch = content.match(/^name:\s*([a-z0-9-]+)\r?$/m); + assert.ok(nameMatch, `name must exist and match ^[a-z0-9-]+$ in ${skillName}`); + assert.equal(nameMatch[1], skillName, `name '${nameMatch[1]}' must match folder name '${skillName}'`); + + const descMatch = content.match(/^description:\s*(.+)\r?$/m); + assert.ok(descMatch, `description must exist in ${skillName}`); + assert.ok(descMatch[1].trim().length > 10, `description must be substantive in ${skillName}`); + + // Verify referenced script exists + const scriptMatch = content.match(/node\s+"([^"]+)"/); + assert.ok(scriptMatch, `Command syntax found in ${skillName}`); + const scriptClean = scriptMatch[1].replace(/^\$\{[A-Z_]*PLUGIN_ROOT(?::-[^}]*)?\}\//, ""); + const scriptPath = path.join(root, scriptClean); + assert.ok(fs.existsSync(scriptPath), `Script target ${scriptMatch[1]} must exist`); + } +}); + +test("skills: cli flush auto-discovers most recent unflushed session when no argument provided", async (t) => { + const fake = await startFakeEveros(); + const testDataDir = makeTempDir(); + + t.after(() => { + fake.close(); + fs.rmSync(testDataDir, { recursive: true, force: true }); + }); + + const now = Date.now(); + const projectId = "github.com_auto_flush"; + + // 1. Older session for this project (unflushed) + const oldState = { + session_id: "conv_older_01", + project_id: projectId, + flushed: false, + updated_at: now - 30000, + created_at: now - 35000, + }; + saveSessionState(testDataDir, oldState); + + // 2. Newer session for this project (unflushed) + const recentState = { + session_id: "conv_recent_02", + project_id: projectId, + flushed: false, + updated_at: now - 1000, + created_at: now - 5000, + }; + saveSessionState(testDataDir, recentState); + + // 3. Different project session (unflushed) + const otherProjectState = { + session_id: "conv_other_03", + project_id: "other_project", + flushed: false, + updated_at: now - 500, + created_at: now - 1000, + }; + saveSessionState(testDataDir, otherProjectState); + + // Run cli flush without session_id argument + const res = await runCli(["flush"], { + EVEROS_AG_BASE_URL: fake.baseUrl, + EVEROS_AG_DATA_DIR: testDataDir, + EVEROS_AG_PROJECT_ID: projectId, + }); + + assert.equal(res.status, 0); + assert.match(res.stdout, /2PC Flush Acknowledged/); + assert.match(res.stdout, /conv_recent_02/); + + // Verify fake received flush precisely for the most recent session of this project + const flushCalls = fake.only("/api/v2/memory/flush"); + assert.equal(flushCalls.length, 1); + assert.equal(flushCalls[0].body.app_id, "antigravity"); + assert.equal(flushCalls[0].body.session_id, "conv_recent_02"); + assert.equal(flushCalls[0].body.project_id, projectId); + + // Verify recent session is marked flushed, while older remains intact + const loadedRecent = loadSessionState(testDataDir, "conv_recent_02"); + assert.equal(loadedRecent.flushed, true); + + const loadedOld = loadSessionState(testDataDir, "conv_older_01"); + assert.equal(loadedOld.flushed, false); +}); diff --git a/antigravity/tests/state-collision.test.js b/antigravity/tests/state-collision.test.js new file mode 100644 index 0000000..cbc8c03 --- /dev/null +++ b/antigravity/tests/state-collision.test.js @@ -0,0 +1,19 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import path from "node:path"; +import { getSessionFilePath } from "../hooks/scripts/lib/state.js"; + +test("state: getSessionFilePath eliminates session collisions via SHA-1 suffix (D7-02)", () => { + const dir = "C:/mock/data"; + const ids = ["conv:alpha", "conv/alpha", "conv\\alpha", "conv alpha"]; + const filePaths = ids.map((id) => getSessionFilePath(dir, id)); + + // Each distinct id must produce a distinct filename + const uniquePaths = new Set(filePaths); + assert.equal(uniquePaths.size, ids.length); + + for (const fp of filePaths) { + const filename = path.basename(fp); + assert.match(filename, /^session_conv_alpha_[0-9a-f]{8}\.json$/); + } +}); diff --git a/antigravity/tests/state-concurrency.test.js b/antigravity/tests/state-concurrency.test.js new file mode 100644 index 0000000..cc48844 --- /dev/null +++ b/antigravity/tests/state-concurrency.test.js @@ -0,0 +1,56 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { + loadSessionState, + saveSessionState, + markRecalled, + markSettled, + markObserved, +} from "../hooks/scripts/lib/state.js"; + +test("state: merge-on-write prevents lost updates during concurrent writes (D3-01)", () => { + const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "everos-state-concurrency-")); + const sid = "conv_concurrency_test"; + + try { + // Initial save: turn 1 + const initial = loadSessionState(dataDir, sid); + markSettled(initial, 1); + markObserved(initial, 1); + markRecalled(initial, "turn_1"); + saveSessionState(dataDir, initial); + + // Simulate concurrent reads: + // Process A (e.g. PreInvocation / recall) reads initial state snapshot + const snapshotA = loadSessionState(dataDir, sid); + + // Process B (e.g. Stop / capture) reads the same initial state snapshot + const snapshotB = loadSessionState(dataDir, sid); + + // Process A marks a new recalled turn + markRecalled(snapshotA, "turn_2"); + + // Process B marks turn 2 as observed and settled, with new byte offset + markObserved(snapshotB, 2); + markSettled(snapshotB, 2); + snapshotB.last_read_byte_offset = 1024; + + // Both save to disk (B saves first, then A saves with stale snapshot of turn_index) + saveSessionState(dataDir, snapshotB); + saveSessionState(dataDir, snapshotA); + + // Reload from disk: both changes MUST be present! + const finalState = loadSessionState(dataDir, sid); + + assert.equal(finalState.settled_turn_index, 2, "settled_turn_index from snapshot B must be preserved"); + assert.equal(finalState.observed_turn_index, 2, "observed_turn_index from snapshot B must be preserved"); + assert.equal(finalState.last_read_byte_offset, 1024, "last_read_byte_offset from snapshot B must be preserved"); + assert.ok(finalState.recalled_turn_ids.includes("turn_1"), "turn_1 must be present"); + assert.ok(finalState.recalled_turn_ids.includes("turn_2"), "turn_2 from snapshot A must NOT be overwritten by snapshot B"); + } finally { + fs.rmSync(dataDir, { recursive: true, force: true }); + } +}); diff --git a/antigravity/tests/state.test.js b/antigravity/tests/state.test.js new file mode 100644 index 0000000..885b2d2 --- /dev/null +++ b/antigravity/tests/state.test.js @@ -0,0 +1,265 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { + atomicWriteFileSync, + getSessionFilePath, + createDefaultSessionState, + loadSessionState, + saveSessionState, + markObserved, + markSettled, + markFlushed, + markRecalled, + markProfileInjected, + listStaleSessions, + cleanupExpiredSessions, +} from "../hooks/scripts/lib/state.js"; + +function makeTempDir() { + return fs.mkdtempSync(path.join(os.tmpdir(), "everos-state-test-")); +} + +test("state: createDefaultSessionState returns well-structured initial state", () => { + const state = createDefaultSessionState("sess_123", { + projectId: "proj_abc", + branch: "main", + userId: "alice", + }); + + assert.equal(state.session_id, "sess_123"); + assert.equal(state.project_id, "proj_abc"); + assert.equal(state.branch, "main"); + assert.equal(state.user_id, "alice"); + assert.equal(state.agent_id, "antigravity"); + assert.equal(state.has_injected_profile, false); + assert.deepEqual(state.recalled_turn_ids, []); + assert.equal(state.observed_turn_index, -1); + assert.equal(state.settled_turn_index, -1); + assert.equal(state.flushed, false); + assert.ok(typeof state.created_at === "number"); + assert.ok(typeof state.updated_at === "number"); +}); + +test("state: atomicWriteFileSync persists content and cleans up tmp files", () => { + const dir = makeTempDir(); + try { + const targetFile = path.join(dir, "sub", "target.txt"); + atomicWriteFileSync(targetFile, "hello atomic world"); + assert.equal(fs.readFileSync(targetFile, "utf8"), "hello atomic world"); + + // Ensure no orphan .tmp files left in the directory + const files = fs.readdirSync(path.join(dir, "sub")); + assert.deepEqual(files, ["target.txt"]); + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } +}); + +test("state: load and save session state round-trip", () => { + const dir = makeTempDir(); + try { + const initial = loadSessionState(dir, "sess_alpha", { + projectId: "proj_1", + branch: "feat", + }); + assert.equal(initial.session_id, "sess_alpha"); + assert.equal(initial.project_id, "proj_1"); + + markObserved(initial, 3); + markSettled(initial, 3); + markRecalled(initial, "turn_0"); + markProfileInjected(initial, true); + saveSessionState(dir, initial); + + const reloaded = loadSessionState(dir, "sess_alpha"); + assert.equal(reloaded.observed_turn_index, 3); + assert.equal(reloaded.settled_turn_index, 3); + assert.deepEqual(reloaded.recalled_turn_ids, ["turn_0"]); + assert.equal(reloaded.has_injected_profile, true); + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } +}); + +test("state: 2PC observation and settlement index advancement", () => { + const state = createDefaultSessionState("sess_2pc"); + assert.equal(state.observed_turn_index, -1); + assert.equal(state.settled_turn_index, -1); + + // Mark observed 5 + markObserved(state, 5); + assert.equal(state.observed_turn_index, 5); + assert.equal(state.settled_turn_index, -1); // Unsettled! + + // Smaller index should not regress + markObserved(state, 3); + assert.equal(state.observed_turn_index, 5); + + // Settlement only advances on explicit call + markSettled(state, 5); + assert.equal(state.settled_turn_index, 5); + + // markFlushed + assert.equal(state.flushed, false); + markFlushed(state, true); + assert.equal(state.flushed, true); +}); + +test("state: markRecalled deduplicates turn IDs", () => { + const state = createDefaultSessionState("sess_rec"); + markRecalled(state, "turn_0"); + markRecalled(state, "turn_1"); + markRecalled(state, "turn_0"); + assert.deepEqual(state.recalled_turn_ids, ["turn_0", "turn_1"]); +}); + +test("state: listStaleSessions correctly filters unflushed and idle sessions", () => { + const dir = makeTempDir(); + try { + const now = Date.now(); + const staleThreshold = 1000; // 1 second for test + + // 1. Stale unflushed session + const staleState = createDefaultSessionState("sess_stale", { projectId: "proj_stale" }); + staleState.updated_at = now - 5000; + saveSessionState(dir, staleState); + // Overwrite updated_at because saveSessionState re-stamps it + staleState.updated_at = now - 5000; + const staleFile = getSessionFilePath(dir, "sess_stale"); + fs.writeFileSync(staleFile, JSON.stringify(staleState)); + + // 2. Active recent unflushed session + const activeState = createDefaultSessionState("sess_active", { projectId: "proj_active" }); + saveSessionState(dir, activeState); + + // 3. Old but already flushed session + const flushedState = createDefaultSessionState("sess_flushed", { projectId: "proj_flushed" }); + flushedState.flushed = true; + flushedState.updated_at = now - 5000; + const flushedFile = getSessionFilePath(dir, "sess_flushed"); + fs.writeFileSync(flushedFile, JSON.stringify(flushedState)); + + const staleList = listStaleSessions(dir, staleThreshold); + assert.equal(staleList.length, 1); + assert.equal(staleList[0].session_id, "sess_stale"); + assert.equal(staleList[0].project_id, "proj_stale"); + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } +}); + +test("state: markRecalled caps at STATE_MAX_PROMPT_IDS with sliding window", () => { + const state = createDefaultSessionState("sess_overflow"); + for (let i = 0; i < 250; i++) { + markRecalled(state, `turn_${i}`); + } + assert.equal(state.recalled_turn_ids.length, 200); + assert.equal(state.recalled_turn_ids[0], "turn_50"); + assert.equal(state.recalled_turn_ids[199], "turn_249"); +}); + +test("state: cleanupExpiredSessions removes flushed files older than TTL while preserving unflushed drafts", () => { + const dir = makeTempDir(); + try { + const freshFile = path.join(dir, "session_fresh.json"); + const oldFlushedFile = path.join(dir, "session_old_flushed.json"); + const oldUnflushedFile = path.join(dir, "session_old_unflushed.json"); + + fs.writeFileSync(freshFile, JSON.stringify({ session_id: "fresh", flushed: true })); + fs.writeFileSync(oldFlushedFile, JSON.stringify({ session_id: "old_flushed", flushed: true })); + fs.writeFileSync(oldUnflushedFile, JSON.stringify({ session_id: "old_unflushed", flushed: false })); + + // Manually set mtimes to 35 days ago + const thirtyFiveDaysAgo = new Date(Date.now() - 35 * 24 * 60 * 60 * 1000); + fs.utimesSync(oldFlushedFile, thirtyFiveDaysAgo, thirtyFiveDaysAgo); + fs.utimesSync(oldUnflushedFile, thirtyFiveDaysAgo, thirtyFiveDaysAgo); + + const removed = cleanupExpiredSessions(dir, 30); + assert.equal(removed, 1); + assert.ok(fs.existsSync(freshFile), "fresh file must exist"); + assert.ok(fs.existsSync(oldUnflushedFile), "unflushed file must be preserved even if older than 30 days"); + assert.equal(fs.existsSync(oldFlushedFile), false, "old flushed file must be cleaned up"); + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } +}); + +test("state: atomicWriteFileSync retries and recovers when encountering transient lock (EBUSY/EACCES)", () => { + const dir = makeTempDir(); + try { + const targetFile = path.join(dir, "locked_target.txt"); + const originalRenameSync = fs.renameSync; + let attempts = 0; + + // Simulate transient lock: first 2 attempts throw EBUSY, 3rd succeeds + fs.renameSync = (from, to) => { + attempts++; + if (attempts <= 2) { + const err = new Error("Resource temporarily locked by antivirus/indexer"); + err.code = "EBUSY"; + throw err; + } + return originalRenameSync(from, to); + }; + + try { + atomicWriteFileSync(targetFile, "recovered through backoff retry", 3, 5); + assert.equal(fs.readFileSync(targetFile, "utf8"), "recovered through backoff retry"); + assert.equal(attempts, 3); + } finally { + fs.renameSync = originalRenameSync; + } + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } +}); + +test("state: loadSessionState fail-opens gracefully on malformed JSON", () => { + const dir = makeTempDir(); + try { + const corruptFile = getSessionFilePath(dir, "sess_corrupt"); + fs.writeFileSync(corruptFile, "{ THIS IS CORRUPTED JSON", "utf8"); + + const fallback = loadSessionState(dir, "sess_corrupt", { projectId: "proj_fallback" }); + assert.equal(fallback.session_id, "sess_corrupt"); + assert.equal(fallback.project_id, "proj_fallback"); + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } +}); + +test("state: saveSessionState maintains sessions_index.json and prunes on flushed", () => { + const dir = makeTempDir(); + try { + const indexPath = path.join(dir, "sessions_index.json"); + + // 1. Save an active unflushed session + const activeState = createDefaultSessionState("sess_active_1", { projectId: "proj_1" }); + saveSessionState(dir, activeState); + + assert.ok(fs.existsSync(indexPath), "sessions_index.json should be created"); + let index = JSON.parse(fs.readFileSync(indexPath, "utf8")); + assert.ok(index.sessions["sess_active_1"], "sess_active_1 should be registered"); + assert.equal(index.sessions["sess_active_1"].flushed, false); + + // 2. Save a second session + const activeState2 = createDefaultSessionState("sess_active_2", { projectId: "proj_1" }); + saveSessionState(dir, activeState2); + + index = JSON.parse(fs.readFileSync(indexPath, "utf8")); + assert.equal(Object.keys(index.sessions).length, 2); + + // 3. Mark the first session as flushed and save: should be pruned from index + activeState.flushed = true; + saveSessionState(dir, activeState); + + index = JSON.parse(fs.readFileSync(indexPath, "utf8")); + assert.equal(index.sessions["sess_active_1"], undefined, "flushed session must be pruned from index"); + assert.ok(index.sessions["sess_active_2"], "unflushed session remains in index"); + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } +}); diff --git a/antigravity/tests/transcript.test.js b/antigravity/tests/transcript.test.js new file mode 100644 index 0000000..d39c3e5 --- /dev/null +++ b/antigravity/tests/transcript.test.js @@ -0,0 +1,316 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { + parseAndSortTranscript, + sliceTurn, + truncateMiddle, + extractUserPrompt, + toEverosMessages, + readTranscriptIncremental, +} from "../hooks/scripts/lib/transcript.js"; +import { validateAdd } from "./helpers/contract.js"; + +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); + +test("parseAndSortTranscript handles out-of-order steps and overwrites by step_index", () => { + const lines = [ + JSON.stringify({ step_index: 2, content: "step 2" }), + JSON.stringify({ step_index: 0, content: "step 0 draft" }), + "{ invalid json line", + JSON.stringify({ step_index: 0, content: "step 0 final" }), // overwrite + JSON.stringify({ step_index: 1, content: "step 1" }), + ].join("\n"); + + const parsed = parseAndSortTranscript(lines); + assert.equal(parsed.length, 3); + assert.equal(parsed[0].step_index, 0); + assert.equal(parsed[0].content, "step 0 final"); + assert.equal(parsed[1].step_index, 1); + assert.equal(parsed[2].step_index, 2); +}); + +test("sliceTurn correctly extracts turns by turnId and isolates turn boundaries", () => { + const entries = [ + { step_index: 0, type: "USER_INPUT", source: "USER_EXPLICIT" }, + { step_index: 1, type: "PLANNER_RESPONSE" }, + { step_index: 2, type: "GENERIC" }, + { step_index: 3, type: "USER_INPUT", source: "USER_EXPLICIT" }, + { step_index: 4, type: "PLANNER_RESPONSE" }, + ]; + + const turn0 = sliceTurn(entries, "turn_0"); + assert.equal(turn0.length, 3); + assert.equal(turn0[0].step_index, 0); + assert.equal(turn0[2].step_index, 2); + + const turn3 = sliceTurn(entries, "turn_3"); + assert.equal(turn3.length, 2); + assert.equal(turn3[0].step_index, 3); + assert.equal(turn3[1].step_index, 4); +}); + +test("truncateMiddle preserves head and tail and inserts standard trimming notice", () => { + const shortText = "Short text"; + assert.equal(truncateMiddle(shortText, 50), shortText); + + const longText = "HEAD_START_" + "x".repeat(200) + "_TAIL_END"; + const truncated = truncateMiddle(longText, 30); + assert.match(truncated, /^HEAD_START_/); + assert.match(truncated, /_TAIL_END$/); + assert.match(truncated, /trimmed \d+ chars by the EverOS Antigravity plugin/); +}); + +test("extractUserPrompt unwraps tags and cleans host noise tags", () => { + const wrapped = "\nFix this bug\n\n\ntime=now\n"; + assert.equal(extractUserPrompt(wrapped), "Fix this bug"); + + const withReminder = "Execute commandHost internal"; + assert.equal(extractUserPrompt(withReminder), "Execute command"); + + const bare = "Plain prompt without tags"; + assert.equal(extractUserPrompt(bare), bare); +}); + +test("toEverosMessages strips thinking, pairs tools, reduces subagents, and applies Dummy Tool Synth", () => { + const fixturePath = path.join(root, "tests", "fixtures", "transcript-antigravity.jsonl"); + const rawText = fs.readFileSync(fixturePath, "utf8"); + const allEntries = parseAndSortTranscript(rawText); + + // 1. Test Turn 0 (normal single tool call) + const turn0Entries = sliceTurn(allEntries, "turn_0"); + const turn0Messages = toEverosMessages(turn0Entries, { userId: "developer_alice", agentId: "antigravity" }); + + assert.equal(turn0Messages.length, 4); + assert.equal(turn0Messages[0].role, "user"); + assert.equal(turn0Messages[0].content, "Initialize EverOS Antigravity Plugin"); + assert.equal(turn0Messages[1].role, "assistant"); + assert.equal(turn0Messages[1].tool_calls.length, 1); + assert.equal(turn0Messages[1].tool_calls[0].id, "call_1_0"); + assert.equal("thinking" in turn0Messages[1], false); // thinking completely stripped! + assert.equal(turn0Messages[2].role, "tool"); + assert.equal(turn0Messages[2].tool_call_id, "call_1_0"); + assert.equal(turn0Messages[3].role, "assistant"); + + // Validate EverOS contract compliance for Turn 0 + const contractErrors0 = validateAdd({ + session_id: "sess_0", + app_id: "antigravity", + messages: turn0Messages, + }); + assert.deepEqual(contractErrors0, []); + + // 2. Test Turn 4 (invoke_subagent dimensionality reduction) + const turn4Entries = sliceTurn(allEntries, "turn_4"); + const turn4Messages = toEverosMessages(turn4Entries, { userId: null, agentId: "antigravity" }); + + assert.equal(turn4Messages[0].sender_id, "user"); // null userId falls back to "user" + const subagentCall = turn4Messages[1].tool_calls[0]; + assert.equal(subagentCall.function.name, "invoke_subagent"); + const parsedArgs = JSON.parse(subagentCall.function.arguments); + assert.deepEqual(parsedArgs, { + subagent_role: "CodeAuditor", + prompt: "Perform deep architectural audit", + }); + + // 3. Test Turn 7 (Error tool status + Dummy Tool Synth on interruption) + const turn7Entries = sliceTurn(allEntries, "turn_7"); + const turn7Messages = toEverosMessages(turn7Entries, { userId: "tester", agentId: "antigravity" }); + + // Anti-recursive memory stripping on user prompt: + assert.equal(turn7Messages[0].content, "Run tool and interrupt"); + assert.doesNotMatch(turn7Messages[0].content, /【既定规约】/); + + // Tool 1: executed with error + assert.equal(turn7Messages[2].role, "tool"); + assert.equal(turn7Messages[2].tool_call_id, "call_8_0"); + assert.match(turn7Messages[2].content, /^\[tool error\] Command crashed with code 1/); + + // Tool 2: interrupted (Dummy Tool Synth must synthesize orphan call response!) + assert.equal(turn7Messages[3].role, "tool"); + assert.equal(turn7Messages[3].tool_call_id, "call_8_1"); + assert.equal(turn7Messages[3].content, "[tool interrupted or canceled by user]"); + + // Validate EverOS contract on synthesized messages + const contractErrors7 = validateAdd({ + session_id: "sess_7", + app_id: "antigravity", + messages: turn7Messages, + }); + assert.deepEqual(contractErrors7, []); +}); + +test("toEverosMessages closes unfulfilled tool calls BEFORE next assistant message in multi-invocation turns", () => { + // Turn with 2 invocations: + // Invocation 1: calls A (call_1_0) and B (call_1_1). + // A finishes, but B is canceled / missing GENERIC. + // Invocation 2: calls C (call_3_0). C finishes. + const turnEntries = [ + { step_index: 0, type: "USER_INPUT", source: "USER_EXPLICIT", content: "Multi-invocation test" }, + { + step_index: 1, + type: "PLANNER_RESPONSE", + content: "Calling A and B", + tool_calls: [ + { name: "toolA", args: {} }, + { name: "toolB", args: {} }, + ], + }, + { step_index: 2, type: "GENERIC", status: "DONE", content: "Result of tool A" }, + // Notice: tool B has no GENERIC here! + { + step_index: 3, + type: "PLANNER_RESPONSE", + content: "Calling C after B failed", + tool_calls: [{ name: "toolC", args: {} }], + }, + { step_index: 4, type: "GENERIC", status: "DONE", content: "Result of tool C" }, + { step_index: 5, type: "PLANNER_RESPONSE", content: "All done" }, + ]; + + const messages = toEverosMessages(turnEntries, { userId: "tester", agentId: "antigravity" }); + + // Expected sequence preserving strict OpenAI topology: + // 0: user + // 1: assistant (calls A, B) + // 2: tool (call_1_0, Result of tool A) + // 3: tool (call_1_1, [tool interrupted or canceled by user] -> SYNTHESIZED BEFORE NEXT ASSISTANT!) + // 4: assistant (calls C) + // 5: tool (call_3_0, Result of tool C) + // 6: assistant (All done) + assert.equal(messages.length, 7); + assert.equal(messages[0].role, "user"); + assert.equal(messages[1].role, "assistant"); + assert.equal(messages[2].role, "tool"); + assert.equal(messages[2].tool_call_id, "call_1_0"); + assert.equal(messages[2].content, "Result of tool A"); + + assert.equal(messages[3].role, "tool"); + assert.equal(messages[3].tool_call_id, "call_1_1"); + assert.equal(messages[3].content, "[tool interrupted or canceled by user]"); + + assert.equal(messages[4].role, "assistant"); + assert.equal(messages[5].role, "tool"); + assert.equal(messages[5].tool_call_id, "call_3_0"); + assert.equal(messages[5].content, "Result of tool C"); + + assert.equal(messages[6].role, "assistant"); + + // Validate EverOS contract on multi-invocation topology + const errors = validateAdd({ + session_id: "sess_multi", + app_id: "antigravity", + messages, + }); + assert.deepEqual(errors, []); +}); + +test("toEverosMessages handles lowercase subagent argument names", () => { + const turnEntries = [ + { step_index: 0, type: "USER_INPUT", source: "USER_EXPLICIT", content: "Delegate task" }, + { + step_index: 1, + type: "PLANNER_RESPONSE", + content: "Delegating", + tool_calls: [ + { + name: "invoke_subagent", + args: { role: "CodeReviewer", prompt: "Review PR #123" }, // lowercase keys + }, + ], + }, + { step_index: 2, type: "GENERIC", status: "DONE", content: "Review passed." }, + ]; + + const messages = toEverosMessages(turnEntries, { userId: "tester", agentId: "antigravity" }); + assert.equal(messages[1].role, "assistant"); + const call = messages[1].tool_calls[0]; + const parsed = JSON.parse(call.function.arguments); + assert.deepEqual(parsed, { + subagent_role: "CodeReviewer", + prompt: "Review PR #123", + }); +}); + +test("toEverosMessages preserves subagent conversationId and TypeName metadata", () => { + const turnEntries = [ + { step_index: 0, type: "USER_INPUT", source: "USER_EXPLICIT", content: "Delegate with metadata" }, + { + step_index: 1, + type: "PLANNER_RESPONSE", + content: "Delegating with subagent ID", + tool_calls: [ + { + name: "invoke_subagent", + args: { + role: "SecurityAuditor", + prompt: "Scan repo", + conversationId: "subagent_conv_888", + TypeName: "research", + }, + }, + ], + }, + { step_index: 2, type: "GENERIC", status: "DONE", content: "Audit completed" }, + ]; + + const messages = toEverosMessages(turnEntries, { userId: "tester", agentId: "antigravity" }); + assert.equal(messages[1].role, "assistant"); + const call = messages[1].tool_calls[0]; + const parsed = JSON.parse(call.function.arguments); + assert.deepEqual(parsed, { + subagent_role: "SecurityAuditor", + prompt: "Scan repo", + subagent_id: "subagent_conv_888", + type_name: "research", + }); +}); + +test("readTranscriptIncremental reads new slices via byte offset cursor with atomic line boundary defense", (t) => { + const os = process.platform === "win32" ? "win32" : "posix"; + const tmpFile = path.join(root, `temp_transcript_${Date.now()}_${process.pid}.jsonl`); + + t.after(() => { + try { + if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile); + } catch {} + }); + + // 1. Initial write: two complete lines + const line1 = JSON.stringify({ step_index: 1, content: "line 1" }) + "\n"; + const line2 = JSON.stringify({ step_index: 2, content: "line 2" }) + "\n"; + fs.writeFileSync(tmpFile, line1 + line2, "utf8"); + + const firstRead = readTranscriptIncremental(tmpFile, 0); + assert.equal(firstRead.entries.length, 2); + assert.equal(firstRead.entries[0].step_index, 1); + assert.equal(firstRead.entries[1].step_index, 2); + assert.ok(firstRead.nextOffset > 0); + + // 2. Append: one half-written line (no trailing newline) + const line3Half = JSON.stringify({ step_index: 3, content: "line 3 incomplete" }); + fs.appendFileSync(tmpFile, line3Half, "utf8"); + + // Read with firstRead.nextOffset: should NOT consume the half-written line yet + const secondRead = readTranscriptIncremental(tmpFile, firstRead.nextOffset); + assert.equal(secondRead.entries.length, 0); + assert.equal(secondRead.nextOffset, firstRead.nextOffset); + + // 3. Complete the line with newline and add line 4 + fs.appendFileSync(tmpFile, "\n" + JSON.stringify({ step_index: 4, content: "line 4" }) + "\n", "utf8"); + + // Read again: now line 3 and line 4 should be consumed! + const thirdRead = readTranscriptIncremental(tmpFile, firstRead.nextOffset); + assert.equal(thirdRead.entries.length, 2); + assert.equal(thirdRead.entries[0].step_index, 3); + assert.equal(thirdRead.entries[1].step_index, 4); + assert.ok(thirdRead.nextOffset > firstRead.nextOffset); + + // 4. Test file truncation (rewind to 0) + fs.writeFileSync(tmpFile, JSON.stringify({ step_index: 99, content: "reset" }) + "\n", "utf8"); + const rewindRead = readTranscriptIncremental(tmpFile, thirdRead.nextOffset); + assert.equal(rewindRead.entries.length, 1); + assert.equal(rewindRead.entries[0].step_index, 99); +});