@geminixiang/pi-simplify 0.0.4 → 0.0.6

package/README.md

@@ -1,5 +1,7 @@
 # pi-simplify
 
+[![npm version](https://img.shields.io/npm/v/@geminixiang/pi-simplify.svg)](https://www.npmjs.com/package/@geminixiang/pi-simplify)
+
 A [pi coding agent](https://github.com/mariozechner/pi) extension that cleans up leftover code after feature implementation.
 
 ## What it does

package/index.ts

@@ -1,87 +1,99 @@
 /**
- * pi-simplify: Code Cleanup Extension for pi
+ * pi-simplify: Code Review & Cleanup Extension for pi
  *
- * Removes leftover code after feature implementation:
- * - Dead code (unused exports, orphaned files)
- * - Debug remnants (console.log, debugger, temp flags)
- * - Commented-out code
- * - Over-engineering ("might use later" abstractions)
- * - Duplicate logic
+ * Reviews changed code for reuse, quality, and efficiency:
+ * - Reuse: replace newly-written code with existing utilities
+ * - Quality: dead code, debug remnants, commented-out code, over-engineering, duplicate logic
+ * - Efficiency: redundant work, missed concurrency, hot-path bloat, memory leaks
  */
 
-import { writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
 import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { matchesKey, Key, truncateToWidth, type SelectItem } from "@mariozechner/pi-tui";
 
+type Category = "reuse" | "quality" | "efficiency";
+type Risk = "safe" | "confirm" | "review";
+type Action = "delete" | "inline" | "refactor" | "parallelize";
+
 type SimplifyResult = {
+  category: Category;
   file: string;
   lines: string;
   reason: string;
-  risk: "safe" | "confirm" | "review";
+  risk: Risk;
+  action: Action;
 };
 
-const SIMPLIFY_PROMPT = `# Simplify: Clean Up Leftover Code
+const SIMPLIFY_PROMPT = `# Simplify: Review Changed Code for Reuse, Quality, and Efficiency
 
-You are a code cleanup assistant. Your job is to identify and remove unnecessary code left over after feature implementation.
+You are a code review assistant. Review the changed code along three axes — **Reuse**, **Quality**, and **Efficiency** — and surface concrete fixes.
 
 ## What to Find
 
-### 1. Dead Code (Safe to Delete)
-- **Unused exports**: Functions/classes defined but never imported elsewhere
-- **Orphan files**: Files created but never referenced
-- **Zombie variables**: Variables assigned but never used
-- **Empty blocks**: try/catch/if blocks with no logic
-
-### 2. Debug Remnants (Safe to Delete)
-- console.log, console.warn, console.error statements
-- debugger statements
-- Temporary feature flags (e.g., \`ENABLE_DEBUG\`, \`DEBUG_MODE\`)
-- Temporary todo comments that are now implemented
-
-### 3. Commented-out Code (Review Before Deleting)
-- Old logic left in comments
-- Disabled features (commented out rather than deleted)
-- Copy-pasted templates never customized
-
-### 4. Over-engineering (Confirm Before Deleting)
-- Abstractions created "for future use" but never used
-- Helper functions with single call sites (could be inlined)
-- Layers of indirection that add no value
-
-### 5. Duplicate Logic (Confirm Before Deleting)
-- Repeated if-else blocks doing the same thing
-- Copy-paste code with minor variations
-- Duplicate utility functions
+### A. Reuse (Confirm Before Replacing)
 
-## How to Analyze
+Before flagging, **search the codebase** (utility directories, shared modules, files adjacent to the change) for existing helpers. Quote the existing symbol you'd use.
+
+- **Duplicates an existing function**: a newly written helper does what an existing one already does
+- **Inline logic that has a utility**: hand-rolled string manipulation, manual path handling, custom env checks, ad-hoc type guards
+- **Reinvented framework primitive**: re-implementing something the language/stdlib/framework already provides
+
+### B. Quality
+
+#### B1. Dead Code (Safe to Delete)
+- Unused exports, orphan files, zombie variables, empty try/catch/if blocks
+
+#### B2. Debug Remnants (Safe to Delete)
+- \`console.log\` / \`console.warn\` / \`console.error\`, \`debugger\`, temporary feature flags, stale TODO comments
 
-1. Run \`git diff\` to see what changed
-2. For each change, determine if it's:
-   - **Essential**: Required for the feature to work
-   - **Residual**: Left over from development/debugging
-   - **Legacy**: Old code not touched by this change
+#### B3. Commented-out Code (Review)
+- Old logic left in comments, disabled features, uncustomized templates
+
+#### B4. Over-engineering (Confirm)
+- Abstractions created "for future use" but unused, single-call-site helpers that should be inlined, useless indirection
+
+#### B5. Hacky Patterns (Confirm)
+- **Redundant state**: state that duplicates other state, cached values that could be derived, observers that could be direct calls
+- **Parameter sprawl**: piling new parameters onto a function instead of restructuring
+- **Copy-paste with variation**: near-duplicate blocks that should share an abstraction
+- **Leaky abstractions**: exposing internals or breaking existing boundaries
+- **Stringly-typed code**: raw strings where an existing constant/enum/union exists
+- **Unnecessary wrapper elements**: JSX/DOM wrappers that add no layout value
+- **Nested conditionals**: ternary chains or if/else nested 3+ levels deep — flatten with early returns or a lookup table
+- **Useless comments**: comments restating WHAT the code does, narrating the change, or referencing the task/caller — keep only non-obvious WHY
+
+### C. Efficiency (Confirm)
+
+- **Unnecessary work**: redundant computations, repeated file reads, duplicate API calls, N+1 patterns
+- **Missed concurrency**: independent operations run sequentially when they could run in parallel
+- **Hot-path bloat**: blocking work added to startup or per-request/per-render hot paths
+- **Recurring no-op updates**: state writes inside loops/intervals/handlers that fire unconditionally — add a change-detection guard
+- **Unnecessary existence checks**: pre-checking file/resource existence before operating (TOCTOU) — operate directly and handle the error
+- **Memory**: unbounded data structures, missing cleanup, event listener leaks
+- **Overly broad operations**: reading whole files when a slice would do, loading all items when filtering for one
+
+## How to Analyze
 
-3. For each residual item:
+1. Run \`git diff\` to see what changed.
+2. For each change, classify as **Essential** / **Residual** / **Legacy** (don't flag legacy code unless the diff touches it).
+3. For each finding:
    - Identify exact file and line(s)
-   - Assess risk level
-   - Provide clear reason for removal
+   - Assign **category** (reuse / quality / efficiency) and **risk**
+   - State the concrete fix (which existing utility to call, which lines to delete, how to parallelize, etc.)
 
 ## Risk Levels
 
-- **safe**: Definitely can be deleted (unused, debug code)
-- **confirm**: Delete after user confirms (over-engineered, duplicates)
-- **review**: User should review before action (commented code, ambiguous)
+- **safe**: Definitely apply (dead code, debug remnants)
+- **confirm**: Apply after user confirms (reuse swaps, over-engineering, hacky patterns, efficiency fixes)
+- **review**: User should look first (commented-out code, ambiguous cases)
 
 ## Rules
 
-1. When in doubt, mark as "confirm" or "review" - don't delete without consent
-2. For inline candidates, show the alternative
-3. Don't flag necessary code just because it's simple
-4. Respect existing abstraction boundaries
-5. Be especially careful with:
+1. When in doubt, mark as "confirm" or "review" — don't change without consent.
+2. For reuse findings, name the existing symbol/file you'd swap to.
+3. For efficiency findings, briefly justify the win (e.g., "N+1 → single query", "sequential awaits → Promise.all").
+4. Don't flag necessary code just because it's simple.
+5. Respect existing abstraction boundaries.
+6. Be especially careful with:
    - Error handling code
    - Security-related logic
    - Code that looks "unused" but is called via reflection/eval
@@ -95,24 +107,24 @@ You may write prose analysis first, but you MUST end your response with a single
 {
   "candidates": [
     {
-      "risk": "safe",
+      "category": "reuse",
+      "risk": "confirm",
       "file": "path/to/file.ext",
       "lines": "12-15",
-      "type": "debug",
-      "reason": "Why this should be removed",
-      "action": "delete"
+      "reason": "Replace hand-rolled join with existing pathJoin() in src/utils/path.ts",
+      "action": "refactor"
     }
   ]
 }
 \`\`\`
 
 Field notes:
+- \`category\` — one of: "reuse", "quality", "efficiency"
 - \`risk\` — one of: "safe", "confirm", "review"
 - \`file\` — repository-relative path, no backticks, no markdown
 - \`lines\` — line number or range ("42" or "42-57"); empty string if unknown
-- \`type\` — one of: "dead-code", "debug", "commented", "over-eng", "duplicate"
-- \`reason\` — single plain-text sentence
-- \`action\` — one of: "delete", "inline", "confirm"
+- \`reason\` — single plain-text sentence stating the concrete fix
+- \`action\` — one of: "delete", "inline", "refactor", "parallelize"
 
 If there are no candidates, output \`{"candidates": []}\`. Do NOT output anything after the closing \`\`\` fence.
 `;
@@ -122,6 +134,15 @@ export default function simplifyExtension(pi: ExtensionAPI) {
   // the AI makes tool calls). Overwriting would drop the JSON block if it
   // appears in an earlier message and a later one adds a short confirmation.
   let assistantTextBuffer = "";
+  let resolvePendingTurnStart: (() => void) | null = null;
+
+  pi.on("turn_start", () => {
+    if (!resolvePendingTurnStart) return;
+    const resolve = resolvePendingTurnStart;
+    resolvePendingTurnStart = null;
+    resolve();
+  });
+
   pi.on("message_end", (event) => {
     const msg = event.message;
     if (msg.role !== "assistant" || !Array.isArray(msg.content)) return;
@@ -132,17 +153,33 @@ export default function simplifyExtension(pi: ExtensionAPI) {
     if (text) assistantTextBuffer += (assistantTextBuffer ? "\n" : "") + text;
   });
 
-  const RISK_VALUES = new Set(["safe", "confirm", "review"]);
+  const CATEGORY_VALUES = new Set<Category>(["reuse", "quality", "efficiency"]);
+  const RISK_VALUES = new Set<Risk>(["safe", "confirm", "review"]);
+  const ACTION_VALUES = new Set<Action>(["delete", "inline", "refactor", "parallelize"]);
+
+  function normalizeCategory(value: unknown): Category {
+    const v = String(value ?? "")
+      .toLowerCase()
+      .trim();
+    return CATEGORY_VALUES.has(v as Category) ? (v as Category) : "quality";
+  }
+
+  function normalizeRisk(value: unknown): Risk {
+    const v = String(value ?? "")
+      .toLowerCase()
+      .trim();
+    return RISK_VALUES.has(v as Risk) ? (v as Risk) : "review";
+  }
 
-  function normalizeRisk(value: unknown): "safe" | "confirm" | "review" {
+  function normalizeAction(value: unknown): Action | null {
     const v = String(value ?? "")
       .toLowerCase()
       .trim();
-    return RISK_VALUES.has(v) ? (v as "safe" | "confirm" | "review") : "review";
+    return ACTION_VALUES.has(v as Action) ? (v as Action) : null;
   }
 
   function stripMarkdown(text: string): string {
-    return text.replace(/[`*_]/g, "").trim();
+    return text.replace(/[`*]/g, "").trim();
   }
 
   /**
@@ -171,14 +208,18 @@ export default function simplifyExtension(pi: ExtensionAPI) {
         for (const item of list) {
           if (!item || typeof item !== "object") continue;
           const file = stripMarkdown(String(item.file ?? item.location ?? ""));
-          if (!file) continue;
+          // Validate path is within repo (no path traversal)
+          if (!file || file.includes("..") || file.startsWith("/")) continue;
           const reason = stripMarkdown(String(item.reason ?? item.description ?? ""));
-          const action = item.action ? ` [${stripMarkdown(String(item.action))}]` : "";
+          const action = normalizeAction(item.action);
+          if (!action) continue;
           out.push({
+            category: normalizeCategory(item.category),
             file,
             lines: stripMarkdown(String(item.lines ?? "")),
-            reason: reason ? reason + action : action.trim() || "(no reason provided)",
+            reason: reason || "(no reason provided)",
             risk: normalizeRisk(item.risk),
+            action,
           });
         }
         // A valid candidates array (even empty) is a successful parse
@@ -190,134 +231,6 @@ export default function simplifyExtension(pi: ExtensionAPI) {
     return null;
   }
 
-  /**
-   * Tolerant markdown parser — fallback for responses that don't emit the JSON block.
-   * Accepts many header/bullet variations that LLMs produce in practice.
-   */
-  function parseCandidatesMarkdown(response: string): SimplifyResult[] {
-    const candidates: SimplifyResult[] = [];
-    const lines = response.split("\n");
-
-    // Match `[safe]` / `[confirm]` / `[review]` anywhere on a "header-ish" line.
-    // A line counts as a header if the risk tag is preceded only by markdown noise:
-    // whitespace, #, *, -, digits, dots, parens, colons, backticks, underscores.
-    const HEADER_PREFIX = /^[\s#*\-–—•▸→0-9.)\]:`_]*$/;
-    const RISK_TAG = /\[(safe|confirm|review)\]/i;
-
-    let current: (Partial<SimplifyResult> & { _reason?: string; _action?: string }) | null = null;
-
-    const commit = () => {
-      if (!current) return;
-      if (!current.risk || !current.file) {
-        current = null;
-        return;
-      }
-      const reason = current._reason?.trim() || current.lines?.trim() || "(no reason provided)";
-      const action = current._action ? ` [${current._action.trim()}]` : "";
-      candidates.push({
-        file: current.file,
-        lines: current.lines || "",
-        reason: reason + action,
-        risk: current.risk as "safe" | "confirm" | "review",
-      });
-      current = null;
-    };
-
-    for (const rawLine of lines) {
-      const line = rawLine;
-      const tagMatch = line.match(RISK_TAG);
-      if (tagMatch) {
-        const prefix = line.slice(0, line.indexOf(tagMatch[0]));
-        if (HEADER_PREFIX.test(prefix)) {
-          // New candidate — commit the previous one
-          commit();
-          const risk = normalizeRisk(tagMatch[1]);
-          // Everything after the tag on this line
-          const rest = stripMarkdown(
-            line.slice(line.indexOf(tagMatch[0]) + tagMatch[0].length).replace(/^[\s\-–—:]+/, ""),
-          );
-          // Try to extract a file path (with optional :line or :line-line)
-          const fileMatch = rest.match(/([^\s()`*,]+?\.[a-zA-Z0-9]+)(?::(\d+(?:-\d+)?))?/);
-          current = { risk };
-          if (fileMatch) {
-            current.file = fileMatch[1];
-            current.lines = fileMatch[2] || "";
-            // Remaining text becomes a description/reason fallback
-            const desc = rest
-              .replace(fileMatch[0], "")
-              .replace(/^[\s\-–—:]+/, "")
-              .trim();
-            if (desc) current.lines = current.lines ? `${current.lines}: ${desc}` : desc;
-          } else {
-            // No recognizable file on header — treat rest as description
-            current.lines = rest;
-          }
-          continue;
-        }
-      }
-
-      if (!current) continue;
-
-      // Field extraction: tolerate `- Key:`, `* Key:`, `**Key:**`, or bare `Key:`.
-      const fieldMatch = line.match(
-        /^\s*(?:[-*•]\s*)?\*{0,2}(File|Location|Path|Reason|Why|Action|Lines?)\*{0,2}\s*:?\s*[:\-–—]?\s*(.+?)\s*$/i,
-      );
-      if (fieldMatch) {
-        const key = fieldMatch[1].toLowerCase();
-        const value = stripMarkdown(fieldMatch[2]);
-        if (key === "file" || key === "location" || key === "path") {
-          // Split `path.ts:12-15` into file + lines if current.file is still missing/weak
-          const withLine = value.match(/^(.+?)(?::(\d+(?:-\d+)?))?$/);
-          if (withLine) {
-            current.file = current.file || withLine[1];
-            if (withLine[2]) current.lines = withLine[2];
-          } else {
-            current.file = current.file || value;
-          }
-        } else if (key === "reason" || key === "why") {
-          current._reason = value;
-        } else if (key === "action") {
-          current._action = value;
-        } else if (key === "line" || key === "lines") {
-          current.lines = value;
-        }
-      }
-    }
-
-    commit();
-    return candidates;
-  }
-
-  /** Write raw AI output to a debug file so the user can see what the model actually returned. */
-  function dumpDebug(response: string): string {
-    const path = join(tmpdir(), `pi-simplify-debug-${Date.now()}.md`);
-    try {
-      writeFileSync(path, response, "utf8");
-      return path;
-    } catch {
-      return "";
-    }
-  }
-
-  type ParseOutcome = { kind: "ok"; candidates: SimplifyResult[] } | { kind: "unparseable" };
-
-  /**
-   * Parse the AI's response to extract cleanup candidates.
-   * - "ok" with non-empty list → show selector
-   * - "ok" with empty list   → AI legitimately found nothing
-   * - "unparseable"          → AI output didn't match any known format; dump for debug
-   */
-  function parseCandidates(response: string): ParseOutcome {
-    const json = parseCandidatesJSON(response);
-    if (json !== null) return { kind: "ok", candidates: json };
-    const md = parseCandidatesMarkdown(response);
-    if (md.length > 0) return { kind: "ok", candidates: md };
-    return { kind: "unparseable" };
-  }
-
-  /**
-   * Show selection dialog for candidates with proper multi-select support
-   */
   async function showCandidateSelector(
     ctx: ExtensionCommandContext,
     candidates: SimplifyResult[],
@@ -331,94 +244,61 @@ export default function simplifyExtension(pi: ExtensionAPI) {
     const confirmCandidates = candidates.filter((c) => c.risk === "confirm");
     const reviewCandidates = candidates.filter((c) => c.risk === "review");
 
-    // Build display items with section headers
+    const RISK_CONFIG = {
+      safe: { label: "Safe to apply", description: "Will be applied" },
+      confirm: { label: "Needs confirmation", description: "Select to apply" },
+      review: { label: "Needs review", description: "Review before applying" },
+    } as const;
+
+    const sections = [
+      { key: "safe" as const, items: safeCandidates },
+      { key: "confirm" as const, items: confirmCandidates },
+      { key: "review" as const, items: reviewCandidates },
+    ]
+      .map(({ key, items }) => ({ key, items, config: RISK_CONFIG[key], total: items.length }))
+      .filter((s) => s.total > 0);
+
     const displayItems: SelectItem[] = [];
     const selectableItems: { index: number; candidate: SimplifyResult }[] = [];
     let globalIndex = 0;
 
-    if (safeCandidates.length > 0) {
+    for (const section of sections) {
       displayItems.push({
-        value: "__section__safe__",
-        label: `── Safe to delete (${safeCandidates.length}) ──`,
+        value: `__section__${section.key}__`,
+        label: `── ${section.config.label} (${section.total}) ──`,
         description: "",
       });
       globalIndex++;
-      for (const c of safeCandidates) {
+      for (const c of section.items) {
         displayItems.push({
           value: JSON.stringify(c),
           label: `${c.file} - ${c.reason}`,
-          description: "Will be deleted",
+          description: section.config.description,
         });
-        selectableItems.push({ index: globalIndex, candidate: c });
-        globalIndex++;
+        selectableItems.push({ index: globalIndex++, candidate: c });
       }
     }
 
-    if (confirmCandidates.length > 0) {
-      displayItems.push({
-        value: "__section__confirm__",
-        label: `── Needs confirmation (${confirmCandidates.length}) ──`,
-        description: "",
-      });
-      globalIndex++;
-      for (const c of confirmCandidates) {
-        displayItems.push({
-          value: JSON.stringify(c),
-          label: `${c.file} - ${c.reason}`,
-          description: "Select to delete",
-        });
-        selectableItems.push({ index: globalIndex, candidate: c });
-        globalIndex++;
-      }
-    }
-
-    if (reviewCandidates.length > 0) {
-      displayItems.push({
-        value: "__section__review__",
-        label: `── Needs review (${reviewCandidates.length}) ──`,
-        description: "",
-      });
-      globalIndex++;
-      for (const c of reviewCandidates) {
-        displayItems.push({
-          value: JSON.stringify(c),
-          label: `${c.file} - ${c.reason}`,
-          description: "Review before deleting",
-        });
-        selectableItems.push({ index: globalIndex, candidate: c });
-        globalIndex++;
-      }
-    }
-
-    // Track selected selectable items (by their selectableItems index)
-    const selectedSet = new Set<number>();
-
-    // Pre-select all safe items (indices 0 to safeCandidates.length - 1 in selectableItems)
-    for (let i = 0; i < safeCandidates.length; i++) {
-      selectedSet.add(i);
-    }
+    // Pre-select all safe items
+    const selectedSet = new Set<number>(
+      safeCandidates.length > 0 ? Array.from({ length: safeCandidates.length }, (_, i) => i) : [],
+    );
 
     const maxVisible = 12;
     let scrollOffset = 0;
     let cursorPos = 0;
 
     const result = await ctx.ui.custom<SimplifyResult[]>((tui, theme, _keybindings, done) => {
-      // Render the multi-select list manually
       const renderList = (width: number): string[] => {
         const lines: string[] = [];
 
-        // Calculate which items are visible
         const visibleItems: { selectableIdx: number | null; item: SelectItem }[] = [];
-        for (let i = 0; i < displayItems.length; i++) {
-          const item = displayItems[i];
+        let nextSelectableIdx = 0;
+        for (const item of displayItems) {
           if (item.value.startsWith("__section__")) {
             visibleItems.push({ selectableIdx: null, item });
           } else {
-            const selectableInfo = selectableItems.find((si) => si.index === i);
-            if (selectableInfo) {
-              const selectableIdx = selectableItems.indexOf(selectableInfo);
-              visibleItems.push({ selectableIdx, item });
-            }
+            visibleItems.push({ selectableIdx: nextSelectableIdx++, item });
           }
         }
 
@@ -456,7 +336,7 @@ export default function simplifyExtension(pi: ExtensionAPI) {
       return {
         render(width: number) {
           const lines: string[] = [];
-          lines.push(theme.bold("Simplify: Select items to remove"));
+          lines.push(theme.bold("Simplify: Select findings to apply"));
           lines.push(
             theme.fg(
               "muted",
@@ -550,52 +430,44 @@ export default function simplifyExtension(pi: ExtensionAPI) {
     return result ?? [];
   }
 
-  /**
-   * Execute the cleanup by sending deletion commands
-   */
-  async function executeCleanup(
+  async function applyFindings(
     ctx: ExtensionCommandContext,
     selected: SimplifyResult[],
   ): Promise<void> {
     if (selected.length === 0) {
-      ctx.ui.notify("No items selected for cleanup", "info");
+      ctx.ui.notify("No findings selected to apply", "info");
       return;
     }
 
     const safeItems = selected.filter((c) => c.risk === "safe");
     const confirmItems = selected.filter((c) => c.risk === "confirm");
 
-    // Build cleanup prompt
-    const cleanupPrompt = `# Cleanup Instructions
+    const cleanupPrompt = `# Apply Review Findings
 
-Delete the following code:
+Apply the following findings. Each item includes a bracketed action (e.g. \`[delete]\`, \`[refactor]\`, \`[parallelize]\`, \`[inline]\`) — follow that action, not a blanket delete.
 
-${selected.map((c) => `- ${c.file}: ${c.reason}`).join("\n")}
+${selected.map((c) => `- ${c.file} (${c.lines || "?"}): ${c.reason} [${c.action}]`).join("\n")}
 
 For each item:
 1. Read the file to find the exact location
-2. Remove only the specified code (not surrounding code unless instructed)
-3. If the removal affects other code, stop and report the issue
-4. After all deletions, verify the code still works by running any existing tests
+2. Apply only the specified change (not surrounding code unless instructed)
+3. For refactor/inline/parallelize: preserve behavior; if the change has visible side effects, stop and report
+4. If the change affects other code, stop and report the issue
 
-Report:
-- What was deleted
-- Any issues encountered
-- Files that may need further attention`;
+After applying all changes:
+- Run \`npm test\` or equivalent; if there are no tests, verify the files parse/type-check
+- Report what changed, test results, and any items skipped with reasons`;
 
     ctx.ui.notify(
-      `Starting cleanup of ${selected.length} items (${safeItems.length} safe, ${confirmItems.length} confirmed)`,
+      `Applying ${selected.length} findings (${safeItems.length} safe, ${confirmItems.length} confirmed)`,
       "info",
     );
 
     pi.sendUserMessage(cleanupPrompt);
   }
 
-  /**
-   * Main command handler
-   */
   pi.registerCommand("simplify", {
-    description: "Clean up leftover code (dead code, debug remnants, over-engineering)",
+    description: "Review changed code for reuse, quality, and efficiency, then apply fixes",
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       if (!ctx.hasUI) {
         ctx.ui.notify("Simplify requires interactive mode", "error");
@@ -624,7 +496,7 @@ Report:
         return;
       }
 
-      ctx.ui.notify("Analyzing code for cleanup candidates...", "info");
+      ctx.ui.notify("Analyzing code for review findings...", "info");
 
       // Build prompt with optional focus
       let fullPrompt = SIMPLIFY_PROMPT;
@@ -635,17 +507,26 @@ Report:
       // Reset capture buffer, then send prompt and wait.
       // message_end events append to assistantTextBuffer during the turn.
       //
-      // Race condition fix: pi.sendUserMessage() queues the message, but
-      // ctx.waitForIdle() resolves immediately if the agent is still in idle.
-      // We must wait for the agent to transition out of idle before waiting.
+      // Wait for the queued analysis turn to actually begin before waiting for
+      // idle; otherwise waitForIdle() can return immediately while the agent is
+      // still idle and the queued prompt has not started yet.
       assistantTextBuffer = "";
-      let resolveTurnStarted: () => void;
       const turnStarted = new Promise<void>((r) => {
-        resolveTurnStarted = r;
+        resolvePendingTurnStart = r;
       });
-      pi.on("turn_start", () => resolveTurnStarted!());
+
       pi.sendUserMessage(fullPrompt);
-      await turnStarted;
+
+      const started = await Promise.race<boolean>([
+        turnStarted.then(() => true),
+        new Promise<boolean>((r) => setTimeout(() => r(false), 10000)),
+      ]);
+      if (!started) {
+        resolvePendingTurnStart = null;
+        ctx.ui.notify("Analysis did not start within 10 seconds. Please try again.", "warning");
+        return;
+      }
+
       await ctx.waitForIdle();
       const analysisText = assistantTextBuffer;
 
@@ -654,42 +535,36 @@ Report:
         return;
       }
 
-      const outcome = parseCandidates(analysisText);
+      const candidates = parseCandidatesJSON(analysisText);
 
-      if (outcome.kind === "unparseable") {
-        const debugPath = dumpDebug(analysisText);
-        const suffix = debugPath ? ` Raw response saved to ${debugPath}` : "";
+      if (candidates === null) {
         ctx.ui.notify(
-          `Could not parse cleanup candidates — the model did not return the expected JSON block.${suffix}`,
+          "Could not parse review findings — the model did not return the expected JSON block.",
           "warning",
         );
         return;
       }
 
-      const candidates = outcome.candidates;
       if (candidates.length === 0) {
-        ctx.ui.notify("No cleanup candidates found!", "info");
+        ctx.ui.notify("No review findings found!", "info");
         return;
       }
 
-      ctx.ui.notify(`Found ${candidates.length} candidates. Select items to remove...`, "info");
+      ctx.ui.notify(`Found ${candidates.length} findings. Select findings to apply...`, "info");
 
       // Show selector
       const selected = await showCandidateSelector(ctx, candidates);
 
       if (!selected || selected.length === 0) {
-        ctx.ui.notify("Cleanup cancelled", "info");
+        ctx.ui.notify("Apply findings cancelled", "info");
         return;
       }
 
-      // Execute cleanup
-      await executeCleanup(ctx, selected);
+      // Apply selected findings
+      await applyFindings(ctx, selected);
     },
   });
 
-  /**
-   * Quick simplify - auto-clean safe items only
-   */
   pi.registerCommand("simplify-quick", {
     description: "Quick cleanup of obviously safe items (debug code, unused exports)",
     handler: async (_args: string, ctx: ExtensionCommandContext) => {
@@ -730,17 +605,4 @@ Return a summary of what was deleted.`;
       pi.sendUserMessage(quickPrompt, { deliverAs: "followUp" });
     },
   });
-
-  /**
-   * Status indicator on startup
-   */
-  pi.on("session_start", async (_event, ctx) => {
-    const { code } = await pi.exec("git", ["rev-parse", "--git-dir"]);
-    if (code === 0) {
-      ctx.ui.setStatus(
-        "simplify",
-        `${ctx.ui.theme.fg("accent", "simplify")} ${ctx.ui.theme.fg("muted", "ready (try /simplify)")}`,
-      );
-    }
-  });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@geminixiang/pi-simplify",
-  "version": "0.0.4",
-  "description": "Simplify: Clean up leftover code after feature implementation",
+  "version": "0.0.6",
+  "description": "Simplify: Review changed code for reuse, quality, and efficiency",
   "keywords": [
     "pi-package"
   ],