@semalt-ai/code 1.8.5 → 1.19.0

package/lib/commands/registry.js

@@ -0,0 +1,269 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Slash-command registry — single source of truth for the in-chat commands.
+// ---------------------------------------------------------------------------
+//
+// One list drives all three things that used to be maintained separately:
+//   * dispatch          (lib/commands.js resolves text → command via this list)
+//   * the /help text    (helpText() is generated here, not hand-written)
+//   * tab-completion     (lib/ui/input-field.js pulls completionNames() here)
+//
+// Each entry:
+//   name            canonical command token (e.g. '/model', or 'exit')
+//   aliases?        additional tokens that resolve to the same command
+//   takesArg?       true     → requires an argument: only `name <arg>` matches,
+//                              bare `name` falls through (e.g. /file, /shell)
+//                   'optional'→ `name` and `name <arg>` both match (/model, /debug)
+//                   (absent) → exact-match only (/new, /clear, …)
+//   bang?           true → also matches a leading '!' (the /shell shorthand)
+//   caseInsensitive? true → match ignoring case (exit/quit)
+//   complete?       true → offered in tab-completion
+//   help?           string | string[] → line(s) shown in /help, in list order.
+//                   Absence means "not advertised in /help" (e.g. /help, /prompt).
+//
+// Handlers live in lib/commands.js bound to the chat-session closure; this
+// module owns identity, arg shape, help, and completion. A load-time parity
+// check in commands.js asserts every entry here has a handler and vice-versa,
+// so adding a command is a single registry entry + its handler. (Full handler
+// co-location lands in Task 1.5 when commands.js is split and a session-context
+// object is introduced.)
+
+const SLASH_COMMANDS = [
+  { name: '/help', complete: true },
+  { name: '/file', takesArg: true, complete: true, help: '/file <path>    Load file or dir into context' },
+  { name: '/image', takesArg: true, complete: true, help: '/image <path>   Attach an image (PNG/JPEG/WebP/GIF) to your next message' },
+  { name: '/history', complete: true, help: '/history        Browse local sessions' },
+  { name: '/chats', complete: true, help: '/chats          Browse saved dashboard chats' },
+  { name: '/new', complete: true, help: '/new            Start fresh conversation' },
+  { name: '/login', complete: true, help: '/login          Authorize via browser' },
+  { name: '/whoami', complete: true, help: '/whoami         Show current user' },
+  { name: '/logout', complete: true, help: '/logout         Clear CLI login' },
+  { name: '/model', takesArg: 'optional', complete: true, help: ['/model          Show current model', '/model <name>   Switch model manually'] },
+  { name: '/models', complete: true, help: '/models         Choose from dashboard models' },
+  { name: '/clear', complete: true, help: '/clear          Clear conversation' },
+  { name: '/compact', aliases: ['/cost'], complete: true, help: '/compact        Show token usage' },
+  { name: '/shell', takesArg: true, bang: true, complete: true, help: ['/shell <cmd>    Run shell command', '!<cmd>          Run shell command'] },
+  { name: '/approve', complete: true, help: '/approve        Toggle auto-approve' },
+  { name: '/debug', takesArg: 'optional', complete: true, help: '/debug [off]    Enable debug output + show last 5 audit entries' },
+  { name: '/config', complete: true, help: '/config         Show config' },
+  { name: '/memory', complete: true, help: '/memory         Show loaded project memory files' },
+  { name: '/mcp', complete: true, help: '/mcp            Show MCP server connection status and tools' },
+  { name: '/skills', complete: true, help: '/skills         List available skills (bodies load on invocation)' },
+  { name: '/plan', complete: true, help: '/plan           Toggle plan mode (withhold changes until approved)' },
+  { name: '/rewind', takesArg: 'optional', complete: true, help: ['/rewind         List file checkpoints (file changes only — shell not reversible)', '/rewind <seq> [code|conversation|both]   Restore files and/or conversation (default both; add "force" to override out-of-band edits)'] },
+  { name: '/doctor', complete: true, help: '/doctor         Run self-diagnostics (config, dashboard, model, audit, key, memory)' },
+  { name: '/sandbox', complete: true, help: '/sandbox        Show OS sandbox status (mode, tool, availability, network)' },
+  { name: '/prompt' },
+  { name: 'exit', aliases: ['quit', '/exit', '/quit'], caseInsensitive: true, help: 'exit            Quit' },
+];
+
+// Custom (Markdown-defined) commands, registered at session start from
+// ~/.semalt-ai/commands and .semalt/commands (Task 3.1). Held in module state so
+// the registry stays the single source of truth: resolveCommand/completion/help
+// all see custom commands alongside the built-ins. Built-ins are always listed
+// first, so a custom command can never shadow one even if registration somehow
+// let a colliding name through.
+let CUSTOM_COMMANDS = [];
+
+// Skills (Task 3.5), registered at session start from ~/.semalt-ai/skills and
+// .semalt/skills. Like custom commands they live in module state so the registry
+// stays the single source of truth, but they carry only METADATA + the path to
+// their SKILL.md — never the body. Invoking `/<skill>` loads the body on demand
+// (progressive disclosure), handled inline by the turn handler.
+let SKILL_COMMANDS = [];
+
+// Every command spec, built-ins first then customs then skills, so neither a
+// custom command nor a skill can ever shadow a built-in even if a colliding name
+// slipped past registration.
+function allCommands() {
+  return SLASH_COMMANDS.concat(CUSTOM_COMMANDS).concat(SKILL_COMMANDS);
+}
+
+// Register discovered custom command specs (from lib/commands/custom.js),
+// replacing any previously-registered set. Built-ins win on collision: any
+// custom whose name collides with a built-in name OR alias is dropped with a
+// warning. The input list is assumed already de-duplicated by name with
+// project-over-global precedence. Each registered spec behaves like an
+// optional-arg, completable command carrying its prompt `template`. Returns
+// { registered, warnings }.
+function registerCustomCommands(specs) {
+  const reserved = new Set();
+  for (const s of SLASH_COMMANDS) {
+    reserved.add(s.name);
+    for (const a of (s.aliases || [])) reserved.add(a);
+  }
+  const warnings = [];
+  const registered = [];
+  const taken = new Set();
+  for (const spec of (specs || [])) {
+    if (reserved.has(spec.name)) {
+      warnings.push(`Custom command ${spec.name} (${spec.source || 'custom'}) ignored: a built-in command already uses that name.`);
+      continue;
+    }
+    if (taken.has(spec.name)) continue;
+    taken.add(spec.name);
+    const aliases = (spec.aliases || []).filter((a) => !reserved.has(a) && !taken.has(a));
+    for (const a of aliases) taken.add(a);
+    registered.push({
+      name: spec.name,
+      aliases,
+      takesArg: 'optional',
+      complete: true,
+      custom: true,
+      template: spec.template || '',
+      description: spec.description || '',
+      argumentHint: spec.argumentHint || '',
+      source: spec.source || 'custom',
+      filePath: spec.filePath || '',
+    });
+  }
+  CUSTOM_COMMANDS = registered;
+  return { registered, warnings };
+}
+
+// Drop all registered custom commands (test isolation / session reset).
+function clearCustomCommands() {
+  CUSTOM_COMMANDS = [];
+}
+
+// The currently-registered custom command specs (copy).
+function customCommands() {
+  return CUSTOM_COMMANDS.slice();
+}
+
+// Register discovered skill metadata specs (from lib/skills.js), replacing any
+// previously-registered set. Built-ins win on collision, and skills also defer
+// to already-registered custom commands (customs register first in cmdChat) — a
+// colliding skill is dropped with a warning. Each registered spec behaves like
+// an optional-arg, completable command flagged `skill: true` and carrying the
+// metadata + `skillPath` needed to load its body on invocation (NOT the body
+// itself). Returns { registered, warnings }.
+function registerSkills(specs) {
+  const reserved = new Set();
+  for (const s of SLASH_COMMANDS) {
+    reserved.add(s.name);
+    for (const a of (s.aliases || [])) reserved.add(a);
+  }
+  for (const c of CUSTOM_COMMANDS) {
+    reserved.add(c.name);
+    for (const a of (c.aliases || [])) reserved.add(a);
+  }
+  const warnings = [];
+  const registered = [];
+  const taken = new Set();
+  for (const spec of (specs || [])) {
+    if (reserved.has(spec.name)) {
+      warnings.push(`Skill ${spec.name} (${spec.source || 'skill'}) ignored: that command name is already in use.`);
+      continue;
+    }
+    if (taken.has(spec.name)) continue;
+    taken.add(spec.name);
+    registered.push({
+      name: spec.name,
+      aliases: [],
+      takesArg: 'optional',
+      complete: true,
+      skill: true,
+      slug: spec.slug || spec.name.replace(/^\//, ''),
+      displayName: spec.displayName || '',
+      description: spec.description || '',
+      skillPath: spec.skillPath || '',
+      dir: spec.dir || '',
+      source: spec.source || 'skill',
+    });
+  }
+  SKILL_COMMANDS = registered;
+  return { registered, warnings };
+}
+
+// Drop all registered skills (test isolation / session reset).
+function clearSkills() {
+  SKILL_COMMANDS = [];
+}
+
+// The currently-registered skill specs (copy).
+function skillCommands() {
+  return SKILL_COMMANDS.slice();
+}
+
+// Resolve raw input text to { name, arg, spec } or null when it is not a command.
+// `name` is the canonical command name; `arg` is the trimmed remainder (or '').
+function resolveCommand(text) {
+  if (typeof text !== 'string' || !text) return null;
+  for (const spec of allCommands()) {
+    const names = [spec.name, ...(spec.aliases || [])];
+    const exactOk = !spec.takesArg || spec.takesArg === 'optional';
+    if (exactOk) {
+      for (const n of names) {
+        if (spec.caseInsensitive ? text.toLowerCase() === n.toLowerCase() : text === n) {
+          return { name: spec.name, arg: '', spec };
+        }
+      }
+    }
+    if (spec.takesArg) {
+      for (const n of names) {
+        if (text.startsWith(n + ' ')) {
+          return { name: spec.name, arg: text.slice(n.length + 1).trim(), spec };
+        }
+      }
+    }
+    if (spec.bang && text.startsWith('!')) {
+      return { name: spec.name, arg: text.slice(1).trim(), spec };
+    }
+  }
+  return null;
+}
+
+// Command names offered in tab-completion (built-ins + registered customs).
+function completionNames() {
+  return allCommands().filter((c) => c.complete).map((c) => c.name);
+}
+
+// The /help body, generated in list order from the `help` fields. Registered
+// custom commands are appended under their own heading; with none registered
+// the output is byte-for-byte the built-in-only help.
+function helpText() {
+  const lines = ['Commands:'];
+  for (const s of SLASH_COMMANDS) {
+    if (!s.help) continue;
+    for (const h of (Array.isArray(s.help) ? s.help : [s.help])) lines.push('  ' + h);
+  }
+  if (CUSTOM_COMMANDS.length) {
+    lines.push('Custom commands:');
+    for (const c of CUSTOM_COMMANDS) {
+      const hint = c.argumentHint ? ' ' + c.argumentHint : '';
+      const desc = c.description ? '   ' + c.description : '';
+      lines.push(`  ${c.name}${hint}${desc}`);
+    }
+  }
+  if (SKILL_COMMANDS.length) {
+    lines.push('Skills:');
+    for (const s of SKILL_COMMANDS) {
+      const desc = s.description ? '   ' + s.description : '';
+      lines.push(`  ${s.name}${desc}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+// Canonical built-in command names (for the handler parity check in chat.js).
+// Custom commands are intentionally excluded: they are handled inline by the
+// turn handler (rendered → submitted to the agent), not via slash handlers.
+function commandNames() {
+  return SLASH_COMMANDS.map((c) => c.name);
+}
+
+module.exports = {
+  SLASH_COMMANDS,
+  resolveCommand,
+  completionNames,
+  helpText,
+  commandNames,
+  registerCustomCommands,
+  clearCustomCommands,
+  customCommands,
+  registerSkills,
+  clearSkills,
+  skillCommands,
+};

package/lib/commands/tasks.js

@@ -0,0 +1,89 @@
+'use strict';
+
+// Background-task CLI commands (Task 5.3): `run --background` to launch and
+// `tasks <list|status|result|kill|prune>` to manage. Thin handlers over
+// lib/background.js — the launcher validates synchronously before detaching, so
+// any config/policy error surfaces HERE, in the terminal, with no orphan.
+
+const bg = require('../background');
+const { resolveApiKey } = require('../secrets');
+
+function createTaskCommands(shared) {
+  const { getConfig, writer, FG_CYAN, FG_GRAY, FG_GREEN, FG_RED, FG_YELLOW, RST } = shared;
+  const store = bg.createTaskStore();
+
+  // Launch a detached background agent task. Policy is FIXED here from the CLI
+  // flags (refuse-by-default when none given) and cannot change after detach.
+  async function cmdRun(opts, promptArgs) {
+    const prompt = (promptArgs || []).join(' ');
+    if (!opts.background) {
+      writer.scrollback(`  ${FG_RED}Usage: semalt-code run --background <prompt>${RST}`);
+      await writer.flush();
+      return;
+    }
+    const config = getConfig();
+    const policy = bg.buildPolicy({
+      allowedTiers: opts.allowedTiers || [],
+      readonly: !!opts.readonly,
+      dangerouslySkipPermissions: !!opts.dangerouslySkipPermissions,
+    });
+    // Binary network isolation (Task 4.4b): --no-network at launch is baked into
+    // the spec's sandbox config (config-driven), so the detached child enforces
+    // kernel-level no-network via its own config — no reliance on the child's argv.
+    const sandboxConfig = opts.noNetwork
+      ? { ...(config.sandbox || {}), network: 'off' }
+      : config.sandbox;
+    try {
+      const { id, pid, dir } = await bg.launchBackground({
+        prompt,
+        config,
+        policy,
+        sandboxConfig,
+        model: opts.model,
+        cwd: process.cwd(),
+        store,
+        resolveKey: resolveApiKey,
+      });
+      writer.scrollback(`  ${FG_GREEN}✓${RST} Launched background task ${FG_CYAN}${id}${RST} (pid ${pid})`);
+      writer.scrollback(`  ${FG_GRAY}policy: ${bg.policySummary(policy)} · dir: ${dir}${RST}`);
+      writer.scrollback(`  ${FG_GRAY}Track with: semalt-code tasks status ${id}${RST}`);
+    } catch (err) {
+      writer.scrollback(`  ${FG_RED}✗ ${err.message}${RST}`);
+    }
+    await writer.flush();
+  }
+
+  async function cmdTasks(sub, argv = []) {
+    const id = argv[0];
+    if (!sub || sub === 'list') {
+      writer.scrollback(bg.formatTaskList(store.list()));
+    } else if (sub === 'status') {
+      if (!id) { writer.scrollback(`  ${FG_RED}Usage: semalt-code tasks status <id>${RST}`); }
+      else writer.scrollback(bg.formatTaskStatus(store.readMeta(id), store.readEvents(id)));
+    } else if (sub === 'result') {
+      if (!id) { writer.scrollback(`  ${FG_RED}Usage: semalt-code tasks result <id>${RST}`); }
+      else {
+        const res = store.readResult(id);
+        if (!res) writer.scrollback(`  ${FG_YELLOW}No result yet for ${id} (still running or failed before completion).${RST}`);
+        else writer.scrollback(JSON.stringify(res, null, 2));
+      }
+    } else if (sub === 'kill') {
+      if (!id) { writer.scrollback(`  ${FG_RED}Usage: semalt-code tasks kill <id>${RST}`); }
+      else {
+        const r = await bg.killTask(store, id);
+        writer.scrollback(r.ok ? `  ${FG_GREEN}✓${RST} ${id}: ${r.reason}` : `  ${FG_RED}✗ ${id}: ${r.reason}${RST}`);
+      }
+    } else if (sub === 'prune') {
+      const ids = bg.prunableIds(store.list());
+      for (const tid of ids) store.remove(tid);
+      writer.scrollback(`  ${FG_GREEN}✓${RST} Pruned ${ids.length} finished/stale task(s).`);
+    } else {
+      writer.scrollback('Usage: semalt-code tasks <list|status <id>|result <id>|kill <id>|prune>');
+    }
+    await writer.flush();
+  }
+
+  return { cmdRun, cmdTasks };
+}
+
+module.exports = { createTaskCommands };

package/lib/compact.js

@@ -0,0 +1,87 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Conversation compaction (Task 2.7) — real /compact + auto-compaction.
+// ---------------------------------------------------------------------------
+//
+// Splits the message history into a HEAD to summarize and a TAIL to keep
+// verbatim, preserving the most recent turns and any pinned messages. The LLM
+// summarization call itself is done by the caller; everything here is pure so
+// the selection / replacement logic is unit-testable.
+
+const DEFAULT_KEEP_RECENT = 6;
+
+// Partition messages into { head, tail, pinned }:
+//   tail   — the last `keepRecent` messages (kept verbatim)
+//   pinned — messages before the tail for which isPinned(msg, i) is true
+//   head   — the remaining older messages (to be summarized)
+// When there is nothing older than the tail, head is empty (nothing to do).
+function selectForCompaction(messages, opts = {}) {
+  const list = Array.isArray(messages) ? messages : [];
+  const keepRecent = Number.isInteger(opts.keepRecent) ? opts.keepRecent : DEFAULT_KEEP_RECENT;
+  const isPinned = typeof opts.isPinned === 'function' ? opts.isPinned : () => false;
+  if (list.length <= keepRecent) return { head: [], tail: list.slice(), pinned: [] };
+  const cut = list.length - keepRecent;
+  const head = [];
+  const pinned = [];
+  for (let i = 0; i < cut; i++) {
+    if (isPinned(list[i], i)) pinned.push(list[i]);
+    else head.push(list[i]);
+  }
+  return { head, tail: list.slice(cut), pinned };
+}
+
+// Build the messages array for the summarization LLM call from the head.
+function summarizationRequest(head) {
+  const transcript = (head || []).map((m) => {
+    const role = (m && m.role) || 'user';
+    const content = m && typeof m.content === 'string' ? m.content : JSON.stringify(m && m.content);
+    return `${role.toUpperCase()}: ${content}`;
+  }).join('\n\n');
+  return [
+    {
+      role: 'system',
+      content: 'You are compacting a coding-assistant conversation. Summarize the exchange below concisely but completely: preserve key decisions, file paths, code changes already made, commands run, and any open/unfinished tasks. Output ONLY the summary.',
+    },
+    { role: 'user', content: transcript },
+  ];
+}
+
+// Reassemble the history after summarization: pinned messages, then a single
+// summary message, then the verbatim tail. The summary is a user-role message
+// (broadly compatible) clearly labelled so the model treats it as context.
+function buildCompactedMessages({ pinned = [], tail = [] }, summaryText) {
+  const summaryMsg = {
+    role: 'user',
+    content: `[Summary of earlier conversation]\n${(summaryText || '').trim()}`,
+  };
+  return [...pinned, summaryMsg, ...tail];
+}
+
+// Convenience: approximate token count of a message list using the same
+// char/4 heuristic the rest of the CLI uses. Injected estimator keeps it pure.
+function approxTokens(messages, estimate) {
+  const est = typeof estimate === 'function' ? estimate : (s) => Math.ceil((s || '').length / 4);
+  return (messages || []).reduce((sum, m) => sum + est(typeof m.content === 'string' ? m.content : JSON.stringify(m.content)), 0);
+}
+
+// Decide whether to auto-compact: only when a token limit is known, the
+// history is bigger than what we'd keep, and usage has crossed `ratio` of the
+// limit. Complements api.js trimToTokenBudget (which drops messages) by
+// summarizing them instead.
+function shouldAutoCompact(tokens, limit, messageCount, opts = {}) {
+  const keepRecent = Number.isInteger(opts.keepRecent) ? opts.keepRecent : DEFAULT_KEEP_RECENT;
+  const ratio = typeof opts.ratio === 'number' ? opts.ratio : 0.85;
+  if (!Number.isFinite(limit) || limit <= 0) return false;
+  if (messageCount <= keepRecent + 1) return false;
+  return tokens >= limit * ratio;
+}
+
+module.exports = {
+  DEFAULT_KEEP_RECENT,
+  selectForCompaction,
+  summarizationRequest,
+  buildCompactedMessages,
+  approxTokens,
+  shouldAutoCompact,
+};