aegiscode 5.2.32 → 6.0.0

package/bin/aegiscode.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * `aegiscode` — the AEGIS terminal host.
+ *
+ * Third host over the same two shared pieces the other two use: the thin
+ * transport (client/aegis.js) and the tool registry (mcp/tools.js). The MCP
+ * host answers a coding agent's tool calls; the desktop is a window; this is
+ * the shell. None of them owns a brain — routing, tiers, memory and billing all
+ * stay behind aegiscloud.org.
+ *
+ * This file is argument parsing and process lifecycle only. Everything
+ * testable lives in ../src/app.js.
+ */
+
+const path = require('node:path');
+
+const HELP = `aegiscode — AEGIS in your shell.
+
+Usage:
+  aegiscode                     interactive session
+  aegiscode "question"          one-shot, then exit
+  aegiscode -p "question"       same, explicit
+  echo "q" | aegiscode -p -     read the prompt from stdin
+
+Options:
+  -m, --model <id>        pin a model id (see /models; default: server choice)
+      --base <url>        API base (default $AEGIS_API_BASE or aegiscloud.org)
+      --key <key>         API key for this run (prefer $AEGIS_API_KEY)
+      --json              with -p: emit JSON instead of text
+      --no-stream         buffer the answer instead of streaming it
+      --max-tokens <n>    output ceiling hint
+      --light             light theme
+      --width <cols>      force a render width (useful for piping/logs)
+  -h, --help              this text
+  -v, --version           print the version
+
+In-session: type /help for commands, /quit to exit, esc/ctrl+c to interrupt a
+running call. Plain text is a prompt (identical to /ask).
+`;
+
+function parseArgs(argv) {
+  const opts = {
+    model: null,
+    base: null,
+    key: null,
+    json: false,
+    stream: true,
+    maxTokens: undefined,
+    light: false,
+    width: null,
+    prompt: null,
+    help: false,
+    version: false,
+  };
+  const rest = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => {
+      const v = argv[++i];
+      if (v === undefined) throw new Error(`${a} needs a value`);
+      return v;
+    };
+    switch (a) {
+      case '-h':
+      case '--help':
+        opts.help = true;
+        break;
+      case '-v':
+      case '--version':
+        opts.version = true;
+        break;
+      case '-p':
+      case '--print':
+        // `-p` takes an optional prompt; a bare `-p` means "read stdin".
+        opts.prompt = argv[i + 1] && !argv[i + 1].startsWith('-') ? next() : '-';
+        break;
+      case '-m':
+      case '--model':
+        opts.model = next();
+        break;
+      case '--base':
+        opts.base = next();
+        break;
+      case '--key':
+        opts.key = next();
+        break;
+      case '--json':
+        opts.json = true;
+        break;
+      case '--no-stream':
+        opts.stream = false;
+        break;
+      case '--stream':
+        opts.stream = true;
+        break;
+      case '--max-tokens':
+        opts.maxTokens = Number(next());
+        break;
+      case '--light':
+        opts.light = true;
+        break;
+      case '--width':
+        opts.width = Number(next());
+        break;
+      default:
+        if (a.startsWith('-') && a !== '-') throw new Error(`unknown option: ${a}`);
+        rest.push(a);
+    }
+  }
+  if (!opts.prompt && rest.length) opts.prompt = rest.join(' ');
+  return opts;
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let buf = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => {
+      buf += c;
+    });
+    process.stdin.on('end', () => resolve(buf.trim()));
+  });
+}
+
+async function main(argv = process.argv.slice(2)) {
+  let opts;
+  try {
+    opts = parseArgs(argv);
+  } catch (e) {
+    process.stderr.write(`aegiscode: ${e.message}\n\n${HELP}`);
+    return 2;
+  }
+
+  if (opts.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+
+  const pkg = require(path.join(__dirname, '..', 'package.json'));
+  if (opts.version) {
+    process.stdout.write(pkg.version + '\n');
+    return 0;
+  }
+
+  // Apply the flags that the shared client reads from the environment, before
+  // anything constructs it.
+  if (opts.base) process.env.AEGIS_API_BASE = opts.base;
+  if (opts.key) process.env.AEGIS_API_KEY = opts.key;
+
+  const { createApp } = require('../src/app.js');
+
+  let prompt = opts.prompt;
+  if (prompt === '-') {
+    if (process.stdin.isTTY) {
+      process.stderr.write('aegiscode: -p - expects a prompt on stdin\n');
+      return 2;
+    }
+    prompt = await readStdin();
+    if (!prompt) {
+      process.stderr.write('aegiscode: empty stdin\n');
+      return 2;
+    }
+  }
+
+  const app = createApp({
+    model: opts.model,
+    stream: opts.stream,
+    light: opts.light,
+    maxTokens: opts.maxTokens,
+    width: opts.width ? () => opts.width : undefined,
+    interactive: !prompt && Boolean(process.stdin.isTTY),
+  });
+
+  if (prompt) return app.runOnce(prompt, { json: opts.json });
+
+  if (!process.stdin.isTTY) {
+    process.stderr.write(
+      'aegiscode: no terminal and no prompt. Use `aegiscode -p "question"` or pipe a prompt in.\n'
+    );
+    return 2;
+  }
+  return app.runInteractive();
+}
+
+if (require.main === module) {
+  main()
+    .then((code) => process.exit(code || 0))
+    .catch((e) => {
+      process.stderr.write(`aegiscode: ${e && e.message ? e.message : e}\n`);
+      process.exit(1);
+    });
+}
+
+module.exports = { main, parseArgs, HELP };

package/package.json

@@ -1,98 +1,45 @@
 {
   "name": "aegiscode",
-  "version": "5.2.32",
-  "description": "AEGIS CLI — AI-powered coding assistant",
-  "type": "module",
-  "bin": {
-    "aegis": "bin/cli.js",
-    "aegis-cli": "bin/cli.js",
-    "aegiscli": "bin/cli.js",
-    "aegiscode": "bin/cli.js"
-  },
-  "scripts": {
-    "preinstall": "node scripts/ensure-node-version.mjs",
-    "build": "node esbuild.mjs",
-    "build:publish": "npm run build && node scripts/make-bin.mjs",
-    "dev": "NODE_NO_WARNINGS=1 tsx src/main.tsx",
-    "start": "node --no-deprecation dist/main.js",
-    "typecheck": "tsc --noEmit",
-    "test:prompts": "tsx src/prompts/test.ts",
-    "test:tools": "tsx src/tools/test.ts",
-    "test:pipeline": "tsx src/tools/execution/test.ts",
-    "test:context": "tsx src/context/test.ts",
-    "test:mcp": "tsx src/mcp/test.ts",
-    "test:store": "tsx src/store/test.ts && tsx src/store/streaming-buffer.test.ts",
-    "test:estimate": "tsx src/ui/components/layout/line-estimate.test.ts"
+  "productName": "AEGIS Code",
+  "version": "6.0.0",
+  "description": "aegiscode — the command-line version of AEGIS Desktop. The shared tool surface in your shell, over the same thin transport and tool registry as the MCP plugin and the desktop app. Ships transport + UI only; no brain.",
+  "author": {
+    "name": "AEGIS Code",
+    "email": "nborneklint@gmail.com"
   },
-  "keywords": [
-    "cli",
-    "ai",
-    "coding-agent",
-    "llm",
-    "openai",
-    "gpt",
-    "claude",
-    "copilot",
-    "assistant",
-    "terminal",
-    "developer-tools"
-  ],
-  "author": "Niklas Borneklint",
   "license": "MIT",
+  "homepage": "https://aegiscloud.org",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/aegisinfo/aegiscode.git"
+    "url": "git+https://github.com/aegisinfo/aegiscode-plugin.git",
+    "directory": "cli"
   },
-  "homepage": "https://github.com/aegisinfo/aegiscode#readme",
-  "bugs": {
-    "url": "https://github.com/aegisinfo/aegiscode/issues"
+  "bin": {
+    "aegiscode": "bin/aegiscode.js"
   },
   "files": [
-    "bin/",
-    "scripts/",
-    "README.md",
-    "LICENSE"
+    "bin",
+    "src",
+    "scripts",
+    "vendor",
+    "README.md"
   ],
   "engines": {
     "node": ">=18.0.0"
   },
-  "dependencies": {
-    "@huggingface/transformers": "^4.2.0",
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "chalk": "^6.0.0",
-    "dotenv": "^17.4.2",
-    "fuse.js": "^7.4.1",
-    "glob": "^13.0.0",
-    "ink": "^7.1.1",
-    "ink-text-input": "^6.0.0",
-    "js-tiktoken": "^1.0.21",
-    "lowlight": "^3.3.0",
-    "minimatch": "^10.2.6",
-    "nanoid": "^6.0.0",
-    "openai": "^7.3.0",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "sql.js": "^1.14.1",
-    "string-width": "^8.2.2",
-    "uuid": "^14.0.0",
-    "yaml": "^2.8.2",
-    "yargs": "^18.1.0",
-    "zod": "^4.4.3",
-    "zustand": "^5.0.14"
-  },
-  "devDependencies": {
-    "@types/node": "^26.1.2",
-    "@types/react": "^19.2.18",
-    "@types/sql.js": "^1.4.11",
-    "@types/yargs": "^17.0.35",
-    "esbuild": "^0.28.0",
-    "tsx": "^4.23.4",
-    "typescript": "^7.0.2"
+  "scripts": {
+    "start": "node bin/aegiscode.js",
+    "predist": "node scripts/predist.mjs",
+    "prepublishOnly": "npm run predist",
+    "check": "node --check bin/aegiscode.js && node --check src/theme.js && node --check src/art.js && node --check src/screen.js && node --check src/format.js && node --check src/render.js && node --check src/commands.js && node --check src/deps.js && node --check src/app.js && node --check scripts/predist.mjs",
+    "test": "for f in ../../test/cli-*.test.mjs; do node \"$f\" || exit 1; done"
   },
-  "overrides": {
-    "string-width": "^8.2.2",
-    "slice-ansi": "^7.1.2",
-    "cli-truncate": "^4.0.0",
-    "cli-boxes": "^3.0.0"
-  }
+  "keywords": [
+    "aegis",
+    "aegiscode",
+    "aegiscloud",
+    "cli",
+    "terminal",
+    "llm"
+  ]
 }

package/scripts/demo.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * Renders a canned session to stdout — banner, a prompt, a streamed answer with
+ * markdown, the accounting line, and the status bar.
+ *
+ * No network and no key: this exists so the look can be reviewed (and pasted
+ * into docs) without a live account, and so a regression in the layout is
+ * visible to a human, not only to the width assertions in test/cli-render.
+ *
+ *   node cli/scripts/demo.mjs [--light] [--width 84] [--plain]
+ */
+
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const src = path.join(__dirname, '..', 'src');
+
+const render = require(path.join(src, 'render.js'));
+const { stripAnsi } = require(path.join(src, 'screen.js'));
+const art = require(path.join(src, 'art.js'));
+// Read the version rather than hardcoding it — a demo that reports a stale
+// version is the kind of drift nobody notices until it is in the docs.
+const { version } = require(path.join(__dirname, '..', 'package.json'));
+
+const argv = process.argv.slice(2);
+const flag = (name, fallback) => {
+  const i = argv.indexOf(name);
+  return i === -1 ? fallback : argv[i + 1];
+};
+const width = Number(flag('--width', 0)) || Math.min(96, Math.max(48, process.stdout.columns || 84));
+const ctx = { light: argv.includes('--light') };
+const plain = argv.includes('--plain');
+
+const out = [];
+const push = (lines) => out.push(...(Array.isArray(lines) ? lines : [lines]));
+
+push(
+  render.renderBanner(ctx, {
+    width,
+    version,
+    model: 'nexus-brain',
+    base: 'https://aegiscloud.org',
+    key: 'aegis_••••4f2a',
+    stream: true,
+  })
+);
+push('');
+push(render.renderTurn(ctx, { role: 'user', text: 'summarise what changed in the token accounting' }, width));
+push(
+  render.renderTurn(
+    ctx,
+    {
+      role: 'assistant',
+      text: [
+        'Three things changed, and one of them was costing you money:',
+        '',
+        '- the pool **merges** worker usage instead of overwriting it',
+        '- cache reads and writes are billed, not ignored',
+        '- a zero-token call no longer refunds its reservation',
+        '',
+        '```',
+        'merge_usage({input_tokens: 1250}, {output_tokens: 312})',
+        '=> 1562 total',
+        '```',
+        '',
+        'Use `/balance` to see tokens beside € on every row.',
+      ].join('\n'),
+      meta: {
+        model: 'nexus-brain',
+        tokens: 1562,
+        usage: { input: 1250, output: 312 },
+        eur: 0.0007,
+        ms: 4200,
+        calls: 4,
+      },
+    },
+    width
+  )
+);
+push('');
+push(render.renderWorking(ctx, { tick: 3, verb: 'Consulting', elapsedMs: 2100 }));
+push(render.renderStatus(ctx, { model: 'nexus-brain', tokens: 1562, spend: 0.0007, mode: 'stream' }, width));
+
+process.stdout.write((plain ? out.map(stripAnsi) : out).join('\n') + '\n\n');
+if (!plain) {
+  process.stdout.write(
+    stripAnsi(`${art.WORDMARK} — ${out.length} lines rendered at ${width} cols${ctx.light ? ' (light)' : ''}\n`)
+  );
+}

package/scripts/predist.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Pre-publish staging for the `aegiscode` package.
+ *
+ * The CLI is a host, not a fork: it consumes the repo's shared modules
+ * (`client/aegis.js` transport, `mcp/tools.js` registry, the desktop's pure
+ * `usage.js` mapping) rather than copies of them. npm can only publish a
+ * package's own directory, so those files are staged into `cli/vendor/` here,
+ * at publish time, keeping the repo's relative shape:
+ *
+ *   cli/                        repo/
+ *     vendor/mcp/tools.js   ≡     mcp/tools.js
+ *     vendor/client/*.js    ≡     client/*.js
+ *     vendor/desktop/...    ≡     desktop/renderer/usage.js
+ *
+ * The shape matters: `mcp/tools.js` requires `../client/foreign-memory.js`, and
+ * because the staged tree mirrors the repo, that path resolves *inside* the
+ * vendor tree with no rewrite in either file.
+ *
+ * `src/deps.js` resolves in-repo paths first and falls back to `vendor/`, so a
+ * source checkout and an installed package run identical code.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const CLI_DIR = path.join(__dirname, '..');
+const REPO_DIR = path.join(CLI_DIR, '..');
+const VENDOR = path.join(CLI_DIR, 'vendor');
+
+/** repo-relative -> staged location (same relative shape, under vendor/) */
+const FILES = [
+  'client/aegis.js',
+  'client/foreign-memory.js',
+  'mcp/tools.js',
+  'desktop/renderer/usage.js',
+];
+
+function main() {
+  fs.rmSync(VENDOR, { recursive: true, force: true });
+  const staged = [];
+
+  for (const rel of FILES) {
+    const from = path.join(REPO_DIR, rel);
+    if (!fs.existsSync(from)) {
+      console.error(`predist: missing shared module: ${rel} (expected at ${from})`);
+      process.exit(1);
+    }
+    const to = path.join(VENDOR, rel);
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    fs.copyFileSync(from, to);
+    const same = fs.readFileSync(from).equals(fs.readFileSync(to));
+    if (!same) {
+      console.error(`predist: staged copy differs from source: ${rel}`);
+      process.exit(1);
+    }
+    staged.push(`${rel} -> vendor/${rel}`);
+  }
+
+  // Prove the staged tree stands on its own: the registry must load and
+  // resolve its own dependencies from inside vendor/, not from the repo.
+  const toolsPath = path.join(VENDOR, 'mcp', 'tools.js');
+  delete require.cache[require.resolve(toolsPath)];
+  const { createTools } = require(toolsPath);
+  const tools = createTools({
+    apiBase: 'http://127.0.0.1',
+    apiKey: 'predist-probe',
+    randomUUID: () => 'id',
+  });
+  const count = tools.toolList().length;
+  if (count === 0) {
+    console.error('predist: staged registry exposes no tools');
+    process.exit(1);
+  }
+
+  console.log(`predist: staged ${staged.length} shared modules into cli/vendor/`);
+  for (const s of staged) console.log(`  ${s}`);
+  console.log(`predist: staged registry loads standalone (${count} tools)`);
+}
+
+main();