indusagi-coding-agent 0.2.8 → 0.2.9

package/src/console/slash/builtins.ts

@@ -0,0 +1,81 @@
+/**
+ * The built-in slash catalog — the single ordered source of truth.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { gatherSkillCards, loadMacros } from "../../briefing/index.js";
+import type { SlashCommand } from "../contract.js";
+import { FAMILY } from "./commands/shared.js";
+import { buildDynamicCommands } from "./commands/dynamic.js";
+import { integrationCommands } from "./commands/integrations.js";
+import { transcriptCommands } from "./commands/transcript.js";
+import { workbenchCommands } from "./commands/workbench.js";
+
+const PROJECT_DIR = ".indusagi";
+
+function dynamicRoots() {
+  const home = homedir();
+  const cwd = process.cwd();
+  return {
+    skills: [
+      { dir: join(cwd, PROJECT_DIR, "skills"), origin: "project" as const },
+      { dir: join(home, PROJECT_DIR, "skills"), origin: "user" as const }
+    ],
+    macros: [
+      { dir: join(cwd, PROJECT_DIR, "commands"), origin: "project" as const, label: "project" },
+      { dir: join(home, PROJECT_DIR, "commands"), origin: "user" as const, label: "user" }
+    ]
+  };
+}
+
+function discoverDynamicSources() {
+  const roots = dynamicRoots();
+  let skills: Array<{ name: string; location: string }> = [];
+  try {
+    skills = gatherSkillCards(roots.skills).cards.slice();
+  } catch {
+    skills = [];
+  }
+  const templates: Array<{ name: string; source: string }> = [];
+  const claimed = new Set<string>();
+  for (const root of roots.macros) {
+    let loaded: Array<{ name: string; source: string }> = [];
+    try {
+      loaded = loadMacros(root.dir, { origin: root.origin, label: root.label });
+    } catch {
+      loaded = [];
+    }
+    for (const macro of loaded) {
+      if (claimed.has(macro.name)) continue;
+      claimed.add(macro.name);
+      templates.push(macro);
+    }
+  }
+  return { skills, templates };
+}
+
+const staticCommands: SlashCommand[] = [
+  ...transcriptCommands,
+  ...workbenchCommands,
+  ...integrationCommands
+];
+
+const reservedTokens = new Set<string>();
+for (const command of staticCommands) {
+  reservedTokens.add(command.name.toLowerCase());
+  for (const alias of command.aliases ?? []) reservedTokens.add(alias.toLowerCase());
+}
+
+const dynamicCommands = buildDynamicCommands(discoverDynamicSources()).filter(
+  (command) => !reservedTokens.has(command.name.toLowerCase())
+);
+
+/**
+ * The built-in catalog — every command row in listing order.
+ */
+export const SLASH_COMMANDS: readonly SlashCommand[] = [
+  ...staticCommands,
+  ...dynamicCommands
+];
+
+export { FAMILY };

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

@@ -0,0 +1,83 @@
+/**
+ * Dynamic slash commands — capability cards and prompt templates as registry rows.
+ */
+import { applyMacros } from "../../../briefing/index.js";
+import type { Macro, SkillCard } from "../../../briefing/index.js";
+import type { SlashCommand } from "../../contract.js";
+
+const SKILL_PREFIX = "skill:";
+const SUMMARY_BUDGET = 88;
+
+function clampSummary(text: string) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  if (oneLine.length <= SUMMARY_BUDGET) return oneLine;
+  return `${oneLine.slice(0, SUMMARY_BUDGET - 1).trimEnd()}…`;
+}
+
+function escapeAttr(value: string) {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function skillInvocationBlock(card: SkillCard, body: string) {
+  const opener = `<skill name="${escapeAttr(card.name)}" location="${escapeAttr(card.location)}">`;
+  return `${opener}\n${body}\n</skill>`;
+}
+
+function skillCommand(card: SkillCard): SlashCommand {
+  const name = `${SKILL_PREFIX}${card.name}`;
+  return {
+    name,
+    summary: clampSummary(card.description),
+    family: "skill",
+    takesArgs: true,
+    run(ctx) {
+      const body = ctx.args.trim();
+      return { kind: "prompt", text: skillInvocationBlock(card, body) };
+    }
+  };
+}
+
+function templateCommand(macro: Macro): SlashCommand {
+  return {
+    name: macro.name,
+    summary: clampSummary(macro.description),
+    family: "template",
+    takesArgs: true,
+    run(ctx) {
+      const text = applyMacros(macro.body, ctx.args);
+      return { kind: "prompt", text };
+    }
+  };
+}
+
+/**
+ * The discovered material a dynamic catalog is built from.
+ */
+export interface DynamicCommandSources {
+  readonly skills?: readonly SkillCard[];
+  readonly templates?: readonly Macro[];
+}
+
+/**
+ * Project discovered skills and templates into {@link SlashCommand} rows.
+ */
+export function buildDynamicCommands(sources: DynamicCommandSources = {}): SlashCommand[] {
+  const rows: SlashCommand[] = [];
+  const claimed = new Set<string>();
+  for (const card of sources.skills ?? []) {
+    const command = skillCommand(card);
+    if (claimed.has(command.name)) continue;
+    claimed.add(command.name);
+    rows.push(command);
+  }
+  for (const macro of sources.templates ?? []) {
+    if (claimed.has(macro.name)) continue;
+    claimed.add(macro.name);
+    rows.push(templateCommand(macro));
+  }
+  return rows;
+}