agen-vektor 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VECTOR contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+# VECTOR
+
+**AI Coding Agent for Linux & Termux** — a terminal-native coding agent that inspects your project, plans, edits code, runs commands and tests, and iterates until the task is done.
+
+```
+╭──────────────────────────────────────────────────────────────╮
+│ VECTOR ● Ready                              openrouter · deepseek/deepseek-chat │
+│ Project: ~/my-project                         Mode: ask        │
+├──────────────────────────────────────────────────────────────┤
+│                                                              │
+│ YOU                                                          │
+│ > Perbaiki error authentication pada project ini            │
+│                                                              │
+│ VECTOR                                                       │
+│ ● Inspecting project...                                      │
+│ ● Searching authentication files                             │
+│                                                              │
+│ TOOL                                                         │
+│ $ npm test                                                   │
+│                                                              │
+│ ✓ Tests passed                                               │
+│                                                              │
+├──────────────────────────────────────────────────────────────┤
+│ > _                                                          │
+├──────────────────────────────────────────────────────────────┤
+│ ENTER Send │ TAB Commands │ CTRL+C Stop │ ? Help             │
+╰──────────────────────────────────────────────────────────────╯
+```
+
+## Features
+
+- **Interactive TUI** — chat, agent status, tool execution, diff viewer, input. Keyboard driven, mouse-aware, works on 80×24 terminals and survives resize.
+- **Agent loop** — plan → inspect → tool call → result → review → fix → retry until done (with an iteration cap).
+- **Tools** — read/write/edit files, list directories, search files, run shell commands, git, fetch web pages.
+- **Security first** — command policy classifies every shell command (SAFE / ASK / DANGEROUS / BLOCKED), permission prompts before risky actions, `--yolo` mode with warnings, and API keys are never printed or persisted to sessions.
+- **Multi-provider** — OpenAI, Anthropic, Gemini, OpenRouter, Ollama, and any OpenAI-compatible custom endpoint.
+- **Sessions & memory** — conversations persist to `~/.vector/sessions/`; `/continue` resumes them.
+- **Context management** — only relevant context is sent to the model, with compaction (`/compact`).
+
+## Installation
+
+Requirements: **Node.js 20+** and **npm** (Termux: `pkg install nodejs`).
+
+### From source
+
+```bash
+git clone https://github.com/clickmamaheti-prog/vector-agent.git
+cd vector-agent
+npm install
+npm run build
+npm link          # makes `vector` available on PATH
+```
+
+Then:
+
+```bash
+vector
+```
+
+### From npm (once published)
+
+```bash
+npm install -g vector-cli
+vector
+```
+
+### Termux (Android)
+
+```bash
+pkg update && pkg upgrade
+pkg install nodejs git
+npm install -g vector-cli
+vector
+```
+
+> VECTOR has **zero runtime dependencies** and does not assume `systemd`, `sudo`, `apt`, or a desktop GUI — everything runs in a plain terminal.
+
+## Quick start
+
+```bash
+cd my-project
+vector "Perbaiki error authentication pada project ini"
+```
+
+or start the TUI and type your task:
+
+```bash
+vector
+```
+
+## Command line
+
+| Command | Description |
+|---|---|
+| `vector` | Start the interactive terminal UI |
+| `vector "task"` | Start TUI and run the task immediately |
+| `vector --model MODEL` | Set the model |
+| `vector --provider P` | Set provider: `openai`, `anthropic`, `gemini`, `openrouter`, `ollama`, `custom` |
+| `vector --continue` | Continue the most recent session |
+| `vector --session NAME` | Use/resume session `NAME` |
+| `vector --plan` | Show a plan before executing |
+| `vector --yolo` | Skip permission prompts for ask-level actions (with warning) |
+| `vector --version` / `--help` | Version / help |
+
+## TUI commands
+
+Type `/` inside VECTOR:
+
+| Command | Description |
+|---|---|
+| `/model` | Select a model |
+| `/provider` | Select a provider |
+| `/session` | Browse saved sessions |
+| `/settings` | Show configuration |
+| `/status` | Show agent status |
+| `/clear` | Clear the conversation |
+| `/continue` | Continue the current/last session |
+| `/diff` | Show diff viewer |
+| `/git` | Run `git status` |
+| `/compact` | Compact context (truncate old messages) |
+| `/yolo` | Toggle permission mode |
+| `/exit` | Quit |
+
+## Provider configuration
+
+Set an API key via environment variable:
+
+```bash
+export OPENAI_API_KEY=sk-...
+export ANTHROPIC_API_KEY=sk-ant-...
+export GEMINI_API_KEY=...
+export OPENROUTER_API_KEY=...
+```
+
+Or inside VECTOR: `/provider` → pick provider → paste key (stored masked in `~/.vector/credentials.json`, permissions `0600`).
+
+Generic variables: `VECTOR_API_KEY`, `VECTOR_API_URL`, `VECTOR_MODEL`, `VECTOR_PROVIDER`, `VECTOR_HOME`.
+
+### Custom API (OpenAI-compatible)
+
+```bash
+export VECTOR_API_URL=https://example.com/v1
+export VECTOR_API_KEY=your-key
+vector --provider custom --model deepseek-v3
+```
+
+The provider speaks `/v1/chat/completions` (and `/models`). Anthropic and Gemini protocols for custom endpoints are documented as adapters; OpenAI-compatible endpoints are fully supported.
+
+## Security model
+
+Every shell command is classified:
+
+- **SAFE** — read-only commands run without prompting (`ls`, `cat`, `git status`, …)
+- **ASK** — prompts for confirmation (`npm install`, `npm test`, `git commit`, …)
+- **DANGEROUS** — prompts with a warning (`rm -rf`, `chmod`, `git push`, …)
+- **BLOCKED** — refused outright (`rm -rf /`, `mkfs`, `shutdown`, forced pushes, …)
+
+`--yolo` auto-approves ASK-level actions but still prompts for DANGEROUS and refuses BLOCKED ones. API keys are never printed to the terminal, logs, diffs, or session history.
+
+## Architecture
+
+```
+src/
+├── cli/          argument parsing, keyboard, bootstrap
+├── tui/          terminal UI: chat, input, statusbar, diff, components
+├── agent/        agent loop, planner, context, memory, prompts, session
+├── providers/    AIProvider interface + OpenAI/Anthropic/Gemini/OpenRouter/Ollama/Custom
+├── tools/        tool registry + filesystem/shell/search/git/web
+├── security/     command policy + permission manager
+├── config/       config, credentials, model catalog
+└── utils/        terminal (ANSI), logger, paths
+```
+
+Providers and tools are pluggable: adding one never touches the agent core.
+
+## Development
+
+```bash
+npm run dev       # run from source with tsx
+npm run build     # compile TypeScript
+npm test          # run unit tests (node:test)
+npm run typecheck # tsc --noEmit
+```
+
+## Testing
+
+Unit tests cover providers, the agent loop, the tool registry, filesystem tools, the command policy, config, credentials, sessions, context manager, keyboard, diff, and CLI helpers.
+
+```bash
+npm test
+npm run build
+```
+
+## Troubleshooting
+
+- **"No API key configured"** — set the relevant `*_API_KEY` env var or run `/provider` in the TUI.
+- **"401" / auth failed** — check the key, or for OpenRouter use `OPENROUTER_API_KEY`.
+- **Nothing happens on `vector` in Termux** — make sure your terminal is a TTY and TERM is set (e.g. `export TERM=xterm-256color`).
+- **Runs out of iterations** — raise `maxIterations` in `~/.vector/config.json` or refine the request.
+- **Rate limited (429)** — VECTOR retries automatically with backoff; wait and retry.
+
+## Roadmap
+
+- Web search tool (provider-backed) behind the `web` abstraction
+- Interactive diff approval before edits in safe mode
+- Persistent permission rules per project
+- `npm publish` as `vector-cli`
+- Windows support (WSL-focused)
+
+## License
+
+[MIT](LICENSE)

package/dist/agent/agent.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const factory_1 = require("../providers/factory");
+const registry_1 = require("../tools/registry");
+const filesystem_1 = require("../tools/filesystem");
+const search_1 = require("../tools/search");
+const shell_1 = require("../tools/shell");
+const git_1 = require("../tools/git");
+const web_1 = require("../tools/web");
+const permissions_1 = require("../security/permissions");
+const config_1 = require("../config/config");
+const loop_1 = require("./loop");
+class Agent {
+    config;
+    provider;
+    tools;
+    permissions;
+    cwd;
+    constructor(opts) {
+        this.config = (0, config_1.effectiveConfig)(opts.config);
+        this.cwd = opts.cwd || process.cwd();
+        this.provider = (0, factory_1.createProvider)(this.config);
+        this.permissions = new permissions_1.PermissionManager({
+            mode: this.config.permissionMode,
+            ask: opts.askPermission,
+        });
+        this.tools = new registry_1.ToolRegistry();
+        this.tools.registerMany([
+            ...(0, filesystem_1.createFilesystemTools)(),
+            ...(0, search_1.createSearchTools)(),
+            (0, shell_1.createShellTool)(),
+            (0, git_1.createGitTool)(),
+            (0, web_1.createWebTool)(),
+        ]);
+    }
+    async run(request, signal) {
+        return (0, loop_1.runAgentLoop)(request, {
+            provider: this.provider,
+            tools: this.tools,
+            permissions: this.permissions,
+            config: this.config,
+            cwd: this.cwd,
+            signal,
+        }, this.callbacks);
+    }
+    /**
+     * Run with optional prior session messages (non-interactive continue).
+     * If sessionMessages is provided, the task is appended after the history.
+     */
+    async runWithContext(request, session, cb = {}) {
+        this.setCallbacks(cb);
+        if (!session)
+            return this.run(request);
+        // Replay history into the loop by prefixing the task request.
+        const context = session.messages
+            .filter((m) => m.role === 'user' || m.role === 'assistant')
+            .slice(-30)
+            .map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content.slice(0, 2000)}`)
+            .join('\n\n');
+        return this.run(`[Previous conversation summary]\n${context}\n\n---\n\nTASK:\n${request}`);
+    }
+    /** Rebuild the provider (e.g. after changing provider id). */
+    rebuildProvider() {
+        this.provider = (0, factory_1.createProvider)(this.config);
+    }
+    callbacks = {};
+    setCallbacks(cb) {
+        this.callbacks = {
+            onStatus: cb.onStatus,
+            onDelta: cb.onDelta,
+            onToolCall: cb.onToolCall,
+            onToolResult: cb.onToolResult,
+            onIteration: cb.onIteration,
+            onFinal: cb.onFinal,
+            onError: cb.onError,
+            onActivity: cb.onActivity,
+        };
+        // Permissions callback must be live-updated as well
+        this.permissions.setMode(this.config.permissionMode);
+    }
+    setPermissionAsk(ask) {
+        this.permissions = new permissions_1.PermissionManager({ mode: this.config.permissionMode, ask });
+    }
+    setMode(mode) {
+        this.config.permissionMode = mode;
+        this.permissions.setMode(mode);
+    }
+}
+exports.Agent = Agent;

package/dist/agent/context.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProject = detectProject;
+exports.buildProjectContext = buildProjectContext;
+exports.listRootEntries = listRootEntries;
+/**
+ * Context Manager — builds a compact, relevant project context.
+ *
+ * Strategy: never send the whole project. Detect the manifest/project type,
+ * read small key files, and keep a bounded message history.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const MANIFESTS = [
+    { file: 'package.json', type: 'Node.js', maxBytes: 8000 },
+    { file: 'tsconfig.json', type: 'TypeScript', maxBytes: 8000 },
+    { file: 'requirements.txt', type: 'Python', maxBytes: 8000 },
+    { file: 'pyproject.toml', type: 'Python', maxBytes: 8000 },
+    { file: 'Cargo.toml', type: 'Rust', maxBytes: 8000 },
+    { file: 'go.mod', type: 'Go', maxBytes: 8000 },
+    { file: 'composer.json', type: 'PHP', maxBytes: 8000 },
+    { file: 'Makefile', type: 'Make', maxBytes: 8000 },
+    { file: 'pom.xml', type: 'Java', maxBytes: 8000 },
+    { file: 'Gemfile', type: 'Ruby', maxBytes: 8000 },
+    { file: 'mix.exs', type: 'Elixir', maxBytes: 8000 },
+];
+function detectProject(root) {
+    const info = { root, type: null, manifest: null, hasGit: false };
+    info.hasGit = fs.existsSync(path.join(root, '.git'));
+    for (const m of MANIFESTS) {
+        const p = path.join(root, m.file);
+        try {
+            if (fs.existsSync(p)) {
+                const stat = fs.statSync(p);
+                if (stat.size > 0 && stat.size <= m.maxBytes) {
+                    info.manifest = { name: m.file, content: fs.readFileSync(p, 'utf8') };
+                    info.type = m.type;
+                    break;
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return info;
+}
+function buildProjectContext(root) {
+    const info = detectProject(root);
+    const lines = [];
+    lines.push(`Project root: ${root}`);
+    lines.push(`Project type: ${info.type || 'unknown'}`);
+    lines.push(`Git repository: ${info.hasGit ? 'yes' : 'no'}`);
+    if (info.manifest) {
+        lines.push(`\n--- ${info.manifest.name} ---\n${info.manifest.content}`);
+    }
+    return lines.join('\n');
+}
+function listRootEntries(root, limit = 25) {
+    try {
+        const entries = fs.readdirSync(root, { withFileTypes: true });
+        const IGNORE = new Set(['.git', 'node_modules', 'dist', 'build', '.cache', '.env', '.next', 'vendor']);
+        const lines = entries
+            .filter((e) => !IGNORE.has(e.name) && !e.name.startsWith('.'))
+            .sort((a, b) => (a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? -1 : 1))
+            .slice(0, limit)
+            .map((e) => (e.isDirectory() ? `${e.name}/` : e.name));
+        return lines.length > 0 ? `Top-level entries:\n${lines.join('\n')}` : '(empty directory)';
+    }
+    catch {
+        return '(cannot read directory)';
+    }
+}

package/dist/agent/loop.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentLoop = runAgentLoop;
+exports.compactMessages = compactMessages;
+exports.estimateContextSize = estimateContextSize;
+/**
+ * Agent loop — the core execution engine.
+ *
+ * USER PROMPT → context → LLM → tool call? → execute → result → LLM → ... → final
+ *
+ * The loop keeps going until the model produces a final answer (no tool
+ * calls) or the iteration limit is reached. Each tool result is fed back
+ * to the model so it can react, fix errors, and retry.
+ */
+const provider_1 = require("../providers/provider");
+const context_1 = require("./context");
+const prompts_1 = require("./prompts");
+async function runAgentLoop(userRequest, opts, callbacks = {}) {
+    const { provider, tools, permissions, config, cwd, signal } = opts;
+    const maxIterations = config.maxIterations;
+    // Seed conversation with system + project context + task
+    const messages = [
+        { role: 'system', content: prompts_1.SYSTEM_PROMPT },
+        {
+            role: 'user',
+            content: `${(0, context_1.buildProjectContext)(cwd)}\n\n${(0, context_1.listRootEntries)(cwd)}\n\n---\n\nTASK:\n${userRequest}`,
+        },
+    ];
+    let iterations = 0;
+    let toolCalls = 0;
+    let aborted = false;
+    let stopped = false;
+    let finalContent = '';
+    const checkAbort = () => {
+        if (signal?.aborted) {
+            aborted = true;
+            throw new Error('aborted');
+        }
+    };
+    while (iterations < maxIterations) {
+        try {
+            checkAbort();
+        }
+        catch {
+            aborted = true;
+            callbacks.onStatus?.('Stopped');
+            break;
+        }
+        iterations++;
+        callbacks.onIteration?.(iterations, maxIterations);
+        callbacks.onStatus?.(iterations === 1 ? 'Thinking' : 'Thinking…');
+        let result;
+        try {
+            result = await (0, provider_1.withRetry)(() => provider.chat({ messages, model: config.model, tools: tools.definitions(), signal }), { retries: config.maxRetries, signal });
+        }
+        catch (err) {
+            if (err.name === 'AbortError' || err.message === 'aborted') {
+                aborted = true;
+                callbacks.onStatus?.('Stopped');
+                break;
+            }
+            if (err instanceof provider_1.ProviderError && err.status === 401) {
+                callbacks.onError?.(new Error('API authentication failed (401). Check your API key.'));
+                callbacks.onStatus?.('Auth error');
+                stopped = true;
+                finalContent = `⚠️ API authentication failed. Run \`vector /provider\` to configure your API key.`;
+                break;
+            }
+            if (err instanceof provider_1.ProviderError && err.status === 429) {
+                callbacks.onError?.(new Error('Rate limited (429) by the provider.'));
+                callbacks.onStatus?.('Rate limited');
+                stopped = true;
+                finalContent = '⚠️ Rate limited by the provider. Wait a moment and try again.';
+                break;
+            }
+            callbacks.onError?.(err);
+            callbacks.onStatus?.('Error');
+            stopped = true;
+            finalContent = `⚠️ Error: ${err.message}`;
+            break;
+        }
+        const hasToolCalls = result.toolCalls.length > 0;
+        // Streaming-free path: collect the assistant message and execute tools.
+        messages.push({
+            role: 'assistant',
+            content: result.content,
+            toolCalls: result.toolCalls,
+        });
+        if (hasToolCalls) {
+            try {
+                for (const tc of result.toolCalls) {
+                    checkAbort();
+                    toolCalls++;
+                    callbacks.onToolCall?.(tc.name, tc.arguments);
+                    callbacks.onStatus?.(`Running ${tc.name}`);
+                    const toolResult = await tools.execute(tc.name, tc.arguments, {
+                        cwd,
+                        permissions,
+                        onActivity: callbacks.onActivity,
+                        maxOutput: 30_000,
+                    });
+                    callbacks.onToolResult?.(tc.name, toolResult.output);
+                    messages.push({
+                        role: 'tool',
+                        toolCallId: tc.id,
+                        name: tc.name,
+                        content: toolResult.output.slice(0, 40_000),
+                    });
+                }
+            }
+            catch {
+                aborted = true;
+                callbacks.onStatus?.('Stopped');
+                break;
+            }
+            continue;
+        }
+        // No tool calls → final answer
+        finalContent = result.content;
+        callbacks.onStatus?.('Completed');
+        callbacks.onFinal?.(result);
+        return { content: finalContent, iterations, toolCalls, stopped, aborted, messages };
+    }
+    if (iterations >= maxIterations) {
+        callbacks.onStatus?.('Iteration limit');
+        if (!finalContent) {
+            finalContent = `⚠️ Reached the maximum of ${maxIterations} iterations without completing the task. Run /settings to raise the limit or refine the request.`;
+        }
+    }
+    return { content: finalContent, iterations, toolCalls, stopped, aborted, messages };
+}
+/** Compact conversation history into a summary to reduce token usage. */
+function compactMessages(messages, summarize) {
+    return summarize(messages).then((summary) => [
+        { role: 'system', content: prompts_1.SYSTEM_PROMPT },
+        {
+            role: 'user',
+            content: `[Previous conversation summarized]\n${summary}`,
+        },
+    ]);
+}
+function estimateContextSize(messages) {
+    let total = 0;
+    for (const m of messages) {
+        total += m.content.length;
+        if (m.toolCalls) {
+            for (const tc of m.toolCalls)
+                total += tc.arguments.length;
+        }
+    }
+    return total;
+}

package/dist/agent/memory.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMemory = loadMemory;
+exports.saveNote = saveNote;
+exports.getNote = getNote;
+exports.allNotes = allNotes;
+exports.projectKey = projectKey;
+/**
+ * Memory — persistent key-value notes per project, stored in ~/.vector/memory/.
+ * The agent can save/load small facts across sessions (e.g. "tests run with npm test").
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const paths_1 = require("../utils/paths");
+function fileFor(projectKey) {
+    return path.join((0, paths_1.getMemoryDir)(), `${(0, paths_1.sanitizeName)(projectKey)}.json`);
+}
+function loadMemory(projectKey) {
+    try {
+        const p = fileFor(projectKey);
+        if (fs.existsSync(p)) {
+            return JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return { notes: {}, updatedAt: new Date().toISOString() };
+}
+function saveNote(projectKey, key, value) {
+    const mem = loadMemory(projectKey);
+    mem.notes[key] = value;
+    mem.updatedAt = new Date().toISOString();
+    fs.mkdirSync((0, paths_1.getMemoryDir)(), { recursive: true });
+    fs.writeFileSync(fileFor(projectKey), JSON.stringify(mem, null, 2));
+}
+function getNote(projectKey, key) {
+    return loadMemory(projectKey).notes[key];
+}
+function allNotes(projectKey) {
+    return loadMemory(projectKey).notes;
+}
+/** Derive a stable project key from the project path. */
+function projectKey(cwd) {
+    const base = path.basename(cwd) || 'root';
+    return base + '-' + hashStr(cwd).slice(0, 8);
+}
+function hashStr(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++) {
+        h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+    }
+    return Math.abs(h).toString(36);
+}