indusagi-coding-agent 0.2.5 → 0.2.9

package/src/console/slash/commands/shared.ts

@@ -0,0 +1,75 @@
+/**
+ * Shared slash-command helpers — the small, pure toolkit every command group is written against.
+ */
+import type { SlashContext, SlashOutcome, StatusMessage } from "../../contract.js";
+
+/**
+ * The family labels the catalog groups commands under.
+ */
+export const FAMILY = {
+  composio: "composio",
+  memory: "memory",
+  scopedModels: "models-for",
+  theme: "theme"
+} as const;
+
+/** The settled "command ran, nothing more to do" outcome. */
+export const HANDLED: SlashOutcome = { kind: "handled" };
+
+/** Mint an info-tone status toast. */
+export function info(text: string): StatusMessage {
+  return { kind: "info", text };
+}
+
+/** Mint a warning-tone status toast (used for usage hints on bad args). */
+export function warn(text: string): StatusMessage {
+  return { kind: "warning", text };
+}
+
+/**
+ * Split a family command's argument string into a leading sub-command verb and the remainder.
+ */
+export function splitVerb(args: string): { verb: string; rest: string } {
+  const trimmed = args.trim();
+  if (trimmed.length === 0) return { verb: "", rest: "" };
+  const gap = trimmed.search(/\s/);
+  if (gap === -1) return { verb: trimmed.toLowerCase(), rest: "" };
+  return {
+    verb: trimmed.slice(0, gap).toLowerCase(),
+    rest: trimmed.slice(gap + 1).trim()
+  };
+}
+
+/**
+ * One sub-command of a command family.
+ */
+export interface SubCommand {
+  readonly verb: string;
+  readonly describe: string;
+  run(ctx: SlashContext, rest: string): SlashOutcome;
+}
+
+/**
+ * Build a family command's `run` from a sub-command table.
+ */
+export function familyRunner(family: string, subs: readonly SubCommand[]): (ctx: SlashContext) => SlashOutcome {
+  const table = new Map(subs.map((sub) => [sub.verb, sub]));
+  const usage = () =>
+    warn(
+      `/${family} expects: ${subs.map((sub) => `${sub.verb} (${sub.describe})`).join(", ")}`
+    );
+  return (ctx) => {
+    const { verb, rest } = splitVerb(ctx.args);
+    if (verb.length === 0) {
+      ctx.setStatus(usage());
+      return HANDLED;
+    }
+    const sub = table.get(verb);
+    if (sub === void 0) {
+      ctx.setStatus(warn(`/${family}: unrecognised action "${verb}".`));
+      ctx.setStatus(usage());
+      return HANDLED;
+    }
+    return sub.run(ctx, rest);
+  };
+}

package/src/console/slash/commands/transcript.ts

@@ -0,0 +1,263 @@
+/**
+ * Slash commands that operate on the session transcript (clear/new, compact, resume, stats, name, reload, quit).
+ */
+import type { SlashCommand } from "../../contract.js";
+import { HANDLED, info, warn } from "./shared.js";
+
+function wipeView(ctx: { dispatch: (e: any) => void; setStatus: (s: any) => void }) {
+  ctx.dispatch({ type: "rows:set", rows: [] });
+  ctx.dispatch({ type: "blocks:clear" });
+  ctx.dispatch({ type: "status:clear" });
+}
+
+function startNewSession(ctx: any, toast: string) {
+  wipeView(ctx);
+  ctx.setStatus(info(toast));
+  void ctx.conductor.newSession().catch(() => {
+    ctx.setStatus(warn("Could not start a new session."));
+  });
+  return HANDLED;
+}
+
+function statsMarkdown(stats: any, name: string | undefined): string {
+  const dollars = `$${stats.cost.toFixed(4)}`;
+  const t = stats.tokens;
+  const rows: Array<[string, string]> = [
+    ["Session", name ? `${name} (${stats.sessionId})` : stats.sessionId],
+    ["Messages", String(stats.totalMessages)],
+    ["User / assistant", `${stats.userMessages} / ${stats.assistantMessages}`],
+    ["Tool calls / results", `${stats.toolCalls} / ${stats.toolResults}`],
+    ["Tokens (in / out)", `${t.input} / ${t.output}`],
+    ["Tokens (cache r/w)", `${t.cacheRead} / ${t.cacheWrite}`],
+    ["Tokens (total)", String(t.total)],
+    ["Cost", dollars]
+  ];
+  const body = rows.map(([k, v]) => `| ${k} | ${v} |`).join("\n");
+  return `| Field | Value |
+| --- | --- |
+${body}`;
+}
+
+const clearCommand: SlashCommand = {
+  name: "clear",
+  summary: "Clear the conversation and start a new session",
+  aliases: ["reset"],
+  run(ctx) {
+    return startNewSession(ctx, "Started a new session.");
+  }
+};
+
+const newCommand: SlashCommand = {
+  name: "new",
+  summary: "Start a fresh session",
+  run(ctx) {
+    return startNewSession(ctx, "Started a new session.");
+  }
+};
+
+const compactCommand: SlashCommand = {
+  name: "compact",
+  summary: "Condense the conversation context",
+  aliases: ["condense", "summarize-context"],
+  takesArgs: true,
+  run(ctx) {
+    const instructions = ctx.args.trim();
+    const busyText =
+      instructions.length > 0
+        ? `Compacting with guidance: ${instructions} — Esc to cancel`
+        : "Compacting conversation context... Press Esc to cancel.";
+    ctx.setStatus({ kind: "busy", text: busyText });
+    void (async () => {
+      try {
+        if (instructions.length > 0) {
+          await ctx.conductor.executeBash(
+            `printf '%s' ${JSON.stringify(`Compaction guidance: ${instructions}`)}`
+          );
+        }
+        switch (await ctx.conductor.condense()) {
+          case "condensed":
+            ctx.setStatus(
+              info(
+                instructions.length > 0
+                  ? "Context condensed (guidance recorded for the agent)."
+                  : "Context condensed."
+              )
+            );
+            break;
+          case "nothing":
+            ctx.setStatus(warn("Nothing to compact yet."));
+            break;
+          case "cancelled":
+            ctx.setStatus(warn("Compaction cancelled."));
+            break;
+          case "busy":
+            ctx.setStatus(warn("A turn is running — press Esc to stop it first, then /compact."));
+            break;
+          case "failed":
+            ctx.setStatus(warn("Compaction failed; the transcript is unchanged."));
+            break;
+        }
+      } catch {
+        ctx.setStatus(warn("Compaction failed; the transcript is unchanged."));
+      }
+    })();
+    return HANDLED;
+  }
+};
+
+const resumeCommand: SlashCommand = {
+  name: "resume",
+  summary: "Resume a persisted session",
+  aliases: ["sessions"],
+  run(ctx) {
+    ctx.openModal("sessions");
+    return HANDLED;
+  }
+};
+
+const sessionCommand: SlashCommand = {
+  name: "session",
+  summary: "Show live session statistics (ids, counts, tokens, cost)",
+  run(ctx) {
+    const stats = ctx.conductor.stats();
+    const name = ctx.conductor.sessionName();
+    const block = {
+      id: `session-stats-${Date.now().toString(36)}`,
+      kind: "changelog",
+      title: name ? `Session: ${name}` : "Session statistics",
+      markdown: statsMarkdown(stats, name),
+      timestamp: Date.now()
+    };
+    ctx.appendBlock(block);
+    ctx.setStatus(
+      info(
+        `${stats.totalMessages} messages, ${stats.tokens.total} tokens, $${stats.cost.toFixed(4)}.`
+      )
+    );
+    return HANDLED;
+  }
+};
+
+const costCommand: SlashCommand = {
+  name: "cost",
+  summary: "Show session cost and token usage",
+  run(ctx) {
+    const stats = ctx.conductor.stats();
+    const t = stats.tokens;
+    const rows: Array<[string, string]> = [
+      ["Total cost", `$${stats.cost.toFixed(4)}`],
+      ["Total tokens", String(t.total)],
+      ["Input / output", `${t.input} / ${t.output}`],
+      ["Cache read / write", `${t.cacheRead} / ${t.cacheWrite}`]
+    ];
+    const markdown = `| Field | Value |
+| --- | --- |
+${rows.map(([k, v]) => `| ${k} | ${v} |`).join("\n")}`;
+    const block = {
+      id: `session-cost-${Date.now().toString(36)}`,
+      kind: "changelog",
+      title: "Session cost",
+      markdown,
+      timestamp: Date.now()
+    };
+    ctx.appendBlock(block);
+    ctx.setStatus(info(`$${stats.cost.toFixed(4)} · ${t.total} tokens`));
+    return HANDLED;
+  }
+};
+
+const forkCommand: SlashCommand = {
+  name: "branch",
+  summary: "Branch the transcript from a prior turn",
+  aliases: ["fork"],
+  run(ctx) {
+    ctx.openModal("userTurns");
+    return HANDLED;
+  }
+};
+
+const treeCommand: SlashCommand = {
+  name: "timeline",
+  summary: "Navigate the transcript tree",
+  aliases: ["tree"],
+  run(ctx) {
+    ctx.openModal("tree");
+    return HANDLED;
+  }
+};
+
+const nameCommand: SlashCommand = {
+  name: "name",
+  summary: "Name the session, or show the current name",
+  takesArgs: true,
+  run(ctx) {
+    const label = ctx.args.trim();
+    if (label.length === 0) {
+      const current = ctx.conductor.sessionName();
+      ctx.setStatus(
+        current === void 0 || current.length === 0
+          ? info("This session has no name. Set one with /name <label>.")
+          : info(`Current session name: ${current}`)
+      );
+      return HANDLED;
+    }
+    ctx.conductor.setSessionName(label);
+    ctx.setStatus(info(`Session named "${label}".`));
+    return HANDLED;
+  }
+};
+
+const reloadCommand: SlashCommand = {
+  name: "reload",
+  summary: "Reload session resources",
+  run(ctx) {
+    const leaf = ctx.conductor.snapshot().head.leaf;
+    if (leaf === null) {
+      ctx.setStatus(info("Session is empty; nothing to reload."));
+      return HANDLED;
+    }
+    ctx.setStatus({ kind: "busy", text: "Reloading session resources..." });
+    void (async () => {
+      try {
+        await ctx.conductor.navigateTree(leaf);
+        ctx.setStatus(info("Reloaded session resources."));
+      } catch {
+        ctx.setStatus(warn("Could not reload session resources."));
+      }
+    })();
+    return HANDLED;
+  }
+};
+
+const quitCommand: SlashCommand = {
+  name: "quit",
+  summary: "Leave the interactive console",
+  run(ctx) {
+    ctx.requestExit();
+    return HANDLED;
+  }
+};
+
+const exitCommand: SlashCommand = {
+  name: "exit",
+  summary: "Leave the interactive console",
+  run(ctx) {
+    ctx.requestExit();
+    return HANDLED;
+  }
+};
+
+export const transcriptCommands: SlashCommand[] = [
+  clearCommand,
+  newCommand,
+  compactCommand,
+  resumeCommand,
+  sessionCommand,
+  costCommand,
+  forkCommand,
+  treeCommand,
+  nameCommand,
+  reloadCommand,
+  quitCommand,
+  exitCommand
+];

package/src/console/slash/commands/workbench.ts

@@ -0,0 +1,246 @@
+/**
+ * Workbench slash commands (model pickers, settings, help, keys, changelog, debug, plan, thinking).
+ */
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { SlashCommand } from "../../contract.js";
+import { SLASH_COMMANDS } from "../builtins.js";
+import { FAMILY, HANDLED, familyRunner, info, warn } from "./shared.js";
+
+function block(slug: string, title: string, markdown: string) {
+  return {
+    id: `${slug}-${Date.now().toString(36)}`,
+    kind: "changelog",
+    title,
+    markdown,
+    timestamp: Date.now()
+  };
+}
+
+async function helpBlock() {
+  const lines = SLASH_COMMANDS.map((c) => {
+    const alts = c.aliases && c.aliases.length > 0 ? ` _(/${c.aliases.join(", /")})_` : "";
+    return `- **/${c.name}**${alts} — ${c.summary}`;
+  });
+  const body = [
+    `${SLASH_COMMANDS.length} commands available. Type \`/\` to complete.`,
+    "",
+    ...lines
+  ].join("\n");
+  return block("help", "Commands", body);
+}
+
+function hotkeysBlock() {
+  const rows = HOTKEYS.map(([chord, effect]) => `| \`${chord}\` | ${effect} |`);
+  const body = [
+    "| Shortcut | Action |",
+    "| --- | --- |",
+    ...rows
+  ].join("\n");
+  return block("hotkeys", "Keyboard shortcuts", body);
+}
+
+function readChangelog(cwd: string) {
+  for (const name of CHANGELOG_NAMES) {
+    try {
+      const text = readFileSync(join(cwd, name), "utf8");
+      if (text.trim().length > 0) return text;
+    } catch {
+      // ignore
+    }
+  }
+  return null;
+}
+
+function runChangelog(ctx: any) {
+  const markdown = readChangelog(process.cwd());
+  ctx.appendBlock(
+    markdown !== null
+      ? block("changelog", "Changelog", markdown)
+      : block("changelog", "What's new", CHANGELOG_FALLBACK)
+  );
+  return HANDLED;
+}
+
+function runDebug(ctx: any) {
+  ctx.dispatch({ type: "toggle:reasoning" });
+  const stats = ctx.conductor.stats();
+  const messages = ctx.conductor.messages();
+  const snapshot = ctx.conductor.snapshot();
+  const records: any[] = [
+    {
+      type: "session",
+      at: new Date().toISOString(),
+      sessionId: stats.sessionId,
+      modelId: snapshot.modelId,
+      phase: snapshot.phase,
+      stats
+    },
+    ...messages.map((message: any, index: number) => ({
+      type: "message",
+      index,
+      role: message.role ?? "unknown",
+      content: message.content
+    }))
+  ];
+  const jsonl = records.map((r) => JSON.stringify(r)).join("\n") + "\n";
+  try {
+    const dir = mkdtempSync(join(tmpdir(), "indus-debug-"));
+    const path = join(dir, `session-${stats.sessionId || "unknown"}.jsonl`);
+    writeFileSync(path, jsonl, "utf8");
+    ctx.setStatus(info(`Diagnostics written to ${path}`));
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    ctx.setStatus(warn(`Could not write the diagnostics log (${detail}).`));
+  }
+  return HANDLED;
+}
+
+function runPlan(ctx: any) {
+  const wasPlan = ctx.conductor.permissionMode() === "plan";
+  const now = ctx.conductor.togglePlanMode(!wasPlan);
+  ctx.setStatus(
+    now === "plan"
+      ? info("Plan mode ON — read-only research; mutating tools are blocked. Run /plan again to leave.")
+      : info(`Plan mode OFF — permission mode is now ${now}.`)
+  );
+  return HANDLED;
+}
+
+const SCOPED_MODEL_VERBS = [
+  {
+    verb: "edit",
+    describe: "open the per-scope routing editor",
+    run: (ctx: any) => {
+      ctx.openModal("scopedModels");
+      return HANDLED;
+    }
+  },
+  {
+    verb: "show",
+    describe: "review the active per-scope assignments",
+    run: (ctx: any) => {
+      ctx.openModal("scopedModels", { focus: "summary" });
+      return HANDLED;
+    }
+  },
+  {
+    verb: "reset",
+    describe: "clear every per-scope override",
+    run: (ctx: any) => {
+      ctx.openModal("scopedModels", { intent: "reset" });
+      ctx.setStatus(info("Per-scope model overrides cleared."));
+      return HANDLED;
+    }
+  }
+];
+
+const runScopedModels = familyRunner(FAMILY.scopedModels, SCOPED_MODEL_VERBS);
+
+const HOTKEYS: Array<[string, string]> = [
+  ["Enter", "Submit the current turn"],
+  ["Shift+Enter", "Insert a soft newline in the composer"],
+  ["Esc", "Dismiss an overlay / abort the in-flight turn"],
+  ["Esc Esc", "Open the transcript-tree navigator"],
+  ["Shift+Tab", "Cycle permission mode (default → accept-edits → plan → bypass)"],
+  ["Tab", "Accept the highlighted completion"],
+  ["Ctrl+C", "Interrupt the running turn"],
+  ["Ctrl+T", "Toggle reasoning / thinking rows"],
+  ["/thinking", "Cycle thinking effort level (off → low → medium)"],
+  ["Ctrl+V", "Attach an image from the clipboard"],
+  ["Ctrl+G", "Edit the composer in your external editor"],
+  ["Ctrl+O", "Expand or collapse full tool output"],
+  ["Ctrl+L", "Open the model picker"],
+  ["Ctrl+R", "Open the session resume list"],
+  ["Ctrl+N / Ctrl+P", "Cycle the active model"],
+  ["Ctrl+A / Ctrl+E", "Jump to start / end of the line"],
+  ["Ctrl+U", "Clear the composer line (twice: exit)"],
+  ["Ctrl+J", "Insert a newline"],
+  ["Ctrl+Z", "Suspend the process"],
+  ["Alt+Up", "Pull the newest queued input back into the composer"],
+  ["Ctrl+X", "Run the newest queued message NOW (stops the current run)"],
+  ["! <cmd>", "Run a shell command (kept in context)"],
+  ["!! <cmd>", "Run a shell command (excluded from context)"]
+];
+
+const CHANGELOG_NAMES = ["CHANGELOG.md", "CHANGELOG", "changelog.md"];
+
+const CHANGELOG_FALLBACK = [
+  "No `CHANGELOG.md` was found at the workspace root.",
+  "",
+  "Recent highlights in this build:",
+  "- Model and per-scope routing pickers reachable from the composer.",
+  "- `/help` and `/keys` render live command and shortcut references.",
+  "- Colour scheme switches inline between **saffron**, **midnight**, and **daylight**."
+].join("\n");
+
+export const workbenchCommands: SlashCommand[] = [
+  {
+    name: "model",
+    summary: "Switch the model bound to this session",
+    aliases: ["models"],
+    run: (ctx) => {
+      ctx.openModal("models");
+      return HANDLED;
+    }
+  },
+  {
+    name: "models-for",
+    summary: "Edit, show, or reset per-scope model routing",
+    aliases: ["scoped-models"],
+    family: FAMILY.scopedModels,
+    takesArgs: true,
+    run: runScopedModels
+  },
+  {
+    name: "settings",
+    summary: "Open the settings overlay",
+    run: (ctx) => {
+      ctx.openModal("settings");
+      return HANDLED;
+    }
+  },
+  {
+    name: "help",
+    summary: "List the available commands",
+    aliases: ["?"],
+    run: async (ctx) => {
+      ctx.appendBlock(await helpBlock());
+      return HANDLED;
+    }
+  },
+  {
+    name: "keys",
+    summary: "Show the keyboard shortcut map",
+    aliases: ["hotkeys"],
+    run: (ctx) => {
+      ctx.appendBlock(hotkeysBlock());
+      return HANDLED;
+    }
+  },
+  {
+    name: "whats-new",
+    summary: "Show what changed in this build",
+    aliases: ["changelog"],
+    run: runChangelog
+  },
+  {
+    name: "plan",
+    summary: "Toggle plan mode (read-only research; mutating tools are blocked)",
+    run: runPlan
+  },
+  {
+    name: "thinking",
+    summary: "Cycle thinking effort level (off → low → medium → off)",
+    run: (ctx) => {
+      ctx.conductor.cycleThinkingLevel();
+      return HANDLED;
+    }
+  },
+  {
+    name: "debug",
+    summary: "Write a session diagnostics log and toggle verbose view",
+    run: runDebug
+  }
+];

package/src/console/slash/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Slash subsystem — public barrel.
+ */
+export { SLASH_COMMANDS, FAMILY } from "./builtins.js";
+export { buildRegistry, tokensOf, findCommand, matchPrefix, listFamilies, commandsInFamily } from "./registry.js";
+export { SLASH_PREFIX, looksLikeSlash, parseSlash, resolveSlash } from "./resolve.js";
+export type { SlashLine, SlashResolution } from "./resolve.js";
+import { buildRegistry } from "./registry.js";
+import { SLASH_COMMANDS } from "./builtins.js";
+import type { SlashRegistry } from "../contract.js";
+
+/**
+ * The built-in catalog pre-folded into a resolved {@link SlashRegistry}.
+ */
+export const DEFAULT_SLASH_REGISTRY: SlashRegistry = buildRegistry(SLASH_COMMANDS);

package/src/console/slash/registry.ts

@@ -0,0 +1,70 @@
+/**
+ * Slash registry assembly — fold a command list into the resolved registry.
+ */
+import type { SlashCommand, SlashRegistry } from "../contract.js";
+
+/**
+ * Every token a command answers to: its canonical name plus any aliases.
+ */
+export function tokensOf(command: SlashCommand): string[] {
+  return [command.name, ...(command.aliases ?? [])];
+}
+
+/**
+ * Fold an ordered command list into a resolved {@link SlashRegistry}.
+ */
+export function buildRegistry(commands: readonly SlashCommand[]): SlashRegistry {
+  const index = new Map<string, SlashCommand>();
+  for (const command of commands) {
+    for (const token of tokensOf(command)) {
+      const key = token.toLowerCase();
+      const existing = index.get(key);
+      if (existing !== void 0 && existing !== command) {
+        throw new Error(
+          `slash registry: token "${key}" is claimed by both "${existing.name}" and "${command.name}"`
+        );
+      }
+      index.set(key, command);
+    }
+  }
+  return { commands, index };
+}
+
+/**
+ * Resolve a single token (canonical or alias) to its command, or `undefined`.
+ */
+export function findCommand(registry: SlashRegistry, token: string): SlashCommand | undefined {
+  const bare = token.startsWith("/") ? token.slice(1) : token;
+  return registry.index.get(bare.toLowerCase());
+}
+
+/**
+ * The commands whose name or alias begins with a partial token, in registry order.
+ */
+export function matchPrefix(registry: SlashRegistry, partial: string): SlashCommand[] {
+  const needle = partial.toLowerCase();
+  if (needle.length === 0) return [...registry.commands];
+  return registry.commands.filter(
+    (command) => tokensOf(command).some((token) => token.toLowerCase().startsWith(needle))
+  );
+}
+
+/**
+ * The distinct family labels present in the registry, in first-seen order.
+ */
+export function listFamilies(registry: SlashRegistry): string[] {
+  const seen: string[] = [];
+  for (const command of registry.commands) {
+    if (command.family !== void 0 && !seen.includes(command.family)) {
+      seen.push(command.family);
+    }
+  }
+  return seen;
+}
+
+/**
+ * The commands belonging to a family, in registry order.
+ */
+export function commandsInFamily(registry: SlashRegistry, family: string): SlashCommand[] {
+  return registry.commands.filter((command) => command.family === family);
+}