supipowers 1.2.6 → 1.5.0

package/src/commands/generate.ts

@@ -0,0 +1,200 @@
+import type { Platform } from "../platform/types.js";
+import type { DriftCheckResult } from "../types.js";
+import { notifyInfo, notifyError, notifyWarning } from "../notifications/renderer.js";
+import {
+  loadState,
+  saveState,
+  discoverDocFiles,
+  getHeadCommit,
+  checkDocDrift,
+} from "../docs/drift.js";
+
+// ── Multi-select UI ───────────────────────────────────────────
+
+async function selectDocFiles(
+  ctx: any,
+  discovered: string[],
+): Promise<string[]> {
+  const selected = new Set<string>();
+
+  while (true) {
+    const options = discovered.map(
+      (f) => `${selected.has(f) ? "◉" : "○"} ${f}`,
+    );
+    options.push("─── Add manually ───");
+    options.push("─── Done ───");
+
+    const choice = await ctx.ui.select("Track these docs", options, {
+      helpText: `${selected.size} selected · Toggle files · Done when ready`,
+    });
+
+    if (choice === undefined || choice === null || choice === "─── Done ───") break;
+
+    if (choice === "─── Add manually ───") {
+      const filePath = await ctx.ui.input("File path (relative to project root)");
+      if (filePath) selected.add(filePath);
+      continue;
+    }
+
+    const file = choice.replace(/^[○◉] /, "");
+    if (selected.has(file)) {
+      selected.delete(file);
+    } else {
+      selected.add(file);
+    }
+  }
+
+  return [...selected];
+}
+
+// ── Subcommand: docs ──────────────────────────────────────────
+
+async function handleDocs(platform: Platform, ctx: any): Promise<void> {
+  if (!ctx.hasUI) {
+    notifyWarning(ctx, "Doc drift check requires interactive mode");
+    return;
+  }
+
+  const cwd = ctx.cwd;
+  const { paths } = platform;
+  const state = loadState(paths, cwd);
+
+  // First run: discover and select files, then steer main thread for full audit
+  if (state.trackedFiles.length === 0) {
+    const discovered = await discoverDocFiles(platform, cwd);
+    if (discovered.length === 0) {
+      notifyWarning(ctx, "No documentation files found in this repository");
+      return;
+    }
+
+    const selected = await selectDocFiles(ctx, discovered);
+    if (selected.length === 0) {
+      notifyInfo(ctx, "No files selected \u2014 doc tracking not set up");
+      return;
+    }
+
+    // Persist tracked files but leave lastCommit null \u2014 updated after fix starts
+    saveState(paths, cwd, {
+      trackedFiles: selected,
+      lastCommit: null,
+      lastRunAt: new Date().toISOString(),
+    });
+
+    // Steer the main thread to audit and fix docs directly
+    const docList = selected.map((f) => `- \`${f}\``).join("\n");
+    const prompt = [
+      `Check these documentation files for accuracy against the current codebase:`,
+      ``,
+      docList,
+      ``,
+      `<critical>`,
+      `You MUST read skill://create-readme before assessing documentation quality.`,
+      `</critical>`,
+      ``,
+      `Read each documentation file and compare against the current codebase. Look for:`,
+      `1. **Factual inaccuracies**: wrong names, missing parameters, removed features, changed behavior, outdated examples`,
+      `2. **Missing documentation**: new commands, features, config options that exist in code but not in docs`,
+      `3. **Structural gaps**: important sections that should exist based on the codebase but don't`,
+      ``,
+      `For each issue found, fix it directly in the documentation file. Do NOT output JSON or a report \u2014 just fix the files.`,
+      `If documentation is accurate, say so and make no changes.`,
+      ``,
+      `Rules:`,
+      `- Only fix factual inaccuracies and add missing sections for undocumented features`,
+      `- Do NOT rewrite prose, improve wording, or restructure existing content`,
+      `- Preserve each document's existing formatting, tone, and conventions`,
+    ].join("\n");
+    notifyInfo(ctx, "Starting full documentation audit", `${selected.length} file(s) selected`);
+
+    platform.sendMessage(
+      {
+        customType: "supi-generate-docs",
+        content: [{ type: "text", text: prompt }],
+        display: "none",
+      },
+      { deliverAs: "steer", triggerTurn: true },
+    );
+    return;
+  }
+
+  // Subsequent run: headless sub-agent drift check
+  const result = await checkDocDrift(platform, cwd);
+
+  if (!result || !result.drifted) {
+    notifyInfo(ctx, "Docs are up to date", result?.summary ?? "No changes since last check");
+    return;
+  }
+
+  // Build lightweight steer summary from findings
+  const steer = buildSteerSummary(result);
+  notifyInfo(ctx, "Documentation drift detected", `${result.findings.length} finding(s)`);
+
+  // Update state only now \u2014 user has seen findings and we\u2019re about to fix.
+  const head = await getHeadCommit(platform, cwd);
+  const currentState = loadState(paths, cwd);
+  saveState(paths, cwd, { ...currentState, lastCommit: head, lastRunAt: new Date().toISOString() });
+
+  platform.sendMessage(
+    {
+      customType: "supi-generate-docs",
+      content: [{ type: "text", text: steer }],
+      display: "none",
+    },
+    { deliverAs: "steer", triggerTurn: true },
+  );
+}
+
+function buildSteerSummary(result: DriftCheckResult): string {
+  const lines: string[] = ["Documentation drift detected. Please fix the following issues:", ""];
+
+  const byFile = new Map<string, typeof result.findings>();
+  for (const f of result.findings) {
+    if (!byFile.has(f.file)) byFile.set(f.file, []);
+    byFile.get(f.file)!.push(f);
+  }
+
+  for (const [file, findings] of byFile) {
+    lines.push(`### \`${file}\``);
+    for (const f of findings) {
+      lines.push(`- [${f.severity}] ${f.description}`);
+    }
+    lines.push("");
+  }
+
+  lines.push("Read each file, apply the fixes, and write the corrected content.");
+  return lines.join("\n");
+}
+
+// ── Command registration ──────────────────────────────────────
+
+const SUBCOMMANDS = [
+  { name: "docs", description: "Check documentation for drift from codebase" },
+] as const;
+
+export function registerGenerateCommand(platform: Platform): void {
+  platform.registerCommand("supi:generate", {
+    description: "Generation utilities — docs drift detection",
+    getArgumentCompletions(prefix: string) {
+      const lower = prefix.toLowerCase();
+      const matches = SUBCOMMANDS
+        .filter((s) => s.name.startsWith(lower))
+        .map((s) => ({ value: `${s.name} `, label: s.name, description: s.description }));
+      return matches.length > 0 ? matches : null;
+    },
+    async handler(args: string | undefined, ctx: any) {
+      const subcommand = args?.trim().split(/\s+/)[0] ?? "docs";
+
+      switch (subcommand) {
+        case "docs":
+          await handleDocs(platform, ctx);
+          break;
+        default:
+          notifyError(
+            ctx,
+            `Unknown subcommand "${subcommand}"`,
+            `Available: ${SUBCOMMANDS.map((s) => s.name).join(", ")}`,
+          );
+      }
+    },
+  });
+}

package/src/commands/model-picker.ts

@@ -25,20 +25,10 @@ import {
   type GeneratedProvider,
 } from "@oh-my-pi/pi-ai";
 
-// ANSI helpers — we cannot rely on the Theme object passed by ctx.ui.custom()
-// because its shape is internal to OMP and not part of the public API.
-const RESET = "\x1b[0m";
-const BOLD = "\x1b[1m";
-const DIM = "\x1b[2m";
-const CYAN = "\x1b[36m";
-const WHITE = "\x1b[37m";
-const YELLOW = "\x1b[33m";
-const INVERSE = "\x1b[7m";
-
-const accent = (t: string) => `${CYAN}${BOLD}${t}${RESET}`;
-const muted = (t: string) => `${DIM}${t}${RESET}`;
-const bright = (t: string) => `${WHITE}${BOLD}${t}${RESET}`;
-const warn = (t: string) => `${YELLOW}${t}${RESET}`;
+import {
+  RESET, BOLD, DIM, CYAN, INVERSE,
+  accent, muted, bright, warn,
+} from "../platform/tui-colors.js";
 
 const ALL_TAB = "ALL";
 const MAX_VISIBLE = 12;
@@ -232,7 +222,7 @@ export function createModelPicker(
       // Enter → select current model
       if (matchesKey(data, "enter")) {
         if (filteredModels.length > 0) {
-          done(filteredModels[selectedIndex].id);
+          done(`${filteredModels[selectedIndex].provider}/${filteredModels[selectedIndex].id}`);
         }
         return;
       }

package/src/commands/model.ts

@@ -39,7 +39,7 @@ function buildDashboard(
   bridge: ModelPlatformBridge,
 ): string {
   const config = loadModelConfig(paths, cwd);
-  const lines: string[] = ["\n  Model Configuration\n", `  ${"action".padEnd(20)} ${"model".padEnd(24)} ${"thinking".padEnd(10)} source`];
+  const lines: string[] = ["\n  Model Configuration\n", `  ${"action".padEnd(20)} ${"model".padEnd(32)} ${"thinking".padEnd(10)} source`];
 
   let lastCategory: "command" | "sub-agent" | null = null;
   let lastParent: string | undefined = undefined;
@@ -60,7 +60,7 @@ function buildDashboard(
     const sourceDisplay = formatSource(source);
 
     lines.push(
-      `  ${action.id.padEnd(20)} ${modelDisplay.padEnd(24)} ${thinkingDisplay.padEnd(10)} ${sourceDisplay}`,
+      `  ${action.id.padEnd(20)} ${modelDisplay.padEnd(32)} ${thinkingDisplay.padEnd(10)} ${sourceDisplay}`,
     );
 
     lastCategory = action.category;
@@ -181,7 +181,7 @@ async function runModelTUI(platform: Platform, ctx: any): Promise<void> {
   }
 }
 
-async function selectModelFromList(
+export async function selectModelFromList(
   ctx: any,
   currentModel?: string,
 ): Promise<string | null> {
@@ -224,8 +224,7 @@ async function selectModelFromList(
   );
 
   if (!choice) return null;
-  const slashIndex = choice.indexOf("/");
-  return slashIndex >= 0 ? choice.slice(slashIndex + 1) : choice;
+  return choice;
 }
 
 async function selectScope(ctx: any): Promise<"global" | "project" | null> {

package/src/commands/optimize-context.ts

@@ -0,0 +1,202 @@
+import type { Platform, PlatformContext } from "../platform/types.js";
+import {
+  parseSystemPrompt,
+  parseIndividualSkills,
+} from "../context/analyzer.js";
+import {
+  detectTechStack,
+  buildContextReport,
+} from "../context/optimizer.js";
+import type { ContextReport } from "../context/optimizer.js";
+
+function formatTokens(n: number): string {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n);
+}
+
+export function handleOptimizeContext(platform: Platform, ctx: PlatformContext): void {
+  void (async () => {
+    if (!ctx.hasUI) return;
+
+    // 1. Detect tech stack
+    const techStack = await detectTechStack(platform, ctx.cwd);
+
+    // 2. Get system prompt
+    let systemPrompt = "";
+    try {
+      systemPrompt = (ctx as any).getSystemPrompt?.() ?? "";
+    } catch {
+      // getSystemPrompt not available
+    }
+
+    if (!systemPrompt) {
+      ctx.ui.notify("System prompt unavailable", "warning");
+      return;
+    }
+
+    // 3. Parse
+    const sections = parseSystemPrompt(systemPrompt);
+    const skills = parseIndividualSkills(systemPrompt);
+
+    // 4. Build raw report
+    const report = buildContextReport(sections, skills, techStack);
+
+    // 5. Show TUI
+    await showReport(platform, ctx, report);
+  })().catch((err) => {
+    ctx.ui.notify(`Optimize error: ${(err as Error).message}`, "error");
+  });
+}
+
+export function registerOptimizeContextCommand(platform: Platform): void {
+  platform.registerCommand("supi:optimize-context", {
+    description: "Analyze context usage and suggest token optimizations",
+    async handler(_args: string | undefined, ctx: any) {
+      handleOptimizeContext(platform, ctx);
+    },
+  });
+}
+
+// ── Internal ──────────────────────────────────────────────
+
+async function showReport(
+  platform: Platform,
+  ctx: PlatformContext,
+  report: ContextReport,
+): Promise<void> {
+  const techList = [
+    ...report.techStack.languages,
+    ...(report.techStack.runtime ? [report.techStack.runtime] : []),
+    ...report.techStack.frameworks,
+    ...report.techStack.tools,
+  ].join(", ");
+
+  const lines: string[] = [
+    `Tech: ${techList || "unknown"}`,
+    `Current: ~${formatTokens(report.totalTokens)} tokens  |  Target: ~8.0K tokens`,
+    "",
+  ];
+
+  // Skills breakdown
+  if (report.skills.length === 0) {
+    lines.push("No skills detected in system prompt.");
+  } else {
+    const totalSkillTokens = report.skills.reduce((sum, s) => sum + s.tokens, 0);
+    lines.push(`Skills (${report.skills.length} loaded, ~${formatTokens(totalSkillTokens)} tok total):`);
+    lines.push("");
+
+    const sorted = [...report.skills].sort((a, b) => b.tokens - a.tokens);
+    for (const s of sorted) {
+      lines.push(`  ${s.name.padEnd(32)} ~${formatTokens(s.tokens)} tok`);
+    }
+  }
+
+  // Non-skill sections
+  if (report.sections.length > 0) {
+    lines.push("");
+    lines.push("Other sections:");
+    lines.push("");
+
+    for (const sec of report.sections) {
+      const tok = formatTokens(sec.tokens);
+      const note = sec.note ? `  (${sec.note})` : "";
+      lines.push(`  ${sec.label.padEnd(28)} ~${tok} tok${note}`);
+    }
+  }
+
+  const message = lines.join("\n");
+
+  // confirm() may not be available on all platforms
+  const shouldOptimize = ctx.ui.confirm
+    ? await ctx.ui.confirm("Context Optimization", message)
+    : (await ctx.ui.select("Context Optimization", [message, "▶ Optimize with AI", "Close"]))?.includes("Optimize");
+
+  if (!shouldOptimize) return;
+
+  platform.sendMessage(
+    {
+      customType: "optimize-context",
+      content: [{ type: "text", text: buildOptimizationPrompt(report) }],
+      display: "none",
+    },
+    { deliverAs: "steer", triggerTurn: true },
+  );
+}
+
+function buildOptimizationPrompt(report: ContextReport): string {
+  const lines: string[] = [];
+
+  const techList = [
+    ...report.techStack.languages,
+    ...(report.techStack.runtime ? [report.techStack.runtime] : []),
+    ...report.techStack.frameworks,
+    ...report.techStack.tools,
+  ].join(", ");
+
+  lines.push("# Context Optimization Request");
+  lines.push("");
+  lines.push(`Current system prompt is **~${formatTokens(report.totalTokens)} tokens**. Target is **< 8K tokens**.`);
+  lines.push(`Project tech stack: **${techList || "unknown"}**`);
+  lines.push("");
+
+  // Skill inventory
+  if (report.skills.length > 0) {
+    lines.push("## Skills currently loaded");
+    lines.push("");
+    lines.push("| Skill | Tokens |");
+    lines.push("|-------|--------|");
+    const sorted = [...report.skills].sort((a, b) => b.tokens - a.tokens);
+    for (const s of sorted) {
+      lines.push(`| ${s.name} | ~${formatTokens(s.tokens)} |`);
+    }
+    lines.push("");
+  }
+
+  // Section inventory
+  if (report.sections.length > 0) {
+    lines.push("## Other prompt sections");
+    lines.push("");
+    for (const sec of report.sections) {
+      const note = sec.note ? ` — ${sec.note}` : "";
+      lines.push(`- **${sec.label}**: ~${formatTokens(sec.tokens)} tok${note}`);
+    }
+    lines.push("");
+  }
+
+  lines.push("## Your task");
+  lines.push("");
+  lines.push("Classify each loaded skill into one of these actions:");
+  lines.push("");
+  lines.push("| Action | Prompt cost | When to use |");
+  lines.push("|--------|-------------|-------------|");
+  lines.push("| **Keep as skill** | Full content every turn | Essential for this project, needed constantly |");
+  lines.push("| **Convert to rulebook rule** | Name + description only | Relevant but only needed on-demand (load via `rule://`) |");
+  lines.push("| **Convert to TTSR rule** | Zero | Behavioral enforcement — triggered by regex pattern in output stream |");
+  lines.push("| **Convert to slash command** | Zero | Interactive workflow the user invokes explicitly |");
+  lines.push("| **Disable** | Zero | Irrelevant to this project's tech stack |");
+  lines.push("");
+  lines.push("For each skill, consider:");
+  lines.push("1. Is it relevant to the detected tech stack? If not → **disable**.");
+  lines.push("2. Does it enforce a behavior pattern (debugging, TDD, verification)? → **TTSR** with a condition regex.");
+  lines.push("3. Is it reference material loaded for occasional lookups? → **rulebook** with a short description.");
+  lines.push("4. Is it an interactive workflow the user triggers explicitly? → **slash command**.");
+  lines.push("5. Is it essential context needed on every turn for this project? → **keep**.");
+  lines.push("");
+  lines.push("## Implementation");
+  lines.push("");
+  lines.push("After classifying, implement the changes:");
+  lines.push("");
+  lines.push("- **Rulebook**: Create `.omp/rules/<skill-name>.md` with YAML frontmatter `description: \"...\"` and condensed key content");
+  lines.push("- **TTSR**: Create `.omp/rules/<skill-name>.md` with YAML frontmatter `condition: \"regex_pattern\"`");
+  lines.push("- **Disable**: Note which skills to remove from the session configuration");
+  lines.push("- **Command**: Note which skills could become slash commands (but don't create them now)");
+  lines.push("");
+  lines.push("## Warnings");
+  lines.push("");
+  lines.push("- Do **NOT** delete files from `~/.omp/skills/` — only create project-local `.omp/rules/` files");
+  lines.push("- Rulebook and TTSR files go in `.omp/rules/` at the project root");
+  lines.push("- Preserve the original skill content's intent when condensing for rulebook rules");
+  lines.push("");
+  lines.push("Present your classification table and implementation plan first, then ask before executing.");
+
+  return lines.join("\n");
+}