@opencoven/coven-code 0.0.2 → 0.0.4

package/README.md

@@ -34,7 +34,7 @@ filtering and a details panel for commands, skills, and plugin actions.
 
 ```text
 $ coven-code
-Coven Code 0.0.2
+Coven Code 0.0.4
 /Users/example/project
 [chat]  lane   tools   threads   config   help    mode: smart   effort: high
 --------------------------------------------------------------------------------

package/docs/CLI.md

@@ -99,7 +99,7 @@ transcript, tabs, compact status line, command palette, slash-command menu, and
 composer. It keeps a current local thread and accepts slash commands:
 
 ```text
-Coven Code 0.0.2
+Coven Code 0.0.4
 [chat]  lane   tools   threads   config   help    mode: smart   effort: high
 --------------------------------------------------------------------------------
 Ready. Type a prompt or /help.

package/docs/DEMO.md

@@ -90,8 +90,11 @@ The menu accepts:
 | -------- | -------------------------------------------------------- |
 | `1`-`12` | run one section by number                                |
 | `a`      | run all sections in sequence, then print the scoreboard  |
+| `r`      | replay the last section you ran                          |
 | `t`      | type your own prompt and run one execute turn            |
 | `s`      | list the files the demo wrote into the sandbox HOME      |
+| `x`      | open a real subshell inside the sandbox (`exit` returns) |
+| `c`      | copy the sandbox path to your clipboard                  |
 | `l`      | re-print the section table of contents (with `✓` marks)  |
 | `?`      | show the menu help                                       |
 | `q`      | quit (sandbox path printed so you can clean up or poke around) |
@@ -144,7 +147,7 @@ rm -rf "$DEMO_HOME"   # the script prints the exact path at the end
 works without any account or API key.
 
 ```sh
-node ./bin/coven-code.mjs --version       # prints 0.0.2
+node ./bin/coven-code.mjs --version       # prints 0.0.4
 node ./bin/coven-code.mjs --help          # full option and command reference
 node ./bin/coven-code.mjs login           # printable instructions (no token yet)
 node ./bin/coven-code.mjs login status    # auth_status: logged_out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencoven/coven-code",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "repository": {
     "type": "git",

package/src/cli/execute.mjs

@@ -1,33 +1,24 @@
 import { randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
-import { BUILTIN_TOOLS } from '../constants.mjs';
 import { estimateUsage, fixtureAgentResponse } from '../agent/fixture.mjs';
-import {
-  listActiveMcpServerEntries,
-} from '../mcp/discover.mjs';
-import { discoverMcpToolRows } from '../mcp/probe.mjs';
 import {
   loadPlugins,
   runPluginEventHandlers,
 } from '../plugins/discover.mjs';
 import { discoverAgentFiles, firstGuidanceInDir } from '../commands/agents.mjs';
-import {
-  isToolDisabled,
-  listToolboxTools,
-  toolKindForName,
-} from '../tools/toolbox.mjs';
 import { executePromptToolRequest } from '../tools/builtin/index.mjs';
 import { toolResultContent } from '../tools/builtin/runtime.mjs';
 import { persistThreadMessages, threadContinuationPrompt } from '../threads/store.mjs';
 import { readEffectiveSettings } from '../settings/load.mjs';
 import { expandFileReferences, expandThreadReferences } from './refs.mjs';
 import { UsageError } from './parse.mjs';
-import { reasoningEffortForMode } from './reasoning.mjs';
 import { notifyAgentComplete } from './notifications.mjs';
 import { globToRegex } from '../util/glob.mjs';
-import { displayCwd, emitJson } from '../util/fs.mjs';
+import { emitJson } from '../util/fs.mjs';
 import {
+  emitStreamJsonInit,
+  emitStreamJsonTurn,
   streamJsonInputMessages,
   streamJsonOutputUserContent,
   streamJsonPermissionDenials,
@@ -60,83 +51,21 @@ export async function runExecute(parsed, stdin, options = {}) {
   const result = turns.at(-1)?.result ?? '';
 
   if (parsed.streamJson) {
-    const activeMcpServers = listActiveMcpServerEntries(parsed, turns.map((turn) => turn.prompt).join('\n\n'));
-    const tools = [
-      ...BUILTIN_TOOLS.map(([name]) => name),
-      ...listToolboxTools(parsed).map((tool) => tool.name),
-      ...plugins.tools.map((tool) => tool.name),
-      ...(await discoverMcpToolRows(activeMcpServers)).map(([name]) => name),
-    ].filter((name) => !isToolDisabled(name, toolKindForName(name), parsed));
-    emitJson({
-      type: 'system',
-      subtype: 'init',
-      cwd: displayCwd(),
-      session_id: sessionId,
-      tools,
-      mcp_servers: activeMcpServers.map(({ name }) => ({ name, status: 'connected' })),
-      agent_mode: parsed.mode,
-      reasoning_effort: reasoningEffortForMode(parsed.mode, parsed.reasoningEffort),
+    await emitStreamJsonInit({
+      parsed,
+      plugins,
+      sessionId,
+      promptForMcpDiscovery: turns.map((turn) => turn.prompt).join('\n\n'),
     });
     for (const turn of turns) {
-      emitJson({
-        type: 'user',
-        message: { role: 'user', content: [{ type: 'text', text: turn.prompt }] },
-        parent_tool_use_id: null,
-        session_id: sessionId,
-      });
-      if (turn.toolRun?.toolUse) {
-        emitJson({
-          type: 'assistant',
-          message: {
-            type: 'message',
-            role: 'assistant',
-            content: [turn.toolRun.toolUse],
-            stop_reason: 'tool_use',
-            usage: estimateUsage(turn.prompt, JSON.stringify(turn.toolRun.toolUse.input)),
-          },
-          parent_tool_use_id: null,
-          session_id: sessionId,
-        });
-        for (const subagentMessage of turn.toolRun.subagentMessages ?? []) {
-          emitJson({
-            type: 'assistant',
-            message: {
-              type: 'message',
-              role: 'assistant',
-              content: assistantStreamContent(subagentMessage.text ?? '', parsed),
-              stop_reason: 'end_turn',
-              usage: estimateUsage(turn.prompt, subagentMessage.text ?? ''),
-            },
-            parent_tool_use_id: turn.toolRun.toolUse.id,
-            session_id: sessionId,
-          });
-        }
-        emitJson({
-          type: 'user',
-          message: {
-            role: 'user',
-            content: [{
-              type: 'tool_result',
-              tool_use_id: turn.toolRun.toolUse.id,
-              content: toolResultContent(turn.toolRun),
-              is_error: turn.toolRun.exitCode !== 0,
-            }],
-          },
-          parent_tool_use_id: toolRunParent(turn.toolRun, 'toolResultParentToolUseId', null),
-          session_id: sessionId,
-        });
-      }
-      emitJson({
-        type: 'assistant',
-        message: {
-          type: 'message',
-          role: 'assistant',
-          content: assistantStreamContent(turn.result, parsed),
-          stop_reason: 'end_turn',
-          usage: estimateUsage(turn.prompt, turn.result),
-        },
-        parent_tool_use_id: turn.toolRun ? toolRunParent(turn.toolRun, 'finalParentToolUseId', null) : null,
-        session_id: sessionId,
+      emitStreamJsonTurn({
+        userContent: [{ type: 'text', text: turn.prompt }],
+        promptText: turn.prompt,
+        toolRun: turn.toolRun,
+        result: turn.result,
+        parsed,
+        sessionId,
+        assistantParentToolUseId: turn.toolRun ? toolRunParent(turn.toolRun, 'finalParentToolUseId', null) : null,
       });
     }
     emitJson(streamJsonResultMessage({
@@ -312,22 +241,11 @@ async function runStreamJsonInputExecute(parsed, stdin, options = {}, started =
   const combinedPrompt = inputMessages.map((message) => message.text).filter(Boolean).join('\n\n');
   const plugins = await loadPlugins(process.cwd());
   await runSessionStartHandlers(plugins, sessionId);
-  const activeMcpServers = listActiveMcpServerEntries(parsed, combinedPrompt);
-  const tools = [
-    ...BUILTIN_TOOLS.map(([name]) => name),
-    ...listToolboxTools(parsed).map((tool) => tool.name),
-    ...plugins.tools.map((tool) => tool.name),
-    ...(await discoverMcpToolRows(activeMcpServers)).map(([name]) => name),
-  ].filter((name) => !isToolDisabled(name, toolKindForName(name), parsed));
-  emitJson({
-    type: 'system',
-    subtype: 'init',
-    cwd: displayCwd(),
-    session_id: sessionId,
-    tools,
-    mcp_servers: activeMcpServers.map(({ name }) => ({ name, status: 'connected' })),
-    agent_mode: parsed.mode,
-    reasoning_effort: reasoningEffortForMode(parsed.mode, parsed.reasoningEffort),
+  await emitStreamJsonInit({
+    parsed,
+    plugins,
+    sessionId,
+    promptForMcpDiscovery: combinedPrompt,
   });
 
   const transcript = [];
@@ -356,67 +274,18 @@ async function runStreamJsonInputExecute(parsed, stdin, options = {}, started =
     if (toolRun?.permissionDenials) permissionDenials.push(...toolRun.permissionDenials);
     if ((toolRun?.exitCode ?? 0) !== 0) isError = true;
 
-    emitJson({
-      type: 'user',
-      ...(input.steer ? { steer: true } : {}),
-      message: { role: 'user', content: streamJsonOutputUserContent(input.content) },
-      parent_tool_use_id: null,
-      session_id: sessionId,
-    });
     if (toolRun?.toolUse) {
-      emitJson({
-        type: 'assistant',
-        message: {
-          type: 'message',
-          role: 'assistant',
-          content: [toolRun.toolUse],
-          stop_reason: 'tool_use',
-          usage: estimateUsage(input.text, JSON.stringify(toolRun.toolUse.input)),
-        },
-        parent_tool_use_id: null,
-        session_id: sessionId,
-      });
-      for (const subagentMessage of toolRun.subagentMessages ?? []) {
-        emitJson({
-          type: 'assistant',
-          message: {
-            type: 'message',
-            role: 'assistant',
-            content: assistantStreamContent(subagentMessage.text ?? '', parsed),
-            stop_reason: 'end_turn',
-            usage: estimateUsage(input.text, subagentMessage.text ?? ''),
-          },
-          parent_tool_use_id: toolRun.toolUse.id,
-          session_id: sessionId,
-        });
-      }
-      emitJson({
-        type: 'user',
-        message: {
-          role: 'user',
-          content: [{
-            type: 'tool_result',
-            tool_use_id: toolRun.toolUse.id,
-            content: toolResultContent(toolRun),
-            is_error: toolRun.exitCode !== 0,
-          }],
-        },
-        parent_tool_use_id: toolRunParent(toolRun, 'toolResultParentToolUseId', null),
-        session_id: sessionId,
-      });
       parentToolUseId = toolRunParent(toolRun, 'finalParentToolUseId', null);
     }
-    emitJson({
-      type: 'assistant',
-      message: {
-        type: 'message',
-        role: 'assistant',
-        content: assistantStreamContent(result, parsed),
-        stop_reason: 'end_turn',
-        usage: estimateUsage(input.text, result),
-      },
-      parent_tool_use_id: parentToolUseId,
-      session_id: sessionId,
+    emitStreamJsonTurn({
+      userContent: streamJsonOutputUserContent(input.content),
+      steer: input.steer,
+      promptText: input.text,
+      toolRun,
+      result,
+      parsed,
+      sessionId,
+      assistantParentToolUseId: parentToolUseId,
     });
     await runPluginEventHandlers(plugins.handlers['agent.end'], {
       message: input.text,
@@ -453,13 +322,6 @@ async function runSessionStartHandlers(plugins, sessionId) {
   });
 }
 
-function assistantStreamContent(result, parsed = {}) {
-  if (parsed.streamJsonThinking && readEffectiveSettings(parsed)['covenCode.thinking.enabled'] !== false) {
-    return [{ type: 'thinking', thinking: 'Using the local deterministic recreation.' }, { type: 'text', text: result }];
-  }
-  return [{ type: 'text', text: result }];
-}
-
 function modelPromptWithTranscript(turnPrompt, transcript, thread, parsed = {}) {
   const context = transcript.length > 0
     ? `[conversation:${thread?.id ?? 'stream-json-input'}]\n${transcript

package/src/cli/slash-commands.mjs

@@ -163,8 +163,8 @@ export async function buildSlashCommandCatalog(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const entries = [
       ...buildStaticSlashCommandCatalog(),
-      ...skillSlashCommands(parsed, cwd),
-      ...await pluginSlashCommands(cwd),
+      ...safeSkillSlashCommands(parsed, cwd),
+      ...await safePluginSlashCommands(cwd),
     ];
     return normalizeCatalog(entries);
   } finally {
@@ -262,6 +262,24 @@ async function pluginSlashCommands(cwd) {
     }));
 }
 
+function safeSkillSlashCommands(parsed, cwd) {
+  try {
+    return skillSlashCommands(parsed, cwd);
+  } catch (error) {
+    console.error(`${CLI_NAME}: skill catalog unavailable: ${error?.message ?? error}`);
+    return [];
+  }
+}
+
+async function safePluginSlashCommands(cwd) {
+  try {
+    return await pluginSlashCommands(cwd);
+  } catch (error) {
+    console.error(`${CLI_NAME}: plugin catalog unavailable: ${error?.message ?? error}`);
+    return [];
+  }
+}
+
 function normalizeCatalog(entries) {
   const seen = new Set();
   const catalog = [];

package/src/cli/stream-json.mjs

@@ -1,6 +1,15 @@
 import { fileURLToPath } from 'node:url';
+import { BUILTIN_TOOLS } from '../constants.mjs';
+import { estimateUsage } from '../agent/fixture.mjs';
+import { listActiveMcpServerEntries } from '../mcp/discover.mjs';
+import { discoverMcpToolRows } from '../mcp/probe.mjs';
+import { readEffectiveSettings } from '../settings/load.mjs';
+import { isToolDisabled, listToolboxTools, toolKindForName } from '../tools/toolbox.mjs';
+import { toolResultContent } from '../tools/builtin/runtime.mjs';
 import { detectImageMediaType, imageMediaTypeExtension } from '../util/media.mjs';
+import { displayCwd, emitJson } from '../util/fs.mjs';
 import { UsageError } from './parse.mjs';
+import { reasoningEffortForMode } from './reasoning.mjs';
 import { imageMentionBlock } from './refs.mjs';
 
 export function streamJsonInputMessages(prompt, stdin) {
@@ -90,6 +99,106 @@ export function streamJsonPermissionDenials(denials = []) {
   });
 }
 
+export function assistantStreamContent(result, parsed = {}) {
+  if (parsed.streamJsonThinking && readEffectiveSettings(parsed)['covenCode.thinking.enabled'] !== false) {
+    return [{ type: 'thinking', thinking: 'Using the local deterministic recreation.' }, { type: 'text', text: result }];
+  }
+  return [{ type: 'text', text: result }];
+}
+
+export async function emitStreamJsonInit({ parsed, plugins, sessionId, promptForMcpDiscovery }) {
+  const activeMcpServers = listActiveMcpServerEntries(parsed, promptForMcpDiscovery);
+  const tools = [
+    ...BUILTIN_TOOLS.map(([name]) => name),
+    ...listToolboxTools(parsed).map((tool) => tool.name),
+    ...plugins.tools.map((tool) => tool.name),
+    ...(await discoverMcpToolRows(activeMcpServers)).map(([name]) => name),
+  ].filter((name) => !isToolDisabled(name, toolKindForName(name), parsed));
+  emitJson({
+    type: 'system',
+    subtype: 'init',
+    cwd: displayCwd(),
+    session_id: sessionId,
+    tools,
+    mcp_servers: activeMcpServers.map(({ name }) => ({ name, status: 'connected' })),
+    agent_mode: parsed.mode,
+    reasoning_effort: reasoningEffortForMode(parsed.mode, parsed.reasoningEffort),
+  });
+}
+
+export function emitStreamJsonTurn({
+  userContent,
+  steer = false,
+  promptText,
+  toolRun,
+  result,
+  parsed,
+  sessionId,
+  assistantParentToolUseId,
+}) {
+  emitJson({
+    type: 'user',
+    ...(steer ? { steer: true } : {}),
+    message: { role: 'user', content: userContent },
+    parent_tool_use_id: null,
+    session_id: sessionId,
+  });
+  if (toolRun?.toolUse) {
+    emitJson({
+      type: 'assistant',
+      message: {
+        type: 'message',
+        role: 'assistant',
+        content: [toolRun.toolUse],
+        stop_reason: 'tool_use',
+        usage: estimateUsage(promptText, JSON.stringify(toolRun.toolUse.input)),
+      },
+      parent_tool_use_id: null,
+      session_id: sessionId,
+    });
+    for (const subagentMessage of toolRun.subagentMessages ?? []) {
+      emitJson({
+        type: 'assistant',
+        message: {
+          type: 'message',
+          role: 'assistant',
+          content: assistantStreamContent(subagentMessage.text ?? '', parsed),
+          stop_reason: 'end_turn',
+          usage: estimateUsage(promptText, subagentMessage.text ?? ''),
+        },
+        parent_tool_use_id: toolRun.toolUse.id,
+        session_id: sessionId,
+      });
+    }
+    emitJson({
+      type: 'user',
+      message: {
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: toolRun.toolUse.id,
+          content: toolResultContent(toolRun),
+          is_error: toolRun.exitCode !== 0,
+        }],
+      },
+      parent_tool_use_id: toolRunParent(toolRun, 'toolResultParentToolUseId', null),
+      session_id: sessionId,
+    });
+  }
+  emitJson({
+    type: 'assistant',
+    message: {
+      type: 'message',
+      role: 'assistant',
+      content: assistantStreamContent(result, parsed),
+      stop_reason: 'end_turn',
+      usage: estimateUsage(promptText, result),
+    },
+    parent_tool_use_id: assistantParentToolUseId,
+    session_id: sessionId,
+  });
+}
+
 export function streamJsonResultMessage({ started, isError, errorSubtype, numTurns, result, sessionId, usage, permissionDenials }) {
   const common = {
     type: 'result',