supipowers 1.5.2 → 2.0.0

package/src/commands/agents.ts

@@ -1,45 +1,85 @@
+import path from "node:path";
 import type { Platform } from "../platform/types.js";
 import {
-  loadMergedReviewAgents,
-  writeAgentFile,
   addAgentToConfig,
-  getReviewAgentsDir,
-  getReviewAgentsConfigPath,
-  getGlobalReviewAgentsDir,
   getGlobalReviewAgentsConfigPath,
+  getGlobalReviewAgentsDir,
+  getRootReviewAgentsConfigPath,
+  getRootReviewAgentsDir,
+  getWorkspaceReviewAgentsConfigPath,
+  getWorkspaceReviewAgentsDir,
+  loadMergedReviewAgents,
+  resolveReviewAgentContext,
+  writeAgentFile,
 } from "../review/agent-loader.js";
-import { selectModelFromList } from "./model.js";
-import type { ConfiguredReviewAgent } from "../types.js";
+import { selectModelFromList, THINKING_LEVELS } from "./model.js";
+import type { ConfiguredReviewAgent, ThinkingLevel } from "../types.js";
 import creatingAgentsSkill from "../../skills/creating-supi-agents/SKILL.md" with { type: "text" };
 
 // ── List View ──────────────────────────────────────────────────
 
-function buildAgentDashboard(agents: ConfiguredReviewAgent[]): string {
+interface AgentDashboardContext {
+  workspaceRelativeDir: string | null;
+}
+
+function formatAgentSourceScope(
+  scope: ConfiguredReviewAgent["scope"],
+  context: AgentDashboardContext,
+): string {
+  switch (scope) {
+    case "global":
+      return "global";
+    case "workspace":
+      return "workspace";
+    case "root":
+    case undefined:
+      return context.workspaceRelativeDir ? "root" : "project";
+  }
+}
+
+function buildAgentDashboard(
+  agents: ConfiguredReviewAgent[],
+  context: AgentDashboardContext,
+): string {
   const nameCol = 18;
   const modelCol = 24;
-  const scopeCol = 10;
+  const thinkingCol = 12;
+  const sourceCol = 10;
+
+  const lines: string[] = ["\n  Review Agents\n"];
+  if (context.workspaceRelativeDir) {
+    lines.push(`  Workspace: ${context.workspaceRelativeDir}`);
+    lines.push("  Effective precedence: workspace → root → global");
+    lines.push("");
+  }
 
-  const lines: string[] = [
-    "\n  Review Agents\n",
-    `  ${"name".padEnd(nameCol)} ${"model".padEnd(modelCol)} ${"scope".padEnd(scopeCol)} focus`,
-  ];
+  lines.push(
+    `  ${"name".padEnd(nameCol)} ${"model".padEnd(modelCol)} ${"thinking".padEnd(thinkingCol)} ${"source".padEnd(sourceCol)} focus`,
+  );
 
   for (const agent of agents) {
     const name = agent.name.padEnd(nameCol);
     const model = (agent.model ?? "—").padEnd(modelCol);
-    const scope = (agent.scope ?? "project").padEnd(scopeCol);
+    const thinking = (agent.thinkingLevel ?? "—").padEnd(thinkingCol);
+    const source = formatAgentSourceScope(agent.scope, context).padEnd(sourceCol);
     const focus = agent.focus
       ? agent.focus.length > 40
         ? agent.focus.slice(0, 37) + "..."
         : agent.focus
       : "—";
-    lines.push(`  ${name} ${model} ${scope} ${focus}`);
+    lines.push(`  ${name} ${model} ${thinking} ${source} ${focus}`);
   }
 
-  const globalCount = agents.filter((a) => a.scope === "global").length;
-  const projectCount = agents.filter((a) => a.scope === "project" || !a.scope).length;
+  const globalCount = agents.filter((agent) => agent.scope === "global").length;
+  const rootCount = agents.filter((agent) => agent.scope === "root" || !agent.scope).length;
+  const workspaceCount = agents.filter((agent) => agent.scope === "workspace").length;
+
   lines.push("");
-  lines.push(`  ${agents.length} agent(s) (${projectCount} project, ${globalCount} global)`);
+  if (context.workspaceRelativeDir) {
+    lines.push(`  ${agents.length} agent(s) (${workspaceCount} workspace, ${rootCount} root, ${globalCount} global)`);
+  } else {
+    lines.push(`  ${agents.length} agent(s) (${rootCount} project, ${globalCount} global)`);
+  }
   lines.push("");
 
   return lines.join("\n");
@@ -49,6 +89,58 @@ function buildAgentDashboard(agents: ConfiguredReviewAgent[]): string {
 
 const KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 
+type AgentCreateScope = "global" | "project";
+type AgentCreateStorageScope = "global" | "root" | "workspace";
+
+interface AgentCreateDestination {
+  agentsDir: string;
+  configPath: string;
+  scope: AgentCreateStorageScope;
+}
+
+function matchesCreateScope(
+  agent: ConfiguredReviewAgent,
+  scope: AgentCreateStorageScope,
+): boolean {
+  switch (scope) {
+    case "global":
+      return agent.scope === "global";
+    case "workspace":
+      return agent.scope === "workspace";
+    case "root":
+      return agent.scope === "root" || agent.scope === undefined;
+  }
+}
+
+function resolveAgentCreateDestination(
+  platform: Platform,
+  cwd: string,
+  scope: AgentCreateScope,
+): AgentCreateDestination {
+  if (scope === "global") {
+    return {
+      agentsDir: getGlobalReviewAgentsDir(platform.paths),
+      configPath: getGlobalReviewAgentsConfigPath(platform.paths),
+      scope: "global",
+    };
+  }
+
+  const context = resolveReviewAgentContext(cwd);
+  if (context.workspaceRelativeDir) {
+    return {
+      agentsDir: getWorkspaceReviewAgentsDir(platform.paths, context.repoRoot, context.workspaceRelativeDir),
+      configPath: getWorkspaceReviewAgentsConfigPath(platform.paths, context.repoRoot, context.workspaceRelativeDir),
+      scope: "workspace",
+    };
+  }
+
+  return {
+    agentsDir: getRootReviewAgentsDir(platform.paths, context.repoRoot),
+    configPath: getRootReviewAgentsConfigPath(platform.paths, context.repoRoot),
+    scope: "root",
+  };
+}
+
 export async function runAgentCreateFlow(platform: Platform, ctx: any): Promise<void> {
   if (!ctx.hasUI) {
     ctx.ui.notify("Agent creation requires interactive mode", "warning");
@@ -62,7 +154,7 @@ export async function runAgentCreateFlow(platform: Platform, ctx: any): Promise<
   ], { helpText: "Select scope · Esc to cancel" });
 
   if (!scopeChoice) return;
-  const scope: "global" | "project" = scopeChoice === "Global" ? "global" : "project";
+  const scope: AgentCreateScope = scopeChoice === "Global" ? "global" : "project";
 
   // Step 2: Agent name
   const nameInput = await ctx.ui.input("Agent name (kebab-case)", {
@@ -77,14 +169,16 @@ export async function runAgentCreateFlow(platform: Platform, ctx: any): Promise<
     return;
   }
 
+  const destination = resolveAgentCreateDestination(platform, ctx.cwd, scope);
+
   // Check for name collision in target scope
   try {
     const existing = await loadMergedReviewAgents(platform.paths, ctx.cwd);
     const collision = existing.agents.find(
-      (a) => a.name === agentName && (a.scope ?? "project") === scope,
+      (agent) => agent.name === agentName && matchesCreateScope(agent, destination.scope),
     );
     if (collision) {
-      ctx.ui.notify(`Agent "${agentName}" already exists in ${scope} scope`, "error");
+      ctx.ui.notify(`Agent "${agentName}" already exists in ${destination.scope} scope`, "error");
       return;
     }
   } catch {
@@ -95,7 +189,16 @@ export async function runAgentCreateFlow(platform: Platform, ctx: any): Promise<
   const modelInput = await selectModelFromList(ctx);
   // null means "inherit default" — that's fine
 
-  // Step 4: Prompt source
+  // Step 4: Thinking level
+  const thinkingChoice = await ctx.ui.select(
+    "Thinking level",
+    THINKING_LEVELS.map((t) => t.label),
+    { helpText: "Select thinking level · Esc to cancel" },
+  );
+  if (!thinkingChoice) return;
+  const thinkingLevel: ThinkingLevel | null = THINKING_LEVELS.find((t) => t.label === thinkingChoice)?.value ?? null;
+
+  // Step 5: Prompt source
   const promptChoice = await ctx.ui.select("Agent prompt", [
     "Send a prompt",
     "Create from zero",
@@ -105,7 +208,7 @@ export async function runAgentCreateFlow(platform: Platform, ctx: any): Promise<
 
   if (promptChoice === "Create from zero") {
     // Load the creating-supi-agents skill via steer
-    loadSkillAndSteer(platform, ctx, scope, agentName, modelInput);
+    loadSkillAndSteer(platform, ctx, scope, agentName, modelInput, thinkingLevel);
     return;
   }
 
@@ -119,25 +222,19 @@ export async function runAgentCreateFlow(platform: Platform, ctx: any): Promise<
     return;
   }
 
-  // Step 5: Save
-  const agentsDir = scope === "global"
-    ? getGlobalReviewAgentsDir(platform.paths)
-    : getReviewAgentsDir(platform.paths, ctx.cwd);
-  const configPath = scope === "global"
-    ? getGlobalReviewAgentsConfigPath(platform.paths)
-    : getReviewAgentsConfigPath(platform.paths, ctx.cwd);
-
-  const fileName = writeAgentFile(agentsDir, agentName, {
+  // Step 6: Save
+  const fileName = writeAgentFile(destination.agentsDir, agentName, {
     name: agentName,
     description: `${agentName} review agent`,
     focus: null,
   }, promptBody.trim());
 
-  await addAgentToConfig(configPath, {
+  await addAgentToConfig(destination.configPath, {
     name: agentName,
     enabled: true,
     data: fileName,
     model: modelInput,
+    thinkingLevel,
   });
 
   ctx.ui.notify(`Agent "${agentName}" created (${scope})`, "info");
@@ -148,18 +245,20 @@ export async function runAgentCreateFlow(platform: Platform, ctx: any): Promise<
 function loadSkillAndSteer(
   platform: Platform,
   ctx: any,
-  scope: "global" | "project",
+  scope: AgentCreateScope,
   agentName: string,
   model: string | null,
+  thinkingLevel: ThinkingLevel | null,
 ): void {
-  const agentsDir = scope === "global"
-    ? getGlobalReviewAgentsDir(platform.paths)
-    : getReviewAgentsDir(platform.paths, ctx.cwd);
-  const configPath = scope === "global"
-    ? getGlobalReviewAgentsConfigPath(platform.paths)
-    : getReviewAgentsConfigPath(platform.paths, ctx.cwd);
-
-  const prompt = buildSkillSteerPrompt(agentName, scope, agentsDir, configPath, model);
+  const destination = resolveAgentCreateDestination(platform, ctx.cwd, scope);
+  const prompt = buildSkillSteerPrompt(
+    agentName,
+    scope,
+    destination.agentsDir,
+    destination.configPath,
+    model,
+    thinkingLevel,
+  );
 
   platform.sendMessage(
     {
@@ -177,6 +276,7 @@ function buildSkillSteerPrompt(
   agentsDir: string,
   configPath: string,
   model: string | null,
+  thinkingLevel: ThinkingLevel | null,
 ): string {
   return `You are guiding the user through creating a new AI review agent for supipowers' multi-agent code review pipeline.
 
@@ -184,6 +284,7 @@ function buildSkillSteerPrompt(
 - **Name**: ${agentName}
 - **Scope**: ${scope}
 - **Model**: ${model ?? "inherit default"}
+- **Thinking Level**: ${thinkingLevel ?? "inherit default"}
 - **Target directory**: ${agentsDir}
 - **Config path**: ${configPath}
 
@@ -194,10 +295,10 @@ ${creatingAgentsSkill}
 ## Save Instructions
 
 Once the user approves the agent design, save it:
-1. Write the markdown file to: ${agentsDir}/${agentName}.md
+1. Write the markdown file to: ${path.join(agentsDir, `${agentName}.md`)}
    - The file MUST have YAML frontmatter (name, description, focus) and a prompt body ending with {output_instructions}
 2. Update config at: ${configPath}
-   - Add entry: { name: "${agentName}", enabled: true, data: "${agentName}.md", model: ${model ? `"${model}"` : "null"} }
+   - Add entry: { name: "${agentName}", enabled: true, data: "${agentName}.md", model: ${model ? `"${model}"` : "null"}, thinkingLevel: ${thinkingLevel ? `"${thinkingLevel}"` : "null"} }
 
 Use the \`writeAgentFile\` and \`addAgentToConfig\` functions from \`src/review/agent-loader.ts\` if you have tool access, or write the files directly.
 
@@ -222,7 +323,10 @@ export function handleAgents(platform: Platform, ctx: any, args?: string): void
 
 async function showAgentsDashboard(platform: Platform, ctx: any): Promise<void> {
   const result = await loadMergedReviewAgents(platform.paths, ctx.cwd);
-  const dashboard = buildAgentDashboard(result.agents);
+  const dashboardContext = resolveReviewAgentContext(ctx.cwd);
+  const dashboard = buildAgentDashboard(result.agents, {
+    workspaceRelativeDir: dashboardContext.workspaceRelativeDir,
+  });
   ctx.ui.notify(dashboard, "info");
 }