@megacode/cli 0.2.0

package/dist/ui/session.js

@@ -0,0 +1,168 @@
+import { providerInfo } from "../adapters/providers/catalog.js";
+import { providerOf } from "../adapters/providers/credentials.js";
+import { autoApproved, EDIT_TOOLS } from "../core/settings.js";
+import { buildDiff } from "./diff.js";
+import { displayOutput } from "./format.js";
+const VERBS = ["Thinking", "Pondering", "Working", "Crafting", "Computing", "Tinkering"];
+/**
+ * One conversation with the agent, independent of React: running turns, queueing messages typed
+ * meanwhile, interrupting, and answering the agent's approvals and questionnaires.
+ * State is an immutable snapshot; `subscribe` reports changes.
+ */
+export class AgentSession {
+    #state = {
+        running: false,
+        activeTool: null,
+        approval: null,
+        questionnaire: null,
+        queued: [],
+        verb: VERBS[0],
+        completedTurns: 0,
+    };
+    #listeners = new Set();
+    #controller = null;
+    #denied = false;
+    #sendNow = false; // interrupted to send the queue: run it instead of handing it back
+    #alwaysAllow = new Set();
+    #agent;
+    #host;
+    constructor(agent, host) {
+        this.#agent = agent;
+        this.#host = host;
+    }
+    get state() {
+        return this.#state;
+    }
+    subscribe = (listener) => {
+        this.#listeners.add(listener);
+        return () => void this.#listeners.delete(listener);
+    };
+    #update(patch) {
+        this.#state = { ...this.#state, ...patch };
+        for (const listener of this.#listeners)
+            listener();
+    }
+    /** Runs the message now, or queues it for after the current turn. Resolves when the session is idle again. */
+    submit = (text) => {
+        if (!this.#controller)
+            return this.#send(text);
+        this.#update({ queued: [...this.#state.queued, text] });
+        return Promise.resolve();
+    };
+    /** Stops the running turn and denies a pending approval. Queued messages go back to the input. */
+    interrupt = () => {
+        const { approval } = this.#state;
+        if (approval) {
+            approval.resolve(false);
+            this.#update({ approval: null });
+        }
+        this.#controller?.abort();
+    };
+    /** Adds `extra` to the queue, then stops the running turn so the queue is sent right away. */
+    flushQueue = (extra) => {
+        if (extra)
+            this.#update({ queued: [...this.#state.queued, extra] });
+        if (!this.#state.queued.length)
+            return;
+        this.#sendNow = true;
+        this.interrupt();
+    };
+    answerApproval = (choice) => {
+        const { approval } = this.#state;
+        if (!approval)
+            return;
+        if (choice === "always") {
+            if (EDIT_TOOLS.has(approval.tool))
+                this.#host.onAllowEdits();
+            else
+                this.#alwaysAllow.add(approval.tool);
+        }
+        approval.resolve(choice !== "no");
+        this.#update({ approval: null });
+        if (choice === "no") {
+            this.#denied = true;
+            this.#controller?.abort();
+        }
+    };
+    /** Aborts any running turn without reporting it, e.g. when the app exits. */
+    abort = () => this.#controller?.abort();
+    async #send(text) {
+        const host = this.#host;
+        if (!host.canSend(text))
+            return;
+        host.push({ kind: "user", text });
+        const ctrl = (this.#controller = new AbortController());
+        this.#denied = false;
+        this.#sendNow = false;
+        this.#update({ running: true, verb: VERBS[Math.floor(Math.random() * VERBS.length)] });
+        let interrupted = false;
+        try {
+            await this.#agent.send(text, ctrl.signal, this.#events());
+            if (!ctrl.signal.aborted)
+                this.#update({ completedTurns: this.#state.completedTurns + 1 });
+        }
+        catch (e) {
+            host.onStepEnd(); // commit any half-streamed text
+            interrupted = ctrl.signal.aborted;
+            this.#reportFailure(e, interrupted);
+        }
+        finally {
+            this.#controller = null;
+            this.#update({ running: false, activeTool: null });
+        }
+        // Send queued messages next; after an interrupt (other than flushQueue), hand them back to the input instead.
+        const next = this.#state.queued.join("\n");
+        this.#update({ queued: [] });
+        if (next && interrupted && !this.#sendNow)
+            host.restoreInput(next);
+        else if (next)
+            await this.#send(next);
+    }
+    #reportFailure(error, interrupted) {
+        const { notice } = this.#host;
+        if (this.#denied)
+            notice("Denied. Tell megacode what to do instead.", "warn");
+        else if (interrupted && this.#sendNow)
+            notice("Interrupted to send queued messages.");
+        else if (interrupted)
+            notice("Interrupted. What should megacode do instead?", "warn");
+        else if ([401, 403].includes(error.status))
+            notice(`${providerInfo(providerOf(this.#agent.model)).label} rejected the credentials. Run /login to update them.`, "error");
+        else
+            notice(error.message, "error");
+    }
+    #approve = (req) => {
+        if (autoApproved(this.#host.mode(), req.tool) || this.#alwaysAllow.has(req.tool))
+            return Promise.resolve(true);
+        return new Promise((resolve) => this.#update({ approval: { ...req, resolve } }));
+    };
+    #askQuestions = (questions, signal) => new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve(null);
+        const finish = (answers) => {
+            signal?.removeEventListener("abort", abort);
+            this.#update({ questionnaire: null });
+            resolve(answers);
+        };
+        const abort = () => finish(null);
+        signal?.addEventListener("abort", abort, { once: true });
+        this.#update({ questionnaire: { questions, resolve: finish } });
+    });
+    #events() {
+        const host = this.#host;
+        return {
+            approve: this.#approve,
+            askQuestions: this.#askQuestions,
+            onText: (delta) => host.onText(delta),
+            onStepEnd: () => host.onStepEnd(),
+            onToolStart: (call) => this.#update({ activeTool: call }),
+            onToolEnd: (call, r) => {
+                this.#update({ activeTool: null });
+                // The transcript shows the whole edit; a new file shows its first lines, as in Claude Code.
+                const diff = r.change && !r.isError ? buildDiff(r.change, r.change.created ? 10 : 60) : undefined;
+                host.push({ kind: "tool", call, output: displayOutput(call, r, diff), isError: r.isError, diff: diff ?? undefined });
+            },
+            onNotice: (text, level) => host.notice(text, level),
+        };
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@megacode/cli",
+  "version": "0.2.0",
+  "description": "Minimal multi-provider coding agent for the terminal (Anthropic, OpenAI, Gemini, OpenAI-compatible)",
+  "keywords": [
+    "ai",
+    "agent",
+    "coding-agent",
+    "cli",
+    "llm",
+    "anthropic",
+    "claude",
+    "openai",
+    "gemini",
+    "ollama"
+  ],
+  "author": "Michal Jach",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "megacode": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.14"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "tsx src/cli.tsx",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc",
+    "test": "node --import tsx --test test/*.test.ts test/*.test.mjs",
+    "bench": "tsx bench/run.ts",
+    "prepublishOnly": "npm test && npm run typecheck && npm run build"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.128.0",
+    "@google/genai": "^2.24.0",
+    "@modelcontextprotocol/sdk": "^1.32.0",
+    "chalk": "^5.6.2",
+    "diff": "^9.0.0",
+    "ink": "^7.1.1",
+    "openai": "^7.23.0",
+    "react": "^19.3.0",
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.3",
+    "@types/react": "^19.3.0",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
+  }
+}