@opencoven/coven-code 0.0.3 → 0.0.6

package/src/commands/permissions-rules.mjs

@@ -1,53 +0,0 @@
-import { BUILTIN_PERMISSIONS } from '../constants.mjs';
-import { readEffectiveSettings } from '../settings/load.mjs';
-
-export const PERMISSIONS_SETTING = 'covenCode.permissions';
-export const COMMAND_ALLOWLIST_SETTING = 'covenCode.commands.allowlist';
-export const DANGEROUSLY_ALLOW_ALL_SETTING = 'covenCode.dangerouslyAllowAll';
-export const GUARDED_FILES_ALLOWLIST_SETTING = 'covenCode.guardedFiles.allowlist';
-
-export const UNDEFINED_MATCH_VALUE = Object.freeze({ __covenCodeLiteral: 'undefined' });
-
-export function isUndefinedMatchValue(value) {
-  return Boolean(
-    value
-      && typeof value === 'object'
-      && !Array.isArray(value)
-      && value.__covenCodeLiteral === 'undefined'
-      && Object.keys(value).length === 1,
-  );
-}
-
-export function loadUserPermissionRules(parsed = {}) {
-  const settings = readEffectiveSettings(parsed);
-  return Array.isArray(settings[PERMISSIONS_SETTING]) ? settings[PERMISSIONS_SETTING] : [];
-}
-
-export function builtinPermissionRules() {
-  return BUILTIN_PERMISSIONS.map(([action, builtinTool, cmd]) => ({
-    action,
-    tool: builtinTool,
-    matches: builtinTool === 'Bash' ? { cmd: `${cmd}*` } : undefined,
-  }));
-}
-
-export function commandAllowlistPermissionRules(parsed = {}) {
-  const allowlist = readEffectiveSettings(parsed)[COMMAND_ALLOWLIST_SETTING];
-  if (!Array.isArray(allowlist)) return [];
-  return allowlist
-    .map((command) => String(command).trim())
-    .filter(Boolean)
-    .map((command) => ({
-      action: 'allow',
-      tool: 'Bash',
-      matches: { cmd: commandAllowlistPattern(command) },
-    }));
-}
-
-function commandAllowlistPattern(command) {
-  return `/^${escapeRegex(command)}(?:\\s|$).*/`;
-}
-
-function escapeRegex(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/src/commands/permissions-text.mjs

@@ -1,112 +0,0 @@
-import { UsageError } from '../cli/parse.mjs';
-import { shellQuote, splitShellWords } from '../util/shell.mjs';
-import { UNDEFINED_MATCH_VALUE, isUndefinedMatchValue } from './permissions-rules.mjs';
-
-export function formatPermissionRule(rule) {
-  const parts = [rule.action];
-  for (const key of ['context', 'to', 'message']) {
-    if (rule[key] !== undefined) parts.push(`--${key}`, formatPermissionToken(rule[key]));
-  }
-  parts.push(formatPermissionToken(rule.tool));
-  for (const [key, value] of flattenMatches(rule.matches)) {
-    parts.push(`--${key}`, formatPermissionToken(value));
-  }
-  return parts.join(' ');
-}
-
-function flattenMatches(matches, prefix = '') {
-  if (!matches) return [];
-  const entries = [];
-  for (const [key, value] of Object.entries(matches)) {
-    const fullKey = prefix ? `${prefix}.${key}` : key;
-    if (Array.isArray(value)) {
-      for (const entry of value) entries.push(...flattenMatchValue(fullKey, entry));
-    } else {
-      entries.push(...flattenMatchValue(fullKey, value));
-    }
-  }
-  return entries;
-}
-
-function flattenMatchValue(key, value) {
-  if (isUndefinedMatchValue(value)) return [[key, value]];
-  if (value && typeof value === 'object' && !Array.isArray(value)) return flattenMatches(value, key);
-  return [[key, value]];
-}
-
-function formatPermissionToken(value) {
-  if (isUndefinedMatchValue(value)) return 'undefined';
-  if (value === null) return 'null';
-  if (value === undefined) return 'undefined';
-  if (typeof value === 'boolean' || typeof value === 'number') return String(value);
-  const text = String(value);
-  return /^[A-Za-z0-9_./:@=-]+$/.test(text) ? text : shellQuote(text);
-}
-
-export function parsePermissionText(input) {
-  return input
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line && !line.startsWith('#'))
-    .map((line) => parsePermissionRule(splitShellWords(line)));
-}
-
-export function parsePermissionRule(tokens) {
-  const [action] = tokens;
-  const { flags: actionArgs, index: toolIndex } = parseActionArgs(tokens, 1);
-  const tool = tokens[toolIndex];
-  const rest = tokens.slice(toolIndex + 1);
-  if (!action || !tool) throw new UsageError('permission rules require: <action> <tool>');
-  const rule = { action, tool, ...actionArgs };
-  const matches = parseFlagMatches(rest, { undefinedPattern: true });
-  if (Object.keys(matches).length > 0) rule.matches = matches;
-  if (matches.to) {
-    rule.to = matches.to;
-    delete rule.matches.to;
-    if (Object.keys(rule.matches).length === 0) delete rule.matches;
-  }
-  return rule;
-}
-
-function parseActionArgs(tokens, startIndex) {
-  const flags = {};
-  let index = startIndex;
-  while (tokens[index]?.startsWith('--')) {
-    const key = tokens[index].slice(2);
-    flags[key] = parsePermissionValue(tokens[index + 1] ?? '');
-    index += 2;
-  }
-  return { flags, index };
-}
-
-export function parseFlagMatches(tokens, options = {}) {
-  const matches = {};
-  for (let index = 0; index < tokens.length; index += 1) {
-    const token = tokens[index];
-    if (!token.startsWith('--')) continue;
-    const key = token.slice(2);
-    const value = parsePermissionValue(tokens[index + 1] ?? '', options);
-    index += 1;
-    setMatchValue(matches, key, value);
-  }
-  return matches;
-}
-
-function parsePermissionValue(value, options = {}) {
-  if (value === 'undefined') return options.undefinedPattern ? { ...UNDEFINED_MATCH_VALUE } : undefined;
-  if (/^(?:true|false|null|-?\d+(?:\.\d+)?)$/.test(value)) return JSON.parse(value);
-  return value;
-}
-
-function setMatchValue(target, key, value) {
-  const parts = key.split('.').filter(Boolean);
-  let current = target;
-  for (const part of parts.slice(0, -1)) {
-    if (!current[part] || typeof current[part] !== 'object' || Array.isArray(current[part])) current[part] = {};
-    current = current[part];
-  }
-  const finalKey = parts.at(-1) ?? key;
-  if (!Object.hasOwn(current, finalKey)) current[finalKey] = value;
-  else if (Array.isArray(current[finalKey])) current[finalKey].push(value);
-  else current[finalKey] = [current[finalKey], value];
-}

package/src/commands/permissions.mjs

@@ -1,62 +0,0 @@
-import { UsageError } from '../cli/parse.mjs';
-import { readSettings, writeSettings } from '../settings/load.mjs';
-import { evaluatePermission, resolvePermissionDecision } from './permissions-eval.mjs';
-import {
-  PERMISSIONS_SETTING,
-  builtinPermissionRules,
-  loadUserPermissionRules,
-} from './permissions-rules.mjs';
-import {
-  formatPermissionRule,
-  parseFlagMatches,
-  parsePermissionRule,
-  parsePermissionText,
-} from './permissions-text.mjs';
-
-export { resolvePermissionDecision };
-
-export async function runPermissions(args, stdin = '', parsed = {}) {
-  const subcommand = args[0] ?? 'list';
-  if (subcommand === 'list') {
-    const rules = args.includes('--builtin')
-      ? builtinPermissionRules()
-      : [...loadUserPermissionRules(parsed), ...builtinPermissionRules()];
-    for (const rule of rules) console.log(formatPermissionRule(rule));
-    return;
-  }
-
-  if (subcommand === 'add') {
-    const settings = readSettings(parsed);
-    const rule = parsePermissionRule(args.slice(1));
-    settings[PERMISSIONS_SETTING] = [rule, ...(settings[PERMISSIONS_SETTING] ?? [])];
-    await writeSettings(settings, parsed);
-    console.log(`Added permission rule: ${rule.action} ${rule.tool}`);
-    return;
-  }
-
-  if (subcommand === 'edit') {
-    const settings = readSettings(parsed);
-    settings[PERMISSIONS_SETTING] = parsePermissionText(stdin);
-    await writeSettings(settings, parsed);
-    console.log(`Wrote ${settings[PERMISSIONS_SETTING].length} permission rule(s).`);
-    return;
-  }
-
-  if (subcommand === 'test') {
-    const tool = args[1];
-    if (!tool) throw new UsageError('permissions test requires a tool name');
-    const toolArgs = parseFlagMatches(args.slice(2));
-    const context = typeof toolArgs.context === 'string' ? toolArgs.context : 'thread';
-    delete toolArgs.context;
-    const decision = evaluatePermission(tool, toolArgs, parsed, { context });
-    console.log(`tool: ${tool}`);
-    console.log(`arguments: ${JSON.stringify(toolArgs)}`);
-    console.log(`action: ${decision.action}`);
-    if (decision.to) console.log(`to: ${decision.to}`);
-    if (decision.matchedRule !== undefined) console.log(`matched-rule: ${decision.matchedRule}`);
-    console.log(`source: ${decision.source}`);
-    return;
-  }
-
-  throw new UsageError(`Unknown permissions command: ${subcommand}`);
-}

package/src/commands/plugins.mjs

@@ -1,86 +0,0 @@
-import {
-  createPluginCommandContext,
-  loadPlugins,
-} from '../plugins/discover.mjs';
-import { UsageError } from '../cli/parse.mjs';
-import { printRows } from '../util/table.mjs';
-
-export async function runPlugins(args) {
-  const subcommand = args[0] ?? 'list';
-
-  if (subcommand === 'list') {
-    const runtime = await loadPlugins(process.cwd());
-    if (runtime.pluginSummaries.length === 0) {
-      console.log('No plugins found.');
-      return;
-    }
-    for (const plugin of runtime.pluginSummaries) {
-      console.log(formatPluginSummary(plugin));
-    }
-    return;
-  }
-
-  if (subcommand === 'reload') {
-    const runtime = await loadPlugins(process.cwd());
-    console.log(`Reloaded ${runtime.pluginSummaries.length} plugin(s).`);
-    for (const plugin of runtime.pluginSummaries) {
-      console.log(formatPluginSummary(plugin));
-    }
-    return;
-  }
-
-  if (subcommand === 'commands') {
-    const commands = (await loadPlugins(process.cwd())).commands;
-    if (commands.length === 0) {
-      console.log('No plugin commands found.');
-      return;
-    }
-    printRows(commands
-      .filter((command) => command.availability.type !== 'hidden')
-      .map((command) => [
-        command.name,
-        command.availability.type,
-        command.metadata.category ?? '',
-        command.metadata.title ?? command.name,
-        command.availability.type === 'disabled'
-          ? command.availability.reason ?? command.metadata.description ?? ''
-          : command.metadata.description ?? '',
-      ]));
-    return;
-  }
-
-  if (subcommand === 'run') {
-    const commandName = args[1];
-    if (!commandName) throw new UsageError('plugins run requires a command name');
-    const plugins = await loadPlugins(process.cwd());
-    const command = plugins.commands.find((entry) => entry.name === commandName);
-    if (!command) throw new UsageError(`Unknown plugin command: ${commandName}`);
-    if (command.availability.type === 'hidden') throw new UsageError(`Unknown plugin command: ${commandName}`);
-    if (command.availability.type === 'disabled') {
-      throw new UsageError(command.availability.reason ?? `Plugin command disabled: ${commandName}`);
-    }
-    const ctx = createPluginCommandContext(process.cwd());
-    const result = await command.handler(ctx);
-    if (result !== undefined) console.log(String(result));
-    for (const message of plugins.notifications) console.log(message);
-    for (const message of ctx.notifications) console.log(message);
-    return;
-  }
-
-  throw new UsageError(`Unknown plugins command: ${subcommand}`);
-}
-
-function formatPluginSummary(plugin) {
-  return [
-    plugin.name,
-    plugin.source,
-    `tools=${formatRegistrations(plugin.tools)}`,
-    `commands=${formatRegistrations(plugin.commands)}`,
-    `events=${formatRegistrations(plugin.events)}`,
-    plugin.path,
-  ].join('\t');
-}
-
-function formatRegistrations(values = []) {
-  return values.length > 0 ? values.join(',') : '-';
-}

package/src/commands/review.mjs

@@ -1,74 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import path from 'node:path';
-import { CONFIG_SUBDIR } from '../constants.mjs';
-import { configDir, findProjectRoot } from '../settings/paths.mjs';
-import { readFrontmatter, splitListValue } from '../settings/load.mjs';
-import { printRows } from '../util/table.mjs';
-
-export function runReview() {
-  const checks = discoverReviewChecks(process.cwd());
-  console.log('Review jobs:');
-  if (checks.length > 0) {
-    printRows(checks.map((check) => [
-      check.name,
-      'passed',
-      check.severity,
-      check.tools.length ? check.tools.join(', ') : '-',
-      check.displayPath,
-      check.description || '-',
-    ]));
-  } else {
-    console.log('(no configured checks)');
-  }
-  console.log('No review findings from configured local checks.');
-}
-
-function discoverReviewChecks(cwd) {
-  const root = findProjectRoot(cwd);
-  const byName = new Map();
-  for (const dir of reviewCheckDirs(cwd, root)) {
-    for (const check of readReviewChecksFromDir(dir, root)) {
-      byName.set(check.name, check);
-    }
-  }
-  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-
-function reviewCheckDirs(cwd, root) {
-  const dirs = [
-    path.join(configDir(), CONFIG_SUBDIR, 'checks'),
-    path.join(configDir(), 'agents', 'checks'),
-  ];
-  const ancestors = [];
-  let current = cwd;
-  while (true) {
-    ancestors.push(current);
-    if (current === root) break;
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  for (const dir of ancestors.reverse()) {
-    dirs.push(path.join(dir, '.agents', 'checks'));
-  }
-  return dirs;
-}
-
-function readReviewChecksFromDir(dir, root) {
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir)
-    .filter((entry) => entry.toLowerCase().endsWith('.md'))
-    .sort((a, b) => a.localeCompare(b))
-    .map((entry) => readReviewCheck(path.join(dir, entry), root));
-}
-
-function readReviewCheck(filePath, root) {
-  const metadata = readFrontmatter(readFileSync(filePath, 'utf8'));
-  return {
-    name: metadata.name || path.basename(filePath, path.extname(filePath)),
-    description: metadata.description || '',
-    severity: metadata['severity-default'] || 'medium',
-    tools: metadata.tools ? splitListValue(metadata.tools) : [],
-    displayPath: path.relative(root, filePath) || path.basename(filePath),
-  };
-}

package/src/commands/skill.mjs

@@ -1,23 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { listSkills } from '../skills/discover.mjs';
-import { UsageError } from '../cli/parse.mjs';
-import { printRows } from '../util/table.mjs';
-
-export async function runSkill(args, parsed = {}) {
-  const subcommand = args[0] ?? 'list';
-
-  if (subcommand === 'list') {
-    const rows = listSkills({ parsed }).map((skill) => [skill.name, skill.source, skill.description]);
-    printRows(rows.length ? rows : [['(none)', '-', '-']]);
-    return;
-  }
-
-  if (subcommand === 'show') {
-    const skill = listSkills({ parsed }).find((candidate) => candidate.name === args[1]);
-    if (!skill) throw new UsageError(`Unknown skill: ${args[1] ?? ''}`);
-    process.stdout.write(readFileSync(skill.filePath, 'utf8'));
-    return;
-  }
-
-  throw new UsageError(`Unknown skill command: ${subcommand}`);
-}

package/src/commands/threads.mjs

@@ -1,165 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import {
-  latestActiveThread,
-  listThreads,
-  normalizeThreadVisibility,
-  requireThread,
-  THREAD_VISIBILITY_INPUTS,
-  threadSearchText,
-  writeThread,
-} from '../threads/store.mjs';
-import { runExecute } from '../cli/execute.mjs';
-import { THREAD_URL_BASE } from '../constants.mjs';
-import { UsageError } from '../cli/parse.mjs';
-import { printRows } from '../util/table.mjs';
-
-export async function runThreads(args, parsed = {}, stdin = '') {
-  const subcommand = args[0] ?? 'list';
-
-  if (subcommand === 'continue') {
-    if (!parsed.execute) throw new UsageError('threads continue requires --execute');
-    const threadId = args.slice(1).find((arg) => !arg.startsWith('-'));
-    const thread = threadId ? requireThread(threadId) : latestActiveThread();
-    if (!thread) throw new UsageError('No active thread to continue');
-    await runExecute(parsed, stdin, { thread });
-    return;
-  }
-
-  if (subcommand === 'list') {
-    const includeArchived = args.includes('--archived');
-    const rows = listThreads()
-      .filter((thread) => includeArchived || !thread.archived)
-      .map((thread) => [
-        thread.id,
-        thread.archived ? 'archived' : 'active',
-        thread.visibility ?? 'private',
-        formatLabels(thread.labels),
-        thread.title,
-      ]);
-    printRows(rows.length ? rows : [['(none)', '-', '-', '-', '-']]);
-    return;
-  }
-
-  if (subcommand === 'show') {
-    const thread = requireThread(args[1]);
-    console.log(`thread_id: ${thread.id}`);
-    console.log(`url: ${THREAD_URL_BASE}/${thread.id}`);
-    console.log(`status: ${thread.archived ? 'archived' : 'active'}`);
-    console.log(`visibility: ${thread.visibility ?? 'private'}`);
-    console.log(`labels: ${formatLabels(thread.labels, ', ')}`);
-    console.log(`cwd: ${thread.cwd}`);
-    for (const message of thread.messages) {
-      console.log(`${message.role}: ${message.content}`);
-    }
-    return;
-  }
-
-  if (subcommand === 'search') {
-    const query = args.slice(1).join(' ').toLowerCase();
-    const rows = listThreads()
-      .filter((thread) => threadSearchText(thread).toLowerCase().includes(query))
-      .map((thread) => [thread.id, thread.archived ? 'archived' : 'active', thread.visibility ?? 'private', formatLabels(thread.labels), thread.title]);
-    printRows(rows.length ? rows : [['(none)', '-', '-', '-', '-']]);
-    return;
-  }
-
-  if (subcommand === 'map') {
-    const root = args[1] ? requireThread(args[1]) : latestActiveThread();
-    if (!root) throw new UsageError('No active thread to map');
-    console.log(`Thread map for ${root.id}`);
-    for (const row of threadMapRows(root.id)) {
-      console.log(row);
-    }
-    return;
-  }
-
-  if (subcommand === 'archive') {
-    const thread = requireThread(args[1]);
-    thread.archived = true;
-    thread.updatedAt = new Date().toISOString();
-    await writeThread(thread);
-    console.log(`Archived thread ${thread.id}`);
-    return;
-  }
-
-  if (subcommand === 'visibility' || subcommand === 'set-visibility') {
-    const thread = requireThread(args[1]);
-    const visibility = normalizeThreadVisibility(args[2]);
-    if (!visibility) {
-      throw new UsageError(`visibility must be one of: ${THREAD_VISIBILITY_INPUTS.join(', ')}`);
-    }
-    thread.visibility = visibility;
-    thread.updatedAt = new Date().toISOString();
-    await writeThread(thread);
-    console.log(`Set ${thread.id} visibility to ${visibility}`);
-    return;
-  }
-
-  if (subcommand === 'report') {
-    const thread = requireThread(args[1]);
-    const reportId = `R-${randomUUID()}`;
-    console.log(`diagnostic_report_id: ${reportId}`);
-    console.log(`thread_id: ${thread.id}`);
-    console.log('retention: 7 days');
-    return;
-  }
-
-  throw new UsageError(`Unknown threads command: ${subcommand}`);
-}
-
-function formatLabels(labels = [], separator = ',') {
-  return labels.length > 0 ? labels.join(separator) : '-';
-}
-
-function threadMapRows(rootId) {
-  const threads = listThreads();
-  const byId = new Map(threads.map((thread) => [thread.id, thread]));
-  const edges = threadReferenceEdges(threads);
-  const seen = new Set();
-  const queue = [rootId];
-  const rows = [];
-
-  while (queue.length > 0) {
-    const threadId = queue.shift();
-    if (seen.has(threadId)) continue;
-    seen.add(threadId);
-    const thread = byId.get(threadId);
-    if (!thread) continue;
-    rows.push(`${thread.id} ${thread.title}`);
-
-    for (const edge of edges.filter((entry) => entry.from === threadId || entry.to === threadId)) {
-      const neighborId = edge.from === threadId ? edge.to : edge.from;
-      const neighbor = byId.get(neighborId);
-      if (!neighbor) continue;
-      const label = edge.from === threadId ? 'mentions ->' : '<- mentioned by';
-      rows.push(`  ${label} ${neighbor.id} ${neighbor.title}`);
-      if (!seen.has(neighborId)) queue.push(neighborId);
-    }
-  }
-
-  return rows;
-}
-
-function threadReferenceEdges(threads) {
-  const knownIds = new Set(threads.map((thread) => thread.id));
-  const edges = [];
-  const seen = new Set();
-  for (const thread of threads) {
-    for (const message of thread.messages ?? []) {
-      for (const ref of threadReferences(message.content)) {
-        if (ref === thread.id || !knownIds.has(ref)) continue;
-        const key = `${thread.id}->${ref}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        edges.push({ from: thread.id, to: ref });
-      }
-    }
-  }
-  return edges;
-}
-
-function threadReferences(text = '') {
-  const threadUrlPattern = THREAD_URL_BASE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  return [...String(text).matchAll(new RegExp(`(?:@|${threadUrlPattern}/)(T-[A-Za-z0-9-]+)`, 'g'))]
-    .map((match) => match[1]);
-}

package/src/commands/tools.mjs

@@ -1,77 +0,0 @@
-import { chmod, mkdir, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { BUILTIN_TOOLS, CLI_NAME } from '../constants.mjs';
-import { writableToolsDir } from '../settings/paths.mjs';
-import { listConfiguredMcpServers } from '../mcp/discover.mjs';
-import { discoverMcpToolRows } from '../mcp/probe.mjs';
-import { listPluginTools } from '../plugins/discover.mjs';
-import {
-  executeToolboxTool,
-  isToolDisabled,
-  listToolboxTools,
-  normalizeToolName,
-  parseToolUseArgs,
-  printToolboxSchema,
-  toolboxTemplate,
-} from '../tools/toolbox.mjs';
-import { UsageError } from '../cli/parse.mjs';
-import { printRows } from '../util/table.mjs';
-
-export async function runTools(args, stdin, parsed = {}) {
-  const subcommand = args[0] ?? 'list';
-  if (subcommand === 'list') {
-    const mcpToolRows = await discoverMcpToolRows(
-      listConfiguredMcpServers(parsed).filter((server) => server.status === 'approved'),
-    );
-    const pluginToolRows = (await listPluginTools(process.cwd()))
-      .map((tool) => [tool.name, 'plugin', tool.description]);
-    const rows = [
-      ...BUILTIN_TOOLS,
-      ...mcpToolRows,
-      ...pluginToolRows,
-      ...listToolboxTools(parsed).map((tool) => [tool.name, 'toolbox', tool.description]),
-    ].filter(([name, kind]) => !isToolDisabled(name, kind, parsed));
-    printRows(rows);
-    return;
-  }
-
-  if (subcommand === 'make') {
-    const shell = args.includes('--zsh') ? 'zsh' : args.includes('--bash') ? 'bash' : 'js';
-    const rawName = args.find((arg) => !arg.startsWith('-') && arg !== 'make') ?? 'tool';
-    const toolName = rawName.replace(/[^a-zA-Z0-9_-]/g, '_');
-    const filePath = path.join(writableToolsDir(), toolName);
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, toolboxTemplate(shell, toolName), 'utf8');
-    await chmod(filePath, 0o755);
-    console.log(`Tool created at: ${filePath}`);
-    console.log(`Inspect with: ${CLI_NAME} tools show tb__${toolName}`);
-    console.log(`Execute with: ${CLI_NAME} tools use tb__${toolName}`);
-    return;
-  }
-
-  if (subcommand === 'show') {
-    const toolName = normalizeToolName(args[1]);
-    const tool = listToolboxTools(parsed).find((entry) => entry.name === toolName);
-    if (!tool) throw new UsageError(`Unknown tool: ${args[1] ?? ''}`);
-    printToolboxSchema(tool);
-    return;
-  }
-
-  if (subcommand === 'use') {
-    const useArgs = parseToolUseArgs(args.slice(1));
-    const toolName = normalizeToolName(useArgs.toolName);
-    const tool = listToolboxTools(parsed).find((entry) => entry.name === toolName);
-    if (!tool) throw new UsageError(`Unknown tool: ${useArgs.toolName ?? ''}`);
-    const result = executeToolboxTool(tool, useArgs.flags, stdin, useArgs.threadId);
-    if (useArgs.onlyOutput) {
-      process.stdout.write(result.stdout);
-    } else {
-      if (result.stderr) process.stderr.write(result.stderr);
-      process.stdout.write(`${JSON.stringify({ output: result.stdout, exitCode: result.status ?? 0 }, null, 2)}\n`);
-    }
-    process.exitCode = result.status ?? 0;
-    return;
-  }
-
-  throw new UsageError(`Unknown tools command: ${subcommand}`);
-}

package/src/commands/update.mjs

@@ -1,31 +0,0 @@
-import { CLI_NAME, VERSION } from '../constants.mjs';
-import { readEffectiveSettings } from '../settings/load.mjs';
-
-export function runUpdate(parsed = {}) {
-  if (process.env.COVEN_CODE_SKIP_UPDATE_CHECK === '1') {
-    console.log('update_check: skipped');
-    console.log('reason: COVEN_CODE_SKIP_UPDATE_CHECK=1');
-    console.log('update_action: none');
-    console.log(`version: ${VERSION}`);
-    return;
-  }
-
-  const mode = updateMode(readEffectiveSettings(parsed)['covenCode.updates.mode']);
-  if (mode === 'disabled') {
-    console.log('update_check: disabled');
-    console.log('mode: disabled');
-    console.log('update_action: none');
-    console.log(`version: ${VERSION}`);
-    return;
-  }
-
-  console.log('update_check: checked');
-  console.log(`mode: ${mode}`);
-  console.log(`update_action: ${mode === 'warn' ? 'notify' : 'auto'}`);
-  console.log(`version: ${VERSION}`);
-  console.log(`status: ${CLI_NAME} ${VERSION} is current in this local recreation.`);
-}
-
-function updateMode(value) {
-  return ['auto', 'warn', 'disabled'].includes(value) ? value : 'auto';
-}