@opencoven/coven-code 0.0.4 → 0.0.6

package/src/cli/slash-commands.mjs

@@ -1,375 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { BUILTIN_TOOLS, CLI_NAME } from '../constants.mjs';
-import { listSkills } from '../skills/discover.mjs';
-import { loadPlugins } from '../plugins/discover.mjs';
-
-const STATIC_COMMANDS = [
-  {
-    name: 'help',
-    command: '/help',
-    title: 'Help',
-    category: 'session',
-    source: 'built-in',
-    usage: '/help',
-    description: 'Show slash commands and keybindings',
-  },
-  {
-    name: 'mode',
-    command: '/mode',
-    title: 'Mode',
-    category: 'session',
-    source: 'built-in',
-    usage: '/mode [name]',
-    description: 'show or set mode: smart, deep, rush, large',
-  },
-  {
-    name: 'reasoning',
-    command: '/reasoning',
-    title: 'Reasoning effort',
-    category: 'session',
-    source: 'built-in',
-    usage: '/reasoning [level|next]',
-    description: 'Show, set, or cycle reasoning effort',
-  },
-  {
-    name: 'new',
-    command: '/new',
-    title: 'New thread',
-    category: 'thread',
-    source: 'built-in',
-    usage: '/new',
-    description: 'Start a fresh thread',
-  },
-  {
-    name: 'continue',
-    command: '/continue',
-    title: 'Continue thread',
-    category: 'thread',
-    source: 'built-in',
-    usage: '/continue [thread-id]',
-    description: 'Continue the latest active thread or a specific thread',
-  },
-  {
-    name: 'queue',
-    command: '/queue',
-    title: 'Queue prompt',
-    category: 'thread',
-    source: 'built-in',
-    usage: '/queue <prompt>',
-    description: 'Send a follow-up prompt after the next turn',
-  },
-  {
-    name: 'lane',
-    command: '/lane',
-    title: 'Lane panel',
-    category: 'lane',
-    source: 'built-in',
-    usage: '/lane refresh | /lane verify | /lane status | /lane diff | /lane harness <name|next>',
-    description: 'TUI lane actions for worktree, harness, diff, and verification state',
-  },
-  {
-    name: 'editor',
-    command: '/editor',
-    title: 'Open editor',
-    category: 'composer',
-    source: 'built-in',
-    usage: '/editor',
-    aliases: ['Ctrl+G'],
-    description: 'compose the next prompt in $EDITOR',
-  },
-  {
-    name: 'edit',
-    command: '/edit',
-    title: 'Edit previous prompt',
-    category: 'composer',
-    source: 'built-in',
-    usage: '/edit',
-    description: 'Edit the previous prompt in $EDITOR',
-  },
-  {
-    name: 'exit',
-    command: '/exit',
-    title: 'Exit',
-    category: 'session',
-    source: 'built-in',
-    usage: '/exit',
-    aliases: ['/quit'],
-    description: 'Leave the interactive session',
-  },
-  {
-    name: `${CLI_NAME}:`,
-    command: `/${CLI_NAME}: help`,
-    title: 'Command palette help',
-    category: 'session',
-    source: 'built-in',
-    usage: `/${CLI_NAME}: help`,
-    description: 'Show command-palette help',
-  },
-  {
-    name: 'thread:',
-    command: '/thread:',
-    title: 'Thread actions',
-    category: 'thread',
-    source: 'built-in',
-    usage: '/thread: archive and quit | /thread: set visibility <level>',
-    description: 'Archive or update the current thread',
-  },
-  {
-    name: 'feedback:',
-    command: '/feedback:',
-    title: 'Feedback report',
-    category: 'diagnostics',
-    source: 'built-in',
-    usage: '/feedback: send report with diagnostics',
-    description: 'Create a diagnostic report for the current thread',
-  },
-];
-
-const TOP_LEVEL_COMMANDS = [
-  ['tools', 'Tools', 'Inspect and manage built-in and toolbox tools', '/tools [list|show|make|use]'],
-  ['skill:', 'Skills', 'List or inspect installed skills', '/skill: list | /skill: show <name>'],
-  ['plugins:', 'Plugins', 'List, reload, or inspect plugin commands', '/plugins: list | /plugins: reload | /plugins: commands'],
-  ['threads', 'Threads', 'List, show, search, archive, or map local threads', '/threads [list|show|search|archive|visibility|map|report]'],
-  ['permissions', 'Permissions', 'Inspect or test permission policy rules', '/permissions list'],
-  ['config', 'Config', 'Open user or workspace settings', '/config edit [--workspace]'],
-  ['mcp', 'MCP', 'Manage MCP server settings', '/mcp [add|list|doctor|approve|oauth]'],
-  ['ide', 'IDE', 'Connect or inspect local IDE integration', '/ide connect'],
-  ['agents', 'Agents guidance', 'Show AGENTS.md guidance files used for this cwd', '/agents list'],
-  ['review', 'Review', 'Run configured local review checks', '/review'],
-  ['usage', 'Usage', 'Show local usage estimates', '/usage'],
-  ['login', 'Login', 'Print local login instructions', '/login'],
-  ['update', 'Update', 'Check for updates', '/update'],
-];
-
-export function buildStaticSlashCommandCatalog() {
-  return normalizeCatalog([
-    ...STATIC_COMMANDS,
-    ...TOP_LEVEL_COMMANDS.map(([name, title, description, usage]) => ({
-      name,
-      command: `/${name}`,
-      title,
-      category: 'command',
-      source: 'top-level',
-      usage,
-      description,
-    })),
-  ]);
-}
-
-export async function buildSlashCommandCatalog(options = {}) {
-  const restoreEnv = applyTemporaryEnv(options.env);
-  try {
-    const parsed = options.parsed ?? {};
-    const cwd = options.cwd ?? process.cwd();
-    const entries = [
-      ...buildStaticSlashCommandCatalog(),
-      ...safeSkillSlashCommands(parsed, cwd),
-      ...await safePluginSlashCommands(cwd),
-    ];
-    return normalizeCatalog(entries);
-  } finally {
-    restoreEnv();
-  }
-}
-
-export function filterSlashCommands(catalog = [], input = '') {
-  const query = slashQuery(input);
-  const entries = query
-    ? catalog.filter((entry) => slashSearchText(entry).includes(query))
-    : catalog;
-  return entries
-    .map((entry, index) => ({ entry, score: slashScore(entry, query, index) }))
-    .sort((a, b) => a.score - b.score)
-    .map(({ entry }) => entry);
-}
-
-export function formatSlashCommandDetails(entry) {
-  if (!entry) return ['No command selected.'];
-  const lines = [
-    `${entry.command}  ${entry.title}`,
-    `Category: ${entry.category}`,
-    `Source: ${entry.source}`,
-    `Usage: ${entry.usage ?? entry.command}`,
-    `Status: ${formatAvailability(entry.availability)}`,
-  ];
-  if (entry.aliases?.length) lines.push(`Aliases: ${entry.aliases.join(', ')}`);
-  if (entry.filePath) lines.push(`File: ${entry.filePath}`);
-  if (entry.description) lines.push('', entry.description);
-  return lines;
-}
-
-export function formatSlashHelpLines(catalog = buildStaticSlashCommandCatalog()) {
-  const visible = catalog.filter((entry) => entry.availability?.type !== 'hidden');
-  const commandLines = visible.map((entry) => {
-    const usage = entry.usage ?? entry.command;
-    const status = entry.availability?.type === 'disabled' ? ` (${entry.availability.reason})` : '';
-    return `  ${usage.padEnd(28)} ${entry.description}${status}`;
-  });
-  return [
-    'Slash commands:',
-    ...commandLines,
-    'End a line with `\\` to continue the prompt onto the next line.',
-    'Anything else is sent as a one-turn prompt.',
-    '',
-    'Keybindings:',
-    '  /                     open slash commands',
-    '  Tab                   complete the selected slash command',
-    '  Up/Down               move through slash commands or previous messages',
-    '  Esc                   close overlays',
-    '  Ctrl+P                open the command palette',
-    '  Ctrl+N                start a fresh thread',
-    '  Ctrl+M                switch agent modes',
-    '  Ctrl+R                search prompt history',
-    '  Ctrl+G                open the current prompt in $EDITOR',
-    '  Alt+D                 cycle reasoning effort for the active mode',
-    '  @                     mention files',
-  ];
-}
-
-export function findSlashCommand(catalog = [], name) {
-  const normalized = slashQuery(name);
-  return catalog.find((entry) => slashQuery(entry.name) === normalized);
-}
-
-function skillSlashCommands(parsed, cwd) {
-  return listSkills({ parsed, cwd }).map((skill) => ({
-    name: skill.name,
-    command: `/${skill.name}`,
-    title: skill.name,
-    category: 'skill',
-    source: 'skill',
-    usage: `/${skill.name} [prompt]`,
-    description: skill.description || 'Skill command',
-    filePath: skill.filePath,
-    skill,
-  }));
-}
-
-async function pluginSlashCommands(cwd) {
-  const runtime = await loadPlugins(cwd);
-  return runtime.commands
-    .filter((command) => command.availability.type !== 'hidden')
-    .map((command) => ({
-      name: command.name,
-      command: `/${command.name}`,
-      title: command.metadata.title ?? command.name,
-      category: command.metadata.category ?? 'plugin',
-      source: 'plugin',
-      usage: `/${command.name}`,
-      description: command.metadata.description ?? command.metadata.title ?? command.name,
-      availability: command.availability,
-      pluginCommand: command,
-    }));
-}
-
-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 = [];
-  for (const entry of entries) {
-    const normalized = {
-      availability: { type: 'enabled' },
-      aliases: [],
-      ...entry,
-    };
-    const key = slashQuery(normalized.name);
-    if (!key || seen.has(key)) continue;
-    seen.add(key);
-    catalog.push(normalized);
-  }
-  return catalog;
-}
-
-function slashQuery(input = '') {
-  return String(input)
-    .trim()
-    .replace(/^\/+/, '')
-    .toLowerCase();
-}
-
-function slashSearchText(entry) {
-  return [
-    entry.name,
-    entry.command,
-    entry.title,
-    entry.category,
-    entry.source,
-    entry.description,
-    ...(entry.aliases ?? []),
-  ].join(' ').toLowerCase();
-}
-
-function slashScore(entry, query, index) {
-  if (!query) return index;
-  const name = slashQuery(entry.name);
-  if (name === query) return index - 10_000;
-  if (name.startsWith(query)) return index - 1_000;
-  if (slashQuery(entry.command).startsWith(query)) return index - 500;
-  return index;
-}
-
-function formatAvailability(availability = { type: 'enabled' }) {
-  if (availability.type === 'disabled') return `disabled - ${availability.reason}`;
-  return availability.type ?? 'enabled';
-}
-
-function applyTemporaryEnv(env) {
-  if (!env) return () => {};
-  const previous = new Map();
-  for (const [key, value] of Object.entries(env)) {
-    previous.set(key, Object.hasOwn(process.env, key) ? process.env[key] : undefined);
-    if (value === undefined) delete process.env[key];
-    else process.env[key] = String(value);
-  }
-  return () => {
-    for (const [key, value] of previous) {
-      if (value === undefined) delete process.env[key];
-      else process.env[key] = value;
-    }
-  };
-}
-
-export function skillPromptFromSlashCommand(entry, prompt) {
-  const skillText = entry?.filePath ? readSkillText(entry.filePath) : '';
-  return [
-    `[skill:${entry.name}]`,
-    skillText.trim(),
-    '[/skill]',
-    '',
-    '[prompt]',
-    prompt.trim(),
-    '[/prompt]',
-  ].join('\n');
-}
-
-function readSkillText(filePath) {
-  try {
-    return readFileSync(filePath, 'utf8');
-  } catch {
-    return '';
-  }
-}
-
-export function builtinToolSummaryLines(limit = 12) {
-  return [
-    `Built-in tools: ${BUILTIN_TOOLS.length}`,
-    ...BUILTIN_TOOLS.slice(0, limit).map(([name, kind, description]) => `${name} (${kind}) - ${description}`),
-  ];
-}

package/src/cli/stream-json.mjs

@@ -1,225 +0,0 @@
-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) {
-  const messages = [];
-  let generatedImageIndex = 0;
-  if (prompt) {
-    messages.push({
-      content: [{ type: 'text', text: prompt }],
-      text: prompt,
-      steer: false,
-    });
-  }
-  for (const [index, line] of stdin.split(/\r?\n/).entries()) {
-    if (!line.trim()) continue;
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      throw new UsageError(`stream-json-input line ${index + 1} is not valid JSON`);
-    }
-    if (event.type !== 'user') continue;
-    const content = Array.isArray(event.message?.content) ? event.message.content : [];
-    messages.push({
-      content,
-      text: content
-        .map((block) => streamJsonContentBlockText(block, () => {
-          generatedImageIndex += 1;
-          return generatedImageIndex;
-        }))
-        .filter(Boolean)
-        .join('\n'),
-      steer: event.steer === true,
-    });
-  }
-  if (messages.length === 0) {
-    messages.push({ content: [{ type: 'text', text: '' }], text: '', steer: false });
-  }
-  return messages;
-}
-
-function streamJsonContentBlockText(block, nextGeneratedImageIndex = () => 1) {
-  if (block.type === 'text') return block.text;
-  if (block.type !== 'image') return undefined;
-  const base64Image = validateStreamJsonBase64Image(block.source);
-  if (block.source_path) {
-    const filePath = block.source_path.startsWith('file://')
-      ? fileURLToPath(block.source_path)
-      : block.source_path;
-    return imageMentionBlock(filePath);
-  }
-  if (base64Image) {
-    const sourcePath = `stream-json-input-image-${nextGeneratedImageIndex()}.${imageMediaTypeExtension(base64Image.mediaType)}`;
-    return `[image:${sourcePath}]\nmedia_type: ${base64Image.mediaType}\nbytes: ${base64Image.bytes}\n[/image]`;
-  }
-  return undefined;
-}
-
-function validateStreamJsonBase64Image(source) {
-  if (source?.type !== 'base64' || !source.media_type || !source.data) return undefined;
-  const raw = Buffer.from(source.data, 'base64');
-  const detected = detectImageMediaType(raw);
-  if (detected && detected !== source.media_type) {
-    throw new UsageError(`stream-json-input image media_type ${source.media_type} does not match decoded ${detected}`);
-  }
-  if (!detected) throw new UsageError(`stream-json-input image media_type ${source.media_type} is not supported by decoded image data`);
-  return { mediaType: source.media_type, bytes: raw.byteLength };
-}
-
-export function streamJsonOutputUserContent(content = []) {
-  const textBlocks = content.filter((block) => block.type === 'text');
-  return textBlocks.length > 0 ? textBlocks : [{ type: 'text', text: '' }];
-}
-
-export function toolRunParent(toolRun, field, fallback) {
-  return Object.hasOwn(toolRun, field) ? toolRun[field] : fallback;
-}
-
-export function streamJsonTurnCount(turns = []) {
-  return turns.reduce((count, turn) => count + (turn.toolRun?.toolUse ? 2 : 1), 0);
-}
-
-export function streamJsonPermissionDenials(denials = []) {
-  return denials.map((denial) => {
-    if (typeof denial === 'string') return denial;
-    const reason = denial.reason ? ` (${denial.reason})` : '';
-    return `${denial.tool}: ${denial.action}${reason}`;
-  });
-}
-
-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',
-    duration_ms: Date.now() - started,
-    num_turns: numTurns,
-    session_id: sessionId,
-    usage,
-    permission_denials: permissionDenials,
-  };
-  if (isError) {
-    return {
-      ...common,
-      subtype: errorSubtype ?? 'error_during_execution',
-      is_error: true,
-      error: result,
-    };
-  }
-  return {
-    ...common,
-    subtype: 'success',
-    is_error: false,
-    result,
-  };
-}

package/src/cli/tui-actions.mjs

@@ -1,72 +0,0 @@
-import {
-  buildSlashCommandCatalog,
-  buildStaticSlashCommandCatalog,
-  filterSlashCommands,
-} from './slash-commands.mjs';
-import { currentSlashMatches } from './tui-render.mjs';
-import { submitTuiText } from './tui-submit.mjs';
-
-export function insertComposerText(model, text) {
-  model.composer = `${model.composer.slice(0, model.composerCursor)}${text}${model.composer.slice(model.composerCursor)}`;
-  model.composerCursor += text.length;
-  updateSlashState(model);
-}
-
-export function deleteComposerText(model, kind) {
-  if (kind === 'delete') {
-    if (model.composerCursor >= model.composer.length) return;
-    model.composer = `${model.composer.slice(0, model.composerCursor)}${model.composer.slice(model.composerCursor + 1)}`;
-  } else {
-    if (model.composerCursor <= 0) return;
-    model.composer = `${model.composer.slice(0, model.composerCursor - 1)}${model.composer.slice(model.composerCursor)}`;
-    model.composerCursor -= 1;
-  }
-  updateSlashState(model);
-}
-
-export function updateSlashState(model) {
-  const beforeCursor = model.composer.slice(0, model.composerCursor);
-  const active = beforeCursor.startsWith('/') && !/\s/.test(beforeCursor.slice(1));
-  if (!active) {
-    closeSlashMenu(model);
-    return;
-  }
-  model.slashOpen = true;
-  model.slashQuery = beforeCursor.replace(/^\/+/, '');
-  model.slashMatches = filterSlashCommands(model.slashCatalog, beforeCursor);
-  if (model.slashMatches.length === 0) model.slashIndex = 0;
-  else model.slashIndex = Math.min(model.slashIndex, model.slashMatches.length - 1);
-}
-
-export function closeSlashMenu(model) {
-  model.slashOpen = false;
-  model.slashQuery = '';
-  model.slashMatches = filterSlashCommands(model.slashCatalog, '');
-  model.slashIndex = 0;
-}
-
-export function completeSlashSelection(model) {
-  const selected = currentSlashMatches(model)[model.slashIndex];
-  if (!selected) return;
-  model.composer = `${selected.command} `;
-  model.composerCursor = model.composer.length;
-  closeSlashMenu(model);
-}
-
-export async function acceptSlashSelection(model, session) {
-  const selected = currentSlashMatches(model)[model.slashIndex];
-  if (!selected) return;
-  const command = selected.command;
-  model.composer = '';
-  model.composerCursor = 0;
-  closeSlashMenu(model);
-  await submitTuiText(model, session, command);
-}
-
-export async function safeBuildSlashCommandCatalog(parsed) {
-  try {
-    return await buildSlashCommandCatalog({ parsed, cwd: process.cwd() });
-  } catch {
-    return buildStaticSlashCommandCatalog();
-  }
-}