s-app-scoder-agent 0.8.20 → 0.9.2

package/dist/tui/command-registry.js

@@ -1,6 +1,11 @@
 import { listSessions, resolveSessionId } from "../session.js";
-import { discoverSkills } from "../skills.js";
-import { formatSlashHelp, parseMcpExec } from "./commands.js";
+import { discoverSkills, skillWarnings } from "../skills.js";
+import { selectableAgents } from "../agents.js";
+import { agentsMdTemplate } from "../agents-guide.js";
+import { existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { formatSlashHelp, parseMcpExec, BUILTIN_COMMANDS, resolveCommandDef, discoverCustomCommands, runCustomCommand } from "./commands.js";
+import { exportTranscript, findInTranscript } from "./transcript.js";
 /** Format usage/cost block (dùng chung — REPL console.log, TUI notice). */
 export function formatUsage(u) {
     return u.calls > 0
@@ -30,8 +35,30 @@ export function formatMcpStatus(status) {
     if (status.length === 0)
         return "no MCP servers configured — add mcpServers to .scoderrc.json";
     return status
-        .map((srv) => `${srv.connected ? "✓" : "·"} ${srv.name} — ${srv.command}` +
-        (srv.connected ? ` (${srv.tools.length} tools)\n` + srv.tools.map((t) => `    mcp__${srv.name}__${t.name}  ${t.description ?? ""}`).join("\n") : " (not connected)"))
+        .map((srv) => {
+        const capParts = [];
+        if (srv.serverInfo?.name)
+            capParts.push(srv.serverInfo.name + (srv.serverInfo.version ? " v" + srv.serverInfo.version : ""));
+        if (srv.capabilities?.ping === true)
+            capParts.push("ping");
+        if (srv.capabilities?.tools)
+            capParts.push("tools");
+        if (srv.capabilities?.resources)
+            capParts.push("resources");
+        if (srv.capabilities?.prompts)
+            capParts.push("prompts");
+        const capTag = capParts.length > 0 ? ` [${capParts.join(", ")}]` : "";
+        const counts = [
+            `${srv.tools.length} tools`,
+            ...(srv.resourceCount ? [`${srv.resourceCount} resources`] : []),
+            ...(srv.promptCount ? [`${srv.promptCount} prompts`] : []),
+        ].join(", ");
+        return (`${srv.connected ? "✓" : "·"} ${srv.name} — ${srv.command}${capTag}` +
+            (srv.connected
+                ? ` (${counts})\n` +
+                    srv.tools.map((t) => `    mcp__${srv.name}__${t.name}  ${t.description ?? ""}`).join("\n")
+                : " (not connected)"));
+    })
         .join("\n");
 }
 /**
@@ -55,11 +82,73 @@ export function coreCommands() {
                 notice(formatUsage(host.agent()?.getUsage() ?? { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 }));
             },
         },
+        {
+            name: "/compact",
+            description: "summarize older history now (manual compaction)",
+            async run(_slash, host, notice) {
+                const agent = host.agent();
+                if (!agent)
+                    return notice("agent not ready — start a task first", "warn");
+                if (host.isRunning?.())
+                    return notice("agent is running — wait or Esc first", "warn");
+                const r = await agent.compactHistory();
+                notice(r.message, r.ok ? "info" : "warn");
+            },
+        },
         {
             name: "/skills",
-            description: "list discovered skills (SKILL.md)",
-            run(_slash, host, notice) {
-                notice(formatSkills(host.agent()?.getSkills() ?? discoverSkills(host.config.workdir)));
+            description: "list/info/lint/reload skills — /skills [info <name>|lint|reload]",
+            run(slash, host, notice) {
+                const arg = slash.arg.trim();
+                const skills = host.agent()?.getSkills() ?? discoverSkills(host.config.workdir);
+                if (!arg) {
+                    notice(formatSkills(skills));
+                    return;
+                }
+                const parts = arg.split(/\s+/);
+                const sub = parts[0].toLowerCase();
+                if (sub === "info") {
+                    const name = parts.slice(1).join(" ").trim();
+                    if (!name)
+                        return notice("usage: /skills info <name>", "warn");
+                    const skill = skills.find((s) => s.name.toLowerCase() === name.toLowerCase());
+                    if (!skill)
+                        return notice(`skill "${name}" not found`, "error");
+                    const lines = [
+                        `# ${skill.name}${skill.version ? ` v${skill.version}` : ""}`,
+                        `description: ${skill.description}`,
+                        `scope: ${skill.scope}`,
+                        skill.tags?.length ? `tags: ${skill.tags.join(", ")}` : null,
+                        skill.allowedTools?.length ? `allowed-tools: ${skill.allowedTools.join(", ")}` : null,
+                        skill.references?.length ? `references: ${skill.references.join(", ")}` : null,
+                        skill.whenToUse ? `when-to-use: ${skill.whenToUse}` : null,
+                        "",
+                        skill.body,
+                    ].filter(Boolean);
+                    notice(lines.join("\n"));
+                    return;
+                }
+                if (sub === "lint") {
+                    const warnings = skillWarnings.filter((w) => !host.config.workdir || w.path.startsWith(host.config.workdir));
+                    if (warnings.length === 0)
+                        return notice("skills lint: ok (no warnings)", "info");
+                    notice(warnings.map((w) => `${w.path}: ${w.message}`).join("\n"), "warn");
+                    return;
+                }
+                if (sub === "reload") {
+                    const ag = host.agent();
+                    if (ag)
+                        ag.reloadSkills?.();
+                    notice(formatSkills(host.agent()?.getSkills() ?? discoverSkills(host.config.workdir)));
+                    return;
+                }
+                // default: treat arg as skill name → show info
+                const skill = skills.find((s) => s.name.toLowerCase() === arg.toLowerCase());
+                if (skill) {
+                    notice(`# ${skill.name}\n${skill.description}\n${skill.body.slice(0, 500)}`, "info");
+                    return;
+                }
+                notice(`unknown /skills subcommand: ${arg}`, "error");
             },
         },
         {
@@ -122,10 +211,86 @@ export function coreCommands() {
                     return;
                 }
                 host.agent()?.setPermissionMode(mode);
+                host.updateConfig?.({ permissionMode: mode });
                 host.config = withPermissionMode(host.config, mode);
                 notice(`permission mode → ${mode}`);
             },
         },
+        {
+            name: "/plan",
+            description: "show the current plan — /plan done|start <id|n|text> to mark steps",
+            run(slash, host, notice) {
+                const agent = host.agent();
+                const plan = agent?.getPlan() ?? [];
+                if (!slash.arg) {
+                    if (plan.length === 0)
+                        return notice("no plan yet — multi-step tasks get one via write_todos");
+                    const icon = (s) => (s === "completed" ? "✓" : s === "in_progress" ? "▸" : "○");
+                    notice("Plan:\n" +
+                        plan
+                            .map((t, i) => {
+                            let line = `  ${icon(t.status)} ${String(i + 1).padStart(2)}. ${t.content}`;
+                            if (t.verify)
+                                line += `\n       verify: ${t.verify}`;
+                            if (t.acceptance)
+                                line += `\n       acceptance: ${t.acceptance}`;
+                            if (t.files?.length)
+                                line += `\n       files: ${t.files.join(", ")}`;
+                            return line;
+                        })
+                            .join("\n") +
+                        "\nmark: /plan done <id|n> · /plan start <id|n>");
+                    return;
+                }
+                const m = /^(done|start)\s+(.+)$/.exec(slash.arg.trim());
+                if (!agent)
+                    return notice("agent not ready", "warn");
+                if (!m)
+                    return notice("usage: /plan [done|start <id|n|text>]", "warn");
+                const r = agent.markPlanStep(m[1] === "done" ? "completed" : "in_progress", m[2]);
+                notice(r.message, r.ok ? "info" : "warn");
+            },
+        },
+        {
+            name: "/agent",
+            description: "list selectable agents — /agent <name> to switch (idle only)",
+            run(slash, host, notice) {
+                const agents = selectableAgents(host.config.workdir);
+                const current = host.config.agent ?? "build";
+                if (!slash.arg) {
+                    notice("Agents:\n" +
+                        agents.map((a) => `  ${a.name === current ? "*" : " "} ${a.name.padEnd(10)} ${a.description}`).join("\n") +
+                        "\nswitch with /agent <name> (idle only; resets the conversation)");
+                    return;
+                }
+                const name = slash.arg.trim();
+                const def = agents.find((a) => a.name === name);
+                if (!def) {
+                    return notice(`agent "${name}" not selectable — available: ${agents.map((a) => a.name).join(", ")}`, "error");
+                }
+                if (current === name)
+                    return notice(`already on agent "${name}"`);
+                if (host.isRunning?.())
+                    return notice("agent is running — wait or Esc first", "warn");
+                host.updateConfig?.({ agent: name });
+                host.config = { ...host.config, agent: name };
+                host.replaceAgent(null); // fresh agent with the new def; old conversation ends here
+                notice(`agent → ${name} (${def.mode}) — conversation reset; /sessions can resume the previous one`);
+            },
+        },
+        {
+            name: "/init",
+            description: "create an AGENTS.md template in this project",
+            run(_slash, host, notice) {
+                const target = join(host.config.workdir, "AGENTS.md");
+                if (existsSync(target)) {
+                    notice(`AGENTS.md already exists: ${target}`, "warn");
+                    return;
+                }
+                writeFileSync(target, agentsMdTemplate(host.config.workdir), "utf8");
+                notice(`created ${target} — review and commit it`);
+            },
+        },
         {
             name: "/sessions",
             description: "list saved sessions — /sessions resume <id|last>",
@@ -147,8 +312,115 @@ export function coreCommands() {
                 notice(formatSessions(listSessions(host.config.workdir)));
             },
         },
+        {
+            name: "/commands",
+            description: "list all commands (builtin + custom) — /commands <name> to inspect",
+            run(slash, host, notice) {
+                const all = BUILTIN_COMMANDS.map((c) => ({
+                    name: c.name,
+                    desc: c.description,
+                    source: c.source,
+                }));
+                const custom = discoverCustomCommands(host.config.workdir).map((c) => ({
+                    name: "/commands " + c.name,
+                    desc: c.description,
+                    source: c.source,
+                }));
+                const combined = [...all, ...custom];
+                if (!slash.arg) {
+                    // List mode — grouped by source.
+                    const bySource = {};
+                    for (const c of combined)
+                        bySource[c.source] = (bySource[c.source] ?? []).concat(c);
+                    const sections = Object.entries(bySource)
+                        .sort(([a], [b]) => a.localeCompare(b))
+                        .map(([src, cmds]) => `  ${src}:\n${cmds.map((c) => `    ${c.name}  ${c.desc}`).join("\n")}`);
+                    notice(`commands:\n${sections.join("\n\n")}`);
+                    return;
+                }
+                // Inspect mode — /commands <name>
+                const name = slash.arg.trim().toLowerCase();
+                const customCmd = custom.find((c) => c.name === "/commands " + name || c.name === "/commands " + name.slice(1));
+                if (customCmd) {
+                    // Full info for custom command
+                    const cmd = discoverCustomCommands(host.config.workdir).find((c) => "/commands " + c.name === customCmd.name);
+                    if (!cmd)
+                        return;
+                    notice(`command: ${cmd.name}\n` +
+                        `description: ${cmd.description}\n` +
+                        `exec: ${cmd.exec ?? "prompt"}\n` +
+                        `source: ${cmd.source} — ${cmd.filePath}\n` +
+                        (cmd.args ? `args: ${cmd.args.join(", ")}\n` : "") +
+                        `\n${cmd.body.slice(0, 400)}\n` +
+                        (cmd.body.length > 400 ? "\n… (truncated)" : ""));
+                    return;
+                }
+                const builtin = BUILTIN_COMMANDS.find((c) => c.name === "/" + name || c.name === "/commands " + name);
+                if (builtin) {
+                    notice(`${builtin.name}: ${builtin.description}\nusage: ${builtin.usage}`);
+                    return;
+                }
+                notice(`command "/${name}" not found`, "warn");
+            },
+        },
+        {
+            name: "/export",
+            description: "export session transcript: /export [md|json] — writes to workdir/scoder-export.{md|json}",
+            run(slash, host, notice) {
+                const items = host.transcriptItems ? host.transcriptItems() : [];
+                if (items.length === 0) {
+                    notice("no transcript to export", "warn");
+                    return;
+                }
+                const fmt = slash.arg.trim().toLowerCase() || "md";
+                if (fmt !== "md" && fmt !== "json") {
+                    notice("usage: /export [md|json]", "warn");
+                    return;
+                }
+                const content = exportTranscript(items, fmt);
+                const fileName = `scoder-export.${fmt}`;
+                const filePath = join(host.config.workdir, fileName);
+                try {
+                    writeFileSync(filePath, "\ufeff" + content, "utf8");
+                    notice(`exported ${items.length} items → ${filePath}`);
+                }
+                catch (e) {
+                    notice(`export failed: ${e.message}`, "error");
+                }
+            },
+        },
+        {
+            name: "/search",
+            description: "search transcript: /search <query> — shows snippets; TUI jumps to result",
+            run(slash, host, notice) {
+                if (!slash.arg.trim()) {
+                    notice("usage: /search <query>", "warn");
+                    return;
+                }
+                const items = host.transcriptItems ? host.transcriptItems() : [];
+                if (items.length === 0) {
+                    notice("no transcript to search", "warn");
+                    return;
+                }
+                const matches = findInTranscript(items, slash.arg);
+                if (matches.length === 0) {
+                    notice(`no results for "${slash.arg.trim()}"`, "warn");
+                    return;
+                }
+                notice(`${matches.length} match${matches.length > 1 ? "es" : ""} in transcript:\n` +
+                    matches.slice(0, 20).map((m) => `  [${m.index}] ${m.kind}: ${m.snippet}`).join("\n"));
+                // TUI: jump to first result
+                if (host.selectTranscriptItem && matches.length > 0) {
+                    host.selectTranscriptItem(matches[0].index);
+                }
+            },
+        },
     ];
 }
+/** Merged catalog of builtin command metadata — /help & completion read this. */
+export function commandCatalog() {
+    return BUILTIN_COMMANDS.map((def) => ({ ...def }));
+}
 /** Clone config với permissionMode mới (host.config thay thế được). */
 function withPermissionMode(cfg, mode) {
     return { ...cfg, permissionMode: mode };
@@ -159,11 +431,14 @@ function withPermissionMode(cfg, mode) {
  * /diff; REPL: không có) TRƯỚC khi gọi hàm này.
  */
 export async function dispatchCommand(input, host, notice, extra = []) {
-    const m = /^\/([a-zA-Z][a-zA-Z0-9]*)(?:\s+(.*\S))?\s*$/.exec(input.trim());
+    const m = /^\/([a-zA-Z][a-zA-Z0-9-]*)(?:\s+([\s\S]*\S))?\s*$/.exec(input.trim());
     if (!m)
         return { handled: false, outcome: null };
-    const cmd = "/" + m[1].toLowerCase();
+    const raw = "/" + m[1].toLowerCase();
     const arg = m[2] ?? "";
+    // Resolve aliases → canonical command (e.g. /quit → /exit).
+    const resolved = resolveCommandDef(raw);
+    const cmd = resolved?.name ?? raw;
     const slash = { cmd, arg };
     if (cmd === "/exit" || cmd === "/quit")
         return { handled: true, outcome: { quit: true } };
@@ -172,6 +447,19 @@ export async function dispatchCommand(input, host, notice, extra = []) {
         host.replaceAgent(null);
         return { handled: true, outcome: { notice: "conversation cleared — context reset" } };
     }
+    const custom = discoverCustomCommands(host.config.workdir);
+    const customMatch = custom.find((c) => `/${c.name.toLowerCase()}` === cmd || c.aliases.some((a) => `/${a.toLowerCase().replace(/^\//, "")}` === cmd));
+    if (customMatch) {
+        if (customMatch.exec === "shell") {
+            notice(`custom command "${customMatch.name}" declares shell execution; run it explicitly through a reviewed agent task`, "warn");
+        }
+        else {
+            const prompt = runCustomCommand(customMatch, arg);
+            notice(`custom command "${customMatch.name}"`, "info");
+            return { handled: true, outcome: { task: prompt } };
+        }
+        return { handled: true, outcome: {} };
+    }
     const entry = [...extra, ...coreCommands()].find((c) => c.name === cmd);
     if (!entry) {
         notice(`unknown command ${cmd} — try /help`, "error");