cortex66 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,14 @@
+Cortex66 CLI — proprietary licence
+
+Copyright (c) 2026 Yotam Elia (Cortex66). All rights reserved.
+
+You may install and run this software (the "cortex66" command-line tool) free of charge,
+only to connect to and use the Cortex66 service (https://cortex66.com) under its terms.
+
+You may not copy, modify, merge, publish, distribute, sublicense or sell copies of the
+software or its source, except as needed to install and run it as provided, and you may
+not use it to build a competing service.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO
+EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.

package/README.md

@@ -1,3 +1,79 @@
-# Temporary Holding Version
+# cortex66 — Cortex66 in your terminal
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+```bash
+npm i -g cortex66        # Node 20 or newer; nothing runs on install
+cortex66                 # type a message; / for commands
+/connect                 # once, inside: sign this computer in and connect your AI apps
+```
+
+`cortex66` is a terminal agent like `claude` or `codex`: each line you type is one normal Cortex66 turn (the receipt, your standing cap, the cheapest capable model first, your memory, your data-trust settings) and the answer prints below it. `cortex66 -p "…"` asks once for scripts (exit 1 on a failure). `cortex66 doctor` checks Node, the keychain, that Cortex66 answers, and this computer's token.
+
+| Inside `cortex66` | Does |
+|---|---|
+| `/help` · `/exit` | the commands · leave |
+| `/connect` · `/status` · `/disconnect` | the same as the subcommands below (status adds the room) |
+| `/ask <text>` | the same as typing (`//text` sends a line that starts with a slash) |
+| `/model [cheap\|strong]` | the tier; the brain still picks the model inside it |
+| `/cost` | this session's spend (and your standing cap once the server offers it) |
+| `/new` | a new session |
+| `/agents list \| new <name> [--project] \| show <name> \| run <name> <task>` | agents as files (below) |
+| `/plan`, `/auto`, `/room`, `/watch`, `/memory` | wired; the server offers them to computers in the next phase (until then: "not offered yet; nothing was spent") |
+
+**Agents** are Markdown files with front matter, the Claude Code custom-agent shape: `.cortex66/agents/<name>.md` in a project wins over `~/.cortex66/agents/<name>.md`, which wins over the starters shipped here (`reviewer`, `planner`, `researcher`).
+
+```markdown
+---
+name: reviewer
+description: Reviews a diff for correctness bugs first, then clarity.
+tier: cheap              # cheap | strong
+tools: [ask, memory]     # ask, plan, auto, memory, room, web
+budget_usd: 0.05         # per session, at most 1; the server caps every turn at your standing cap
+---
+Read the full diff before commenting. …
+```
+
+An agent may propose a new agent (a fenced `cortex66-agent` block in its answer). It is checked and written only after you answer y.
+
+Publishing (the owner): `npm login`, then from `src/cli`: `npm publish --access public`.
+
+One line. It signs this computer in by a device code (your browser opens, you approve; never a password), finds the AI apps on this computer, and, app by app with one key press each, adds the Cortex66 connector to that app — the same connector and the same consent screen the web connect flow uses. Then it offers the Chrome extension and shows what is connected. Everything is reversible.
+
+Plan and card: [`Docs/plan/implementation/2026-11-03-desktop-and-smart-install.md`](../../Docs/plan/implementation/2026-11-03-desktop-and-smart-install.md), FL125 in [`Docs/plan/flows/14-desktop-connections-extensions.md`](../../Docs/plan/flows/14-desktop-connections-extensions.md) (D110).
+
+## Commands
+
+| Command | Does |
+|---|---|
+| `cortex66 connect` | sign in · detect apps · add the connector per app (a yes each) · offer the extension · report. `--dry-run` prints every edit and writes nothing; `--yes` answers only the safe questions (never a config write); `--skip cursor codex` leaves apps alone |
+| `cortex66 status` | sign-in state and, per app, whether the connector is in its file (read from the file, never assumed) |
+| `cortex66 disconnect` | removes exactly what connect added (our entry only, when it still equals what we wrote), revokes this computer's token, forgets the keychain item |
+
+## Apps and the files it edits
+
+| App | File | Entry |
+|---|---|---|
+| Claude Code | `~/.claude.json` | `mcpServers.cortex66 = { type: "http", url }` → then `claude mcp login cortex66` |
+| Cursor | `~/.cursor/mcp.json` | `mcpServers.cortex66 = { url }` |
+| VS Code | `~/Library/Application Support/Code/User/mcp.json` · `%APPDATA%\Code\User\mcp.json` | `servers.cortex66 = { type: "http", url }` |
+| Codex CLI / app | `~/.codex/config.toml` | `[mcp_servers.cortex66] url = …` → then `codex mcp login cortex66` |
+| Gemini CLI | `~/.gemini/settings.json` | `mcpServers.cortex66 = { httpUrl }` |
+| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` · `%APPDATA%\Claude\claude_desktop_config.json` | a stdio bridge (`npx -y mcp-remote <url>`); restart the app |
+| ChatGPT desktop | — (no connector file) | the Chrome extension |
+
+Before every write: a backup beside the file (`<name>.cortex66-backup-<time>.<ext>`, at most 5 kept), only our key changes, the result is parsed again, and the file is replaced atomically. A file that does not parse is never touched.
+
+## What it never does
+
+No passwords, no cookies, no provider keys. The computer token lives only in your system keychain. It never reads other apps' windows or keystrokes, never installs anything itself, and never edits a file without your yes.
+
+## Develop
+
+```bash
+cd src/cli
+npm ci
+npm run typecheck && npm test     # vitest: rules (B1), adapters on real config fixtures (B2), the connect chain with fakes (B3)
+npm run build                     # tsc → dist/ (bin: dist/main.js)
+CORTEX66_API=http://localhost:5080/api/v1 node dist/main.js status
+```
+
+Publishing (`npm publish`, name `cortex66`) is the owner's. The sign-in routes (`/auth/computer/*`, `/me/computers/*`) are phase 1b of the plan; until they exist, `connect` stops with "Cortex66 does not offer computer sign-in yet" and writes nothing.

package/agents/planner.md

@@ -0,0 +1,17 @@
+---
+name: planner
+description: Turns a goal into a numbered checklist of small reversible steps, each with a completion check. Use before multi-step work.
+tier: cheap
+tools: [ask, memory]
+budget_usd: 0.05
+---
+Restate the goal in one sentence and confirm it matches the user's intent.
+Break the goal into numbered steps small enough to finish and check in one sitting.
+Keep each step reversible. Prefer changes that can be undone with a single command.
+Under each step, write how to check it is done, such as a test result, command output, or file state.
+Name what is unknown, and list the questions that block each unknown.
+Ask before any step that costs money, sends data outside, deletes data, or cannot be undone.
+Mark steps that depend on earlier steps.
+Keep the plan under 15 steps. Split larger goals into phases.
+Do not carry out the steps. Only write the plan.
+Your output is a proposal. The user decides whether and how to follow it.

package/agents/researcher.md

@@ -0,0 +1,17 @@
+---
+name: researcher
+description: Finds what already exists before proposing anything new. Cites sources and separates facts from guesses.
+tier: cheap
+tools: [ask, memory, web]
+budget_usd: 0.05
+---
+Search for existing tools, code, docs, or decisions that already cover the question before proposing anything.
+Check memory for prior notes on the topic, and say when you use them.
+Use web search only when local sources do not answer the question.
+Cite the source for every fact: a file path with line number, a URL, or a memory entry.
+Label each statement as FACT (with its source) or GUESS (with the reason it is a guess).
+Do not present a guess as a fact, even when it seems obvious.
+List what you searched and what you did not find, so gaps are visible.
+Prefer options that reuse what exists. Describe new work only after that.
+Ask a question when the goal is too vague to search well.
+Your output is a proposal. The user decides which option to take.

package/agents/reviewer.md

@@ -0,0 +1,17 @@
+---
+name: reviewer
+description: Reviews a diff or text for correctness bugs first, then clarity. Use before merging or sending text out.
+tier: cheap
+tools: [ask, memory]
+budget_usd: 0.05
+---
+Read the full diff or text before commenting.
+Look for correctness bugs first: wrong logic, missing error handling, off-by-one errors, race conditions, broken edge cases.
+Then look for clarity problems: unclear names, misleading comments, dead code, confusing structure.
+For each finding, give the severity (high, medium, or low), the line number, and a one-sentence reason.
+Sort findings by severity, highest first.
+If there are no findings, say "no findings" and stop.
+Suggest a fix in a few lines at most. Never rewrite the whole thing.
+Do not praise or summarize the change unless asked.
+Ask before assuming intent when the purpose of the change is unclear.
+Your output is a proposal. The user decides which findings to act on.

package/dist/adapters/AgentFileStoreAdapter.js

@@ -0,0 +1,53 @@
+// Agent files on disk (D125), the Claude Code shape: project `.cortex66/agents/<name>.md` wins over the user's
+// `~/.cortex66/agents/<name>.md`, which wins over the starters shipped in the package (`agents/`). Reads through the FileSystemPort;
+// writes only what AgentFileValidator accepted, never over an existing file.
+import { AgentFileMapping } from "../rules/AgentFileMapping.js";
+import { AgentFileValidator } from "../rules/AgentFileValidator.js";
+export class AgentFileStoreAdapter {
+    fs;
+    dirs;
+    constructor(fs, dirs) {
+        this.fs = fs;
+        this.dirs = dirs;
+    }
+    async list() {
+        const seen = new Map();
+        for (const place of ["project", "user", "starter"]) {
+            const dir = this.dirs[place];
+            if (!(await this.fs.exists(dir)))
+                continue;
+            for (const file of (await this.fs.list(dir)).filter((f) => f.endsWith(".md")).sort()) {
+                const key = file.slice(0, -3);
+                if (!seen.has(key))
+                    seen.set(key, await this.load(place, `${dir}/${file}`));
+            }
+        }
+        return [...seen.values()];
+    }
+    async find(name) {
+        for (const place of ["project", "user", "starter"]) {
+            const path = `${this.dirs[place]}/${name}.md`;
+            if (await this.fs.exists(path))
+                return this.load(place, path);
+        }
+        return null;
+    }
+    /** Writes a validated agent; `exists` when a file of that name is already there (nothing is overwritten). */
+    async write(agent, place) {
+        const v = AgentFileValidator.check(agent);
+        if (!v.ok)
+            return { refused: "invalid", reason: `${v.field}: ${v.reason}` };
+        const dir = this.dirs[place];
+        const path = `${dir}/${agent.name}.md`;
+        if (await this.fs.exists(path))
+            return { refused: "exists", reason: path };
+        await this.fs.mkdirp(dir);
+        await this.fs.writeAtomic(path, AgentFileMapping.render(agent));
+        return { path };
+    }
+    async load(place, path) {
+        const parsed = AgentFileMapping.parse(await this.fs.read(path));
+        const verdict = parsed.ok ? AgentFileValidator.check(parsed.fields) : { ok: false, field: "name", reason: "no front matter (--- name … ---)" };
+        return { place, path, verdict };
+    }
+}

package/dist/adapters/AppConfigAdapterFactory.js

@@ -0,0 +1,33 @@
+import { ConnectorEntryPolicy } from "../rules/ConnectorEntryPolicy.js";
+import { ClaudeCodeConfigAdapter } from "./ClaudeCodeConfigAdapter.js";
+import { ClaudeDesktopConfigAdapter } from "./ClaudeDesktopConfigAdapter.js";
+import { CodexConfigAdapter } from "./CodexConfigAdapter.js";
+import { ConfigFileWriter } from "./ConfigFileWriter.js";
+import { CursorConfigAdapter } from "./CursorConfigAdapter.js";
+import { GeminiCliConfigAdapter } from "./GeminiCliConfigAdapter.js";
+import { NoConfigAdapter } from "./NoConfigAdapter.js";
+import { VsCodeConfigAdapter } from "./VsCodeConfigAdapter.js";
+export class AppConfigAdapterFactory {
+    deps;
+    writer;
+    constructor(deps) {
+        this.deps = deps;
+        this.writer = new ConfigFileWriter(deps.fs, deps.clock);
+    }
+    for(app) {
+        const path = app.configPath(this.deps.paths);
+        const entry = ConnectorEntryPolicy.entryFor(app.key, this.deps.connectorUrl);
+        if (path === null || entry === null)
+            return new NoConfigAdapter(app);
+        const d = { fs: this.deps.fs, writer: this.writer, path, entry };
+        switch (app.key) {
+            case "claude-code": return ClaudeCodeConfigAdapter(app, d);
+            case "cursor": return CursorConfigAdapter(app, d);
+            case "vscode": return VsCodeConfigAdapter(app, d);
+            case "codex": return CodexConfigAdapter(app, d);
+            case "gemini-cli": return GeminiCliConfigAdapter(app, d);
+            case "claude-desktop": return ClaudeDesktopConfigAdapter(app, d);
+            default: return new NoConfigAdapter(app);
+        }
+    }
+}

package/dist/adapters/ClaudeCodeConfigAdapter.js

@@ -0,0 +1,2 @@
+import { JsonConfigFileAdapter } from "./JsonConfigFileAdapter.js";
+export const ClaudeCodeConfigAdapter = (app, d) => new JsonConfigFileAdapter(app, d.path, d.entry, d.fs, d.writer);

package/dist/adapters/ClaudeDesktopConfigAdapter.js

@@ -0,0 +1,2 @@
+import { JsonConfigFileAdapter } from "./JsonConfigFileAdapter.js";
+export const ClaudeDesktopConfigAdapter = (app, d) => new JsonConfigFileAdapter(app, d.path, d.entry, d.fs, d.writer);

package/dist/adapters/CodexConfigAdapter.js

@@ -0,0 +1,2 @@
+import { TomlConfigFileAdapter } from "./TomlConfigFileAdapter.js";
+export const CodexConfigAdapter = (app, d) => new TomlConfigFileAdapter(app, d.path, d.entry, d.fs, d.writer);

package/dist/adapters/ConfigFileWriter.js

@@ -0,0 +1,37 @@
+import { ConfigBackupMemento } from "../rules/ConfigBackupMemento.js";
+const dirOf = (p) => p.slice(0, Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\")));
+export class ConfigFileWriter {
+    fs;
+    clock;
+    constructor(fs, clock) {
+        this.fs = fs;
+        this.clock = clock;
+    }
+    async write(path, before, after, parses) {
+        const reason = parses(after);
+        if (reason)
+            return { error: `the new content would not parse (${reason}); nothing was written` };
+        let backup = null;
+        if (before !== null) {
+            backup = ConfigBackupMemento.nameFor(path, this.clock.now());
+            await this.fs.writeAtomic(backup, before, true);
+            await this.pruneBackups(path);
+        }
+        else {
+            await this.fs.mkdirp(dirOf(path));
+        }
+        await this.fs.writeAtomic(path, after, false);
+        return { path, before: before ?? "", after, backup };
+    }
+    async listBackups(path) {
+        const dir = dirOf(path);
+        if (!(await this.fs.exists(dir)))
+            return [];
+        return (await this.fs.list(dir)).filter((n) => ConfigBackupMemento.isBackupOf(path, n)).map((n) => `${dir}/${n}`);
+    }
+    async pruneBackups(path) {
+        const names = (await this.listBackups(path)).map((p) => p.slice(dirOf(path).length + 1));
+        for (const old of ConfigBackupMemento.prune(names))
+            await this.fs.remove(`${dirOf(path)}/${old}`);
+    }
+}

package/dist/adapters/CursorConfigAdapter.js

@@ -0,0 +1,2 @@
+import { JsonConfigFileAdapter } from "./JsonConfigFileAdapter.js";
+export const CursorConfigAdapter = (app, d) => new JsonConfigFileAdapter(app, d.path, d.entry, d.fs, d.writer);

package/dist/adapters/GeminiCliConfigAdapter.js

@@ -0,0 +1,2 @@
+import { JsonConfigFileAdapter } from "./JsonConfigFileAdapter.js";
+export const GeminiCliConfigAdapter = (app, d) => new JsonConfigFileAdapter(app, d.path, d.entry, d.fs, d.writer);

package/dist/adapters/JsonConfigFileAdapter.js

@@ -0,0 +1,68 @@
+import { ConnectorEntryValidator } from "../rules/ConnectorEntryPolicy.js";
+import { JsonEditPolicy } from "../rules/JsonEditPolicy.js";
+export class JsonConfigFileAdapter {
+    app;
+    path;
+    entry;
+    fs;
+    writer;
+    constructor(app, path, entry, fs, writer) {
+        this.app = app;
+        this.path = path;
+        this.entry = entry;
+        this.fs = fs;
+        this.writer = writer;
+    }
+    async status() {
+        const l = await this.load();
+        if ("error" in l)
+            return { state: "unparseable", reason: l.error };
+        const v = ConnectorEntryValidator.verdict(JsonEditPolicy.get(l.doc, this.app.keyPath), this.entry);
+        return v === "ours" ? { state: "connected" } : v === "changed" ? { state: "changed" } : { state: "missing", fileExists: l.text !== null };
+    }
+    async planConnect() {
+        const l = await this.load();
+        if ("error" in l)
+            return { error: l.error };
+        if (ConnectorEntryValidator.verdict(JsonEditPolicy.get(l.doc, this.app.keyPath), this.entry) === "ours")
+            return null;
+        const after = JsonEditPolicy.serialize(JsonEditPolicy.set(l.doc, this.app.keyPath, this.entry), l.indent);
+        return { path: this.path, before: l.text ?? "", after, backup: null };
+    }
+    async connect() {
+        const plan = await this.planConnect();
+        if (plan === null || "error" in plan)
+            return plan;
+        const existed = await this.fs.exists(this.path);
+        return this.writer.write(this.path, existed ? plan.before : null, plan.after, parses);
+    }
+    async planDisconnect() {
+        const l = await this.load();
+        if ("error" in l)
+            return { error: l.error };
+        const v = ConnectorEntryValidator.verdict(JsonEditPolicy.get(l.doc, this.app.keyPath), this.entry);
+        if (v === "absent")
+            return null;
+        if (v === "changed")
+            return { error: `the cortex66 entry in ${this.path} was changed by hand; I left it alone` };
+        const after = JsonEditPolicy.serialize(JsonEditPolicy.remove(l.doc, this.app.keyPath), l.indent);
+        return { path: this.path, before: l.text ?? "", after, backup: null };
+    }
+    async disconnect() {
+        const plan = await this.planDisconnect();
+        if (plan === null || "error" in plan)
+            return plan;
+        return this.writer.write(this.path, plan.before, plan.after, parses);
+    }
+    async load() {
+        if (!(await this.fs.exists(this.path)))
+            return { text: null, doc: {}, indent: "  " };
+        const text = await this.fs.read(this.path);
+        const p = JsonEditPolicy.parse(text);
+        return p.ok ? { text, doc: p.doc, indent: p.indent } : { error: `${this.path} does not parse (${p.reason}); I did not touch it` };
+    }
+}
+const parses = (text) => {
+    const p = JsonEditPolicy.parse(text);
+    return p.ok ? null : p.reason;
+};

package/dist/adapters/NoConfigAdapter.js

@@ -0,0 +1,22 @@
+export class NoConfigAdapter {
+    app;
+    path = null;
+    constructor(app) {
+        this.app = app;
+    }
+    async status() {
+        return { state: "no_config" };
+    }
+    async planConnect() {
+        return null;
+    }
+    async connect() {
+        return null;
+    }
+    async planDisconnect() {
+        return null;
+    }
+    async disconnect() {
+        return null;
+    }
+}

package/dist/adapters/StateFileAdapter.js

@@ -0,0 +1,27 @@
+import { JsonEditPolicy } from "../rules/JsonEditPolicy.js";
+const EMPTY = { version: 1, computerId: null, written: {} };
+export class StateFileAdapter {
+    fs;
+    path;
+    constructor(fs, paths) {
+        this.fs = fs;
+        const dir = paths.platform === "windows" ? `${paths.appData}/cortex66` : `${paths.home}/.config/cortex66`;
+        this.path = `${dir}/state.json`;
+    }
+    async read() {
+        if (!(await this.fs.exists(this.path)))
+            return { ...EMPTY, written: {} };
+        const p = JsonEditPolicy.parse(await this.fs.read(this.path));
+        if (!p.ok || p.doc.version !== 1)
+            return { ...EMPTY, written: {} };
+        return { version: 1, computerId: p.doc.computerId ?? null, written: p.doc.written ?? {} };
+    }
+    async write(state) {
+        await this.fs.mkdirp(this.path.slice(0, this.path.lastIndexOf("/")));
+        await this.fs.writeAtomic(this.path, JSON.stringify(state, null, 2) + "\n", true);
+    }
+    async clear() {
+        if (await this.fs.exists(this.path))
+            await this.fs.remove(this.path);
+    }
+}

package/dist/adapters/TomlConfigFileAdapter.js

@@ -0,0 +1,71 @@
+import { ConnectorEntryValidator } from "../rules/ConnectorEntryPolicy.js";
+import { TomlEditPolicy } from "../rules/TomlEditPolicy.js";
+export class TomlConfigFileAdapter {
+    app;
+    path;
+    entry;
+    fs;
+    writer;
+    constructor(app, path, entry, fs, writer) {
+        this.app = app;
+        this.path = path;
+        this.entry = entry;
+        this.fs = fs;
+        this.writer = writer;
+    }
+    async status() {
+        const l = await this.load();
+        if ("error" in l)
+            return { state: "unparseable", reason: l.error };
+        const v = ConnectorEntryValidator.verdict(TomlEditPolicy.get(l.doc, this.app.keyPath), this.entry);
+        return v === "ours" ? { state: "connected" } : v === "changed" ? { state: "changed" } : { state: "missing", fileExists: l.text !== null };
+    }
+    async planConnect() {
+        const l = await this.load();
+        if ("error" in l)
+            return { error: l.error };
+        const v = ConnectorEntryValidator.verdict(TomlEditPolicy.get(l.doc, this.app.keyPath), this.entry);
+        if (v === "ours")
+            return null;
+        if (v === "changed")
+            return { error: `${this.path} already has a different [${this.app.keyPath.join(".")}] table; I left it alone` };
+        const after = TomlEditPolicy.append(l.text ?? "", this.app.keyPath, this.entry);
+        return { path: this.path, before: l.text ?? "", after, backup: null };
+    }
+    async connect() {
+        const plan = await this.planConnect();
+        if (plan === null || "error" in plan)
+            return plan;
+        const existed = await this.fs.exists(this.path);
+        return this.writer.write(this.path, existed ? plan.before : null, plan.after, parses);
+    }
+    async planDisconnect() {
+        const l = await this.load();
+        if ("error" in l)
+            return { error: l.error };
+        const v = ConnectorEntryValidator.verdict(TomlEditPolicy.get(l.doc, this.app.keyPath), this.entry);
+        if (v === "absent")
+            return null;
+        if (v === "changed")
+            return { error: `the [${this.app.keyPath.join(".")}] table in ${this.path} was changed by hand; I left it alone` };
+        const after = TomlEditPolicy.remove(l.text ?? "", this.app.keyPath);
+        return { path: this.path, before: l.text ?? "", after, backup: null };
+    }
+    async disconnect() {
+        const plan = await this.planDisconnect();
+        if (plan === null || "error" in plan)
+            return plan;
+        return this.writer.write(this.path, plan.before, plan.after, parses);
+    }
+    async load() {
+        if (!(await this.fs.exists(this.path)))
+            return { text: null, doc: {} };
+        const text = await this.fs.read(this.path);
+        const p = TomlEditPolicy.parse(text);
+        return p.ok ? { text, doc: p.doc } : { error: `${this.path} does not parse (${p.reason}); I did not touch it` };
+    }
+}
+const parses = (text) => {
+    const p = TomlEditPolicy.parse(text);
+    return p.ok ? null : p.reason;
+};

package/dist/adapters/VsCodeConfigAdapter.js

@@ -0,0 +1,2 @@
+import { JsonConfigFileAdapter } from "./JsonConfigFileAdapter.js";
+export const VsCodeConfigAdapter = (app, d) => new JsonConfigFileAdapter(app, d.path, d.entry, d.fs, d.writer);

package/dist/commands/CliPorts.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/CliProgramFactory.js

@@ -0,0 +1,55 @@
+// Factory Method (p. 85): builds the `cortex66` program from the ports. `cortex66` alone opens the terminal agent; `-p "<text>"` is
+// one turn for scripts; connect | status | disconnect | doctor stay subcommands. The terminal's /connect, /status and /disconnect run
+// the SAME subcommand code through a fresh program (no second implementation).
+import { Command } from "commander";
+import { AgentFileStoreAdapter } from "../adapters/AgentFileStoreAdapter.js";
+import { slashNames } from "../rules/SlashCommandCatalog.js";
+import { TerminalLineParser } from "../rules/TerminalLineParser.js";
+import { AgentRunService } from "../terminal/AgentRunService.js";
+import { AgentsSlashHandler } from "../terminal/AgentsSlashHandler.js";
+import { SlashCommandRouter } from "../terminal/SlashCommandRouter.js";
+import { TerminalLoop } from "../terminal/TerminalLoop.js";
+import { TerminalSession } from "../terminal/TerminalSession.js";
+import { TurnService } from "../terminal/TurnService.js";
+import { registerConnectCommand } from "./ConnectCommand.js";
+import { registerDisconnectCommand } from "./DisconnectCommand.js";
+import { registerDoctorCommand } from "./DoctorCommand.js";
+import { registerStatusCommand } from "./StatusCommand.js";
+const DESCRIPTION = "Cortex66 in your terminal: type a message and the brain answers (receipt, standing cap, cheap first); / for commands.";
+export const CliProgramFactory = {
+    build(ports) {
+        const program = new Command("cortex66").description(DESCRIPTION).version(ports.version)
+            .option("-p, --print <text>", "ask once and print the answer (for scripts); exit code 1 on a failure")
+            .action(async (opts) => {
+            const loop = CliProgramFactory.loop(ports);
+            if (opts.print !== undefined)
+                process.exitCode = await loop.print(opts.print);
+            else
+                await loop.interactive(ports.version);
+        });
+        CliProgramFactory.subcommands(program, ports);
+        registerDoctorCommand(program, ports);
+        return program;
+    },
+    loop(ports) {
+        const session = new TerminalSession();
+        const turns = new TurnService(ports.api, ports.tokens, session);
+        const store = new AgentFileStoreAdapter(ports.fs, ports.agentDirs);
+        const reader = ports.lineReader((prefix) => TerminalLineParser.complete(prefix, slashNames()));
+        const router = new SlashCommandRouter({
+            api: ports.api, turns, session, agents: new AgentsSlashHandler(store, new AgentRunService(turns, store, session)),
+            runSubcommand: async (name) => {
+                reader.suspend();
+                const sub = new Command("cortex66").exitOverride();
+                CliProgramFactory.subcommands(sub, ports);
+                await sub.parseAsync([name], { from: "user" }).catch((e) => ports.out.warn(`cortex66 ${name}: ${e.message}`));
+            },
+        });
+        return new TerminalLoop(router, turns, reader, ports.out);
+    },
+    subcommands(program, ports) {
+        registerConnectCommand(program, ports);
+        registerStatusCommand(program, ports);
+        registerDisconnectCommand(program, ports);
+    },
+};

package/dist/commands/ConnectCommand.js

@@ -0,0 +1,39 @@
+import { AppConfigAdapterFactory } from "../adapters/AppConfigAdapterFactory.js";
+import { StateFileAdapter } from "../adapters/StateFileAdapter.js";
+import { ConnectorEntryPolicy } from "../rules/ConnectorEntryPolicy.js";
+import { InstallStepChain } from "../rules/InstallStepChain.js";
+export const DEFAULT_EXTENSION_URL = "https://cortex66.com/extension";
+export function registerConnectCommand(program, ports) {
+    program
+        .command("connect")
+        .description("sign in by device code, add the Cortex66 connector to the AI apps on this computer (one yes per app), offer the Chrome extension")
+        .option("--dry-run", "print every edit, write nothing", false)
+        .option("--yes", "answer yes to the safe questions only (never to a config write)", false)
+        .option("--skip <app...>", "apps to leave alone (claude-code, cursor, vscode, codex, gemini-cli, claude-desktop)", [])
+        .action(async (opts) => {
+        const prompt = ports.promptFor(opts.yes);
+        const factory = new AppConfigAdapterFactory({ fs: ports.fs, clock: ports.clock, paths: ports.paths, connectorUrl: ports.connectorUrl });
+        const ctx = {
+            paths: ports.paths, fs: ports.fs, process: ports.process, clock: ports.clock, prompt, api: ports.api, tokens: ports.tokens,
+            adapterFor: (app) => factory.for(app),
+            options: { dryRun: opts.dryRun, skip: new Set(opts.skip), extensionUrl: ports.extensionUrl ?? DEFAULT_EXTENSION_URL, connectorUrl: ports.connectorUrl },
+        };
+        const result = await InstallStepChain.run(ctx);
+        if (!opts.dryRun && ctx.written && ctx.written.length > 0) {
+            const state = new StateFileAdapter(ports.fs, ports.paths);
+            const s = await state.read();
+            if (ctx.token)
+                s.computerId = ctx.token.computerId;
+            for (const w of ctx.written) {
+                const entry = ConnectorEntryPolicy.entryFor(w.key, ports.connectorUrl);
+                if (entry)
+                    s.written[w.key] = { fingerprint: ConnectorEntryPolicy.fingerprint(entry), path: w.path, at: ports.clock.now().toISOString() };
+            }
+            await state.write(s);
+        }
+        if (result.stoppedAt) {
+            prompt.warn(`\nstopped at ${result.stoppedAt}: ${result.reason}`);
+            process.exitCode = 2;
+        }
+    });
+}