@0xgeorgemathew/zcode 0.3.2 → 0.4.1

package/lib/commands/agent.js

@@ -1,203 +0,0 @@
-'use strict';
-// lib/commands/agent.js — subagent-dispatching turn, verified programmatically
-// (DESIGN §11): dispatch-forcing preamble, yolo run, then session/subagents
-// RPC joined with the scratch agents dir. Never trusts the model's prose;
-// exit 6 when no subagent ran or none ended "success".
-const fs = require('node:fs');
-const path = require('node:path');
-const { executeTurn, TurnError } = require('../appserver.js');
-const { bootstrap } = require('../bootstrap.js');
-
-function readJsonSafe(file) {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-// Join session/subagents ended items with <home>/.zcode/cli/agents/<parent>/
-// agent_<uuid>/{metadata.json,output.txt} (all under the scratch HOME we own).
-function collectSubagents({ client, sessionId, isolationHome, scrub }) {
-  return client
-    .request('session/subagents', { sessionId }, { timeoutMs: 15000 })
-    .catch((err) => {
-      throw new TurnError(`session/subagents failed: ${scrub(err.message)}`, {
-        kind: 'subagents_rpc',
-      });
-    })
-    .then((result) => {
-      const items = (result && result.ended && result.ended.items) || [];
-      const running = (result && result.running) || [];
-      const agentsDir = path.join(
-        isolationHome,
-        '.zcode',
-        'cli',
-        'agents',
-        sessionId
-      );
-      const out = [];
-      for (const item of items) {
-        const dir = path.join(agentsDir, `agent_${(item.agentId || '').replace(/^agent_/, '')}`);
-        const metadata =
-          readJsonSafe(path.join(dir, 'metadata.json')) || null;
-        let output = null;
-        try {
-          output = fs.readFileSync(path.join(dir, 'output.txt'), 'utf8');
-        } catch {
-          /* subagent may not have flushed output */
-        }
-        out.push({
-          agentId: item.agentId || (metadata && metadata.agentId) || null,
-          childSessionId:
-            item.childSessionId || (metadata && metadata.childSessionId) || null,
-          profileId: (metadata && metadata.profileId) || item.subagentType || null,
-          title: item.title || (metadata && metadata.description) || null,
-          status: item.status || null,
-          summary: item.summary || null,
-          output,
-          startedAt: item.startedAt || null,
-          endedAt: item.endedAt || null,
-          durationMs:
-            item.startedAt && item.endedAt ? item.endedAt - item.startedAt : null,
-        });
-      }
-      return { subagents: out, runningCount: running.length };
-    });
-}
-
-module.exports = async function agent(parsed) {
-  const flags = parsed.flags;
-  const instructions = parsed.prompts.join(' ');
-  if (!instructions.trim()) {
-    process.stderr.write('zcode: agent needs instructions.\n');
-    process.exit(2);
-  }
-  const profile = flags.profile || 'general-purpose';
-  const prompt =
-    `You MUST use the Agent tool (profileId: "${profile}") to accomplish the ` +
-    `task below — do not do the work yourself. When the subagent finishes, ` +
-    `report its agent id and result.\n\nTask: ${instructions}`;
-
-  const { client, scrub, isolation, overlay } = bootstrap({
-    fresh: flags.fresh,
-    mcpSpecs: flags.mcpSpecs,
-    mcpInherit: flags.mcpInherit,
-    skillsDirs: flags.skillsDirs,
-    noSkills: flags.noSkills,
-  });
-  client.start();
-  process.on('SIGINT', () => {
-    client.kill();
-    process.exit(130);
-  });
-  const reporter = require('../ui.js').makePlainReporter({ quiet: flags.quiet });
-  try {
-    const turn = await executeTurn(client, {
-      workspacePath: flags.cwd,
-      modelId: flags.model,
-      effort: flags.effort,
-      prompt,
-      timeoutMs: flags.timeoutMs,
-      resumeSessionId: flags.session || null,
-      requiredMcp: overlay.mcp.added,
-      onEvent: (ev) => {
-        if (flags.json) process.stdout.write(JSON.stringify(ev) + '\n');
-        else reporter.onEvent(ev);
-      },
-    });
-
-    const { subagents, runningCount } = await collectSubagents({
-      client,
-      sessionId: turn.sessionId,
-      isolationHome: isolation.home,
-      scrub,
-    });
-
-    const ok = subagents.length >= 1 && subagents.every((s) => s.status === 'success');
-
-    if (flags.json) {
-      process.stdout.write(
-        JSON.stringify({
-          type: 'result',
-          ok,
-          response: turn.response,
-          model: turn.engineModel || flags.model,
-          modelRequested: flags.model,
-          effort: turn.engineReasoningLevel || flags.effort,
-          effortRequested: flags.effort,
-          mode: turn.mode,
-          sessionId: turn.sessionId,
-          resumed: turn.resumed,
-          usage: turn.usage
-            ? {
-                inputTokens: turn.usage.inputTokens ?? null,
-                outputTokens: turn.usage.outputTokens ?? null,
-              }
-            : null,
-          reasoningChars: turn.reasoningText.length,
-          toolCalls: turn.toolCallCount,
-          mcpServers: Object.keys(overlay.mcp.servers),
-          skillsInjected: overlay.skills.injected,
-          subagents,
-          runningSubagents: runningCount,
-          durationMs: turn.durationMs,
-        }) + '\n'
-      );
-    } else if (!ok) {
-      process.stdout.write(turn.response + '\n');
-    } else {
-      process.stdout.write(turn.response + '\n');
-      reporter.footer({
-        model: turn.engineModel || flags.model,
-        effort: turn.engineReasoningLevel || flags.effort,
-        toolCalls: turn.toolCallCount,
-        durationMs: turn.durationMs,
-        sessionId: turn.sessionId,
-      });
-      for (const s of subagents) {
-        const secs = typeof s.durationMs === 'number' ? `  ${(s.durationMs / 1000).toFixed(1)}s` : '';
-        process.stderr.write(
-          (process.stderr.isTTY ? '\x1b[2m' : '') +
-            `✓ subagent ${s.profileId}${secs}` +
-            (process.stderr.isTTY ? '\x1b[0m' : '') + '\n'
-        );
-        if (s.summary) {
-          process.stderr.write(
-            (process.stderr.isTTY ? '\x1b[2m' : '') +
-              `  ${s.summary.replace(/\s+/g, ' ').trim().slice(0, 200)}` +
-              (process.stderr.isTTY ? '\x1b[0m' : '') + '\n'
-          );
-        }
-      }
-    }
-    client.kill();
-    if (!ok) {
-      const why =
-        subagents.length === 0
-          ? 'no subagent was dispatched'
-          : `subagent statuses: ${subagents.map((s) => s.status).join(', ')}`;
-      process.stderr.write(`zcode: agent verification failed: ${why}\n`);
-      process.exit(6);
-    }
-    process.exit(0);
-  } catch (err) {
-    client.kill();
-    if (flags.json) {
-      process.stdout.write(
-        JSON.stringify({
-          type: 'result',
-          ok: false,
-          error: err.kind || 'error',
-          message: scrub(err.message),
-        }) + '\n'
-      );
-    }
-    if (err instanceof TurnError && err.kind === 'timeout') {
-      process.stderr.write(`zcode: ${scrub(err.message)}\n`);
-      process.exit(124);
-    }
-    process.stderr.write(`zcode: agent turn failed: ${scrub(err.message)}\n`);
-    process.exit(5);
-  }
-}

package/lib/commands/run.js

@@ -1,126 +0,0 @@
-'use strict';
-// lib/commands/run.js — one-shot turn (DESIGN §9, §10), agent-first: NDJSON
-// stream on stdout with --json (incl. reasoning_delta = thinking and tool
-// lifecycle), reasoning mirrored to stderr live in plain mode, session
-// continuity via --session, MCP/skills overlays applied per run.
-const { executeTurn, TurnError } = require('../appserver.js');
-const { bootstrap } = require('../bootstrap.js');
-const { makePlainReporter } = require('../ui.js');
-
-// Prompt: positional argv joined, else stdin (when piped).
-function readPrompt(parsed) {
-  if (parsed.prompts.length > 0) return parsed.prompts.join(' ');
-  if (!process.stdin.isTTY) {
-    return require('node:fs').readFileSync(0, 'utf8');
-  }
-  return '';
-}
-
-module.exports = async function run(parsed) {
-  const flags = parsed.flags;
-  const prompt = readPrompt(parsed);
-  if (!prompt.trim()) {
-    process.stderr.write('zcode: no prompt given (positional args or stdin).\n');
-    process.exit(2);
-  }
-
-  const { client, scrub, overlay } = bootstrap({
-    fresh: flags.fresh,
-    mcpSpecs: flags.mcpSpecs,
-    mcpInherit: flags.mcpInherit,
-    skillsDirs: flags.skillsDirs,
-    noSkills: flags.noSkills,
-  });
-  const workspacePath = flags.cwd;
-  let streamedText = '';
-  const reporter = makePlainReporter({ quiet: flags.quiet });
-  const onEvent = flags.json
-    ? (ev) => process.stdout.write(JSON.stringify(ev) + '\n')
-    : (ev) => {
-        if (ev.type === 'stream' && ev.kind === 'text_delta' && ev.delta) {
-          reporter.closeThinking();
-          streamedText += ev.delta;
-          process.stdout.write(ev.delta);
-        } else {
-          reporter.onEvent(ev);
-        }
-      };
-
-  client.start();
-  process.on('SIGINT', () => {
-    client.kill();
-    process.exit(130);
-  });
-  try {
-    const turn = await executeTurn(client, {
-      workspacePath,
-      modelId: flags.model,
-      effort: flags.effort,
-      prompt,
-      timeoutMs: flags.timeoutMs,
-      resumeSessionId: flags.session || null,
-      requiredMcp: overlay.mcp.added,
-      onEvent,
-    });
-    if (flags.json) {
-      const result = {
-        type: 'result',
-        ok: true,
-        response: turn.response,
-        model: turn.engineModel || flags.model,
-        modelRequested: flags.model,
-        effort: turn.engineReasoningLevel || flags.effort,
-        effortRequested: flags.effort,
-        mode: turn.mode,
-        sessionId: turn.sessionId,
-        resumed: turn.resumed,
-        usage: turn.usage
-          ? {
-              inputTokens: turn.usage.inputTokens ?? null,
-              outputTokens: turn.usage.outputTokens ?? null,
-            }
-          : null,
-        reasoningChars: turn.reasoningText.length,
-        toolCalls: turn.toolCallCount,
-        toolEvents: turn.toolEvents,
-        mcpServers: Object.keys(overlay.mcp.servers),
-        skillsInjected: overlay.skills.injected,
-        terminalStatus: turn.terminalStatus,
-        streamingEvents: turn.streamingEvents,
-        durationMs: turn.durationMs,
-      };
-      if (flags.includeReasoning) result.reasoning = turn.reasoningText;
-      process.stdout.write(JSON.stringify(result) + '\n');
-    } else {
-      if (!streamedText.trim()) process.stdout.write(turn.response);
-      process.stdout.write('\n');
-      reporter.footer({
-        model: turn.engineModel || flags.model,
-        effort: turn.engineReasoningLevel || flags.effort,
-        toolCalls: turn.toolCallCount,
-        durationMs: turn.durationMs,
-        sessionId: turn.sessionId,
-      });
-    }
-    client.kill();
-    process.exit(0);
-  } catch (err) {
-    client.kill();
-    if (flags.json) {
-      process.stdout.write(
-        JSON.stringify({
-          type: 'result',
-          ok: false,
-          error: err.kind || 'error',
-          message: scrub(err.message),
-        }) + '\n'
-      );
-    }
-    if (err instanceof TurnError && err.kind === 'timeout') {
-      process.stderr.write(`zcode: ${scrub(err.message)}\n`);
-      process.exit(124);
-    }
-    process.stderr.write(`zcode: turn failed: ${scrub(err.message)}\n`);
-    process.exit(5);
-  }
-};

package/lib/overlay.js

@@ -1,138 +0,0 @@
-'use strict';
-// Per-run overlays on the scratch HOME (DESIGN §6 extension): MCP servers
-// and extra skills. Both are recomputed from read-only live sources plus the
-// caller's flags on EVERY run, so the scratch never leaks a previous run's
-// additions — the default state is always "what the desktop has".
-const fs = require('node:fs');
-const path = require('node:path');
-const { LIVE_ZCODE } = require('./isolation.js');
-
-// --- MCP ---------------------------------------------------------------------
-
-// Base servers: the live desktop config, read-only, honoring `enabled`.
-function liveMcpServers() {
-  try {
-    const cfg = JSON.parse(
-      fs.readFileSync(path.join(LIVE_ZCODE, 'cli', 'config.json'), 'utf8')
-    );
-    const servers = cfg && cfg.mcp && cfg.mcp.servers;
-    if (!servers || typeof servers !== 'object') return {};
-    const out = {};
-    for (const [name, def] of Object.entries(servers)) {
-      if (!def || typeof def !== 'object') continue;
-      if (def.enabled === false) continue;
-      out[name] = def;
-    }
-    return out;
-  } catch {
-    return {};
-  }
-}
-
-// Effective set for one run. Hermetic by default: ONLY the caller's --mcp
-// servers. --mcp-inherit pulls in the desktop's enabled servers as a base
-// (specs still win by name). Hermetic default is deliberate: the desktop
-// set includes OAuth servers that can never complete headless and stall
-// the engine's connect pool, starving later servers nondeterministically.
-function effectiveMcpServers({ inherit = false, mcpSpecs = [] } = {}) {
-  const servers = inherit ? liveMcpServers() : {};
-  for (const spec of mcpSpecs) {
-    for (const [name, def] of Object.entries(spec)) {
-      servers[name] = def;
-    }
-  }
-  return servers;
-}
-
-// Writes the effective set into the scratch cli config so the engine child
-// picks it up at session start. Creates a minimal config when the scratch
-// has none (fresh-machine synthesized path).
-function applyMcpOverlay({ home, inherit = false, mcpSpecs = [] }) {
-  const servers = effectiveMcpServers({ inherit, mcpSpecs });
-  // Names the caller explicitly added — the CLI waits for these to settle
-  // (connected or failed) before sending the prompt, so an explicit server
-  // is never lost to a slow stdio spawn. Inherited servers are best-effort.
-  const added = mcpSpecs.flatMap((spec) => Object.keys(spec));
-  const configPath = path.join(home, '.zcode', 'cli', 'config.json');
-  let cfg = {};
-  try {
-    cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    if (!cfg || typeof cfg !== 'object') cfg = {};
-  } catch {
-    cfg = {};
-  }
-  cfg.mcp = { ...(cfg.mcp || {}), servers };
-  fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
-  fs.chmodSync(configPath, 0o600);
-  return { servers, count: Object.keys(servers).length, added };
-}
-
-// --- skills ------------------------------------------------------------------
-
-const MANIFEST = 'injected-skills.json';
-
-function readManifest(rootDir) {
-  try {
-    const m = JSON.parse(fs.readFileSync(path.join(rootDir, MANIFEST), 'utf8'));
-    return Array.isArray(m.skills) ? m : { skills: [] };
-  } catch {
-    return { skills: [] };
-  }
-}
-
-// A --skills dir is either one skill (<dir>/SKILL.md) or a skills root
-// (<dir>/<name>/SKILL.md). Returns [{name, dir}] of copyable skills.
-function discoverSkillDirs(dir) {
-  const found = [];
-  if (fs.existsSync(path.join(dir, 'SKILL.md'))) {
-    found.push({ name: path.basename(path.resolve(dir)), dir });
-    return found;
-  }
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    if (fs.existsSync(path.join(dir, entry.name, 'SKILL.md'))) {
-      found.push({ name: entry.name, dir: path.join(dir, entry.name) });
-    }
-  }
-  return found;
-}
-
-// Removes skills injected by a previous run, copies this run's extras in,
-// records them in the manifest. --no-skills empties the scratch skills dir
-// entirely (per-run hermetic mode).
-function applySkillsOverlay({ rootDir, home, skillsDirs = [], noSkills = false }) {
-  const scratchSkills = path.join(home, '.zcode', 'skills');
-  const previous = readManifest(rootDir);
-  for (const name of previous.skills) {
-    fs.rmSync(path.join(scratchSkills, name), { recursive: true, force: true });
-  }
-
-  if (noSkills) {
-    fs.rmSync(scratchSkills, { recursive: true, force: true });
-    fs.mkdirSync(scratchSkills, { recursive: true });
-    fs.writeFileSync(
-      path.join(rootDir, MANIFEST),
-      JSON.stringify({ skills: [] }, null, 2) + '\n',
-      { mode: 0o600 }
-    );
-    return { injected: [] };
-  }
-
-  const injected = [];
-  for (const dir of skillsDirs) {
-    for (const { name, dir: skillDir } of discoverSkillDirs(dir)) {
-      fs.rmSync(path.join(scratchSkills, name), { recursive: true, force: true });
-      fs.cpSync(skillDir, path.join(scratchSkills, name), { recursive: true });
-      injected.push(name);
-    }
-  }
-  fs.writeFileSync(
-    path.join(rootDir, MANIFEST),
-    JSON.stringify({ skills: injected }, null, 2) + '\n',
-    { mode: 0o600 }
-  );
-  return { injected };
-}
-
-module.exports = { effectiveMcpServers, applyMcpOverlay, applySkillsOverlay, discoverSkillDirs };