@geminixiang/pi-simplify 0.0.3 → 0.0.4

package/README.md

@@ -1,47 +1,70 @@
 # pi-simplify
 
-A [pi coding agent](https://github.com/mariozechner/pi) extension that adds a `/simplify` command to review changed code for reuse, quality, and efficiency — then fix any issues found.
+A [pi coding agent](https://github.com/mariozechner/pi) extension that cleans up leftover code after feature implementation.
 
 ## What it does
 
-Running `/simplify` launches three parallel sub-agents that each review your git diff from a different angle:
+After implementing a feature, your code often accumulates:
 
-- **Code Reuse** — finds newly written code that duplicates existing utilities or helpers
-- **Code Quality** — catches hacky patterns: redundant state, parameter sprawl, copy-paste blocks, leaky abstractions, stringly-typed code, unnecessary comments
-- **Efficiency** — spots unnecessary work, missed concurrency, hot-path bloat, memory leaks, and overly broad operations
+- **Dead code** - unused exports, orphaned files, zombie variables
+- **Debug remnants** - console.log, debugger statements, temp flags
+- **Commented-out code** - old logic left in comments
+- **Over-engineering** - "might use later" abstractions never used
+- **Duplicate logic** - repeated if-else blocks doing the same thing
 
-After all three agents finish, issues are aggregated and fixed in place. A brief summary is printed at the end.
+`/simplify` finds these and removes them.
 
 ## Installation
 
-### 1. Install pi-subagents
-
-`pi-simplify` relies on the Agent tool provided by the `pi-subagents` package. Install it first:
-
-```sh
-pi install npm:pi-subagents
-```
-
-### 2. Install pi-simplify
-
 ```sh
 pi install npm:@geminixiang/pi-simplify
 ```
 
 ## Usage
 
-After installation, the `/simplify` command is available inside pi:
+### Full Simplify
 
 ```
 /simplify
 ```
 
-You can also pass an optional focus area to narrow the review:
+Analyzes all git changes and presents cleanup candidates:
+
+- **Safe** (green) - auto-selected, will be deleted
+- **Confirm** (yellow) - delete after user confirms
+- **Review** (orange) - user should review first
+
+### Quick Simplify
 
 ```
-/simplify focus on performance in the database layer
+/simplify-quick
 ```
 
+Only removes the obviously safe stuff:
+
+- `console.log` / `console.warn` / `console.error`
+- `debugger` statements
+- Unused imports
+- Empty catch blocks
+
+No confirmation needed - just does it.
+
+### With Focus
+
+```
+/simplify focus on the utils folder
+/simplify focus on removing debug code
+```
+
+## Comparison with pi-review
+
+|              | pi-review                   | pi-simplify           |
+| ------------ | --------------------------- | --------------------- |
+| **Goal**     | Find problems               | Delete excess         |
+| **Attitude** | Conservative (marks issues) | Active (removes junk) |
+| **Output**   | Findings list               | Deletion plan         |
+| **Trigger**  | Manual review               | Post-feature cleanup  |
+
 ## License
 
 MIT

package/index.ts

@@ -1,89 +1,746 @@
+/**
+ * pi-simplify: Code 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
+ */
+
+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 SimplifyResult = {
+  file: string;
+  lines: string;
+  reason: string;
+  risk: "safe" | "confirm" | "review";
+};
 
-const CUSTOM_TYPE = "simplify-context";
-const DELIVERY_FOLLOW_UP = "followUp";
-const NOTIFY_REVIEW_STARTED = "Simplify review started";
-const NOTIFY_REVIEW_QUEUED = "Simplify review queued as a follow-up";
+const SIMPLIFY_PROMPT = `# Simplify: Clean Up Leftover Code
 
-const SIMPLIFY_PROMPT = `# Simplify: Code Review and Cleanup
+You are a code cleanup assistant. Your job is to identify and remove unnecessary code left over after feature implementation.
 
-Review all changed files for reuse, quality, and efficiency. Fix any issues found.
+## What to Find
 
-## Phase 1: Identify Changes
+### 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
 
-Run \`git diff\` (or \`git diff HEAD\` if there are staged changes) to see what changed. If there are no git changes, review the most recently modified files that the user mentioned or that you edited earlier in this conversation.
+### 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
 
-## Phase 2: Launch Three Review SubAgents in Parallel
+### 3. Commented-out Code (Review Before Deleting)
+- Old logic left in comments
+- Disabled features (commented out rather than deleted)
+- Copy-pasted templates never customized
 
-Use the Agent tool to launch all three agents concurrently in a single message. Pass each agent the full diff so it has the complete context.
+### 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
 
-### SubAgent 1: Code Reuse Review
+### 5. Duplicate Logic (Confirm Before Deleting)
+- Repeated if-else blocks doing the same thing
+- Copy-paste code with minor variations
+- Duplicate utility functions
 
-For each change:
+## How to Analyze
 
-1. **Search for existing utilities and helpers** that could replace newly written code. Look for similar patterns elsewhere in the codebase — common locations are utility directories, shared modules, and files adjacent to the changed ones.
-2. **Flag any new function that duplicates existing functionality.** Suggest the existing function to use instead.
-3. **Flag any inline logic that could use an existing utility** — hand-rolled string manipulation, manual path handling, custom environment checks, ad-hoc type guards, and similar patterns are common candidates.
+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
 
-### SubAgent 2: Code Quality Review
+3. For each residual item:
+   - Identify exact file and line(s)
+   - Assess risk level
+   - Provide clear reason for removal
 
-Review the same changes for hacky patterns:
+## Risk Levels
 
-1. **Redundant state**: state that duplicates existing state, cached values that could be derived, observers/effects that could be direct calls
-2. **Parameter sprawl**: adding new parameters to a function instead of generalizing or restructuring existing ones
-3. **Copy-paste with slight variation**: near-duplicate code blocks that should be unified with a shared abstraction
-4. **Leaky abstractions**: exposing internal details that should be encapsulated, or breaking existing abstraction boundaries
-5. **Stringly-typed code**: using raw strings where constants, enums (string unions), or branded types already exist in the codebase
-6. **Unnecessary JSX nesting**: wrapper Boxes/elements that add no layout value — check if inner component props (flexShrink, alignItems, etc.) already provide the needed behavior
-7. **Unnecessary comments**: comments explaining WHAT the code does (well-named identifiers already do that), narrating the change, or referencing the task/caller — delete; keep only non-obvious WHY (hidden constraints, subtle invariants, workarounds)
+- **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)
 
-### SubAgent 3: Efficiency Review
+## Rules
 
-Review the same changes for efficiency:
+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:
+   - Error handling code
+   - Security-related logic
+   - Code that looks "unused" but is called via reflection/eval
+   - Database migration files
 
-1. **Unnecessary work**: redundant computations, repeated file reads, duplicate network/API calls, N+1 patterns
-2. **Missed concurrency**: independent operations run sequentially when they could run in parallel
-3. **Hot-path bloat**: new blocking work added to startup or per-request/per-render hot paths
-4. **Recurring no-op updates**: state/store updates inside polling loops, intervals, or event handlers that fire unconditionally — add a change-detection guard so downstream consumers aren't notified when nothing changed. Also: if a wrapper function takes an updater/reducer callback, verify it honors same-reference returns (or whatever the "no change" signal is) — otherwise callers' early-return no-ops are silently defeated
-5. **Unnecessary existence checks**: pre-checking file/resource existence before operating (TOCTOU anti-pattern) — operate directly and handle the error
-6. **Memory**: unbounded data structures, missing cleanup, event listener leaks
-7. **Overly broad operations**: reading entire files when only a portion is needed, loading all items when filtering for one
+## Output Format (REQUIRED)
 
-## Phase 3: Fix Issues
+You may write prose analysis first, but you MUST end your response with a single fenced JSON block containing ALL candidates. This JSON is parsed programmatically — it must be valid JSON and use this exact shape:
+
+\`\`\`json
+{
+  "candidates": [
+    {
+      "risk": "safe",
+      "file": "path/to/file.ext",
+      "lines": "12-15",
+      "type": "debug",
+      "reason": "Why this should be removed",
+      "action": "delete"
+    }
+  ]
+}
+\`\`\`
 
-Wait for all three agents to complete. Aggregate their findings and fix each issue directly. If a finding is a false positive or not worth addressing, note it and move on — do not argue with the finding, just skip it.
+Field notes:
+- \`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"
 
-When done, briefly summarize what was fixed (or confirm the code was already clean).
+If there are no candidates, output \`{"candidates": []}\`. Do NOT output anything after the closing \`\`\` fence.
 `;
 
-function buildPrompt(args: string): string {
-	const focus = args.trim();
-	if (!focus) return SIMPLIFY_PROMPT;
-	return `${SIMPLIFY_PROMPT}\n\n## Additional Focus\n\n${focus}`;
-}
+export default function simplifyExtension(pi: ExtensionAPI) {
+  // Accumulate assistant text across the whole turn (multiple messages when
+  // 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 = "";
+  pi.on("message_end", (event) => {
+    const msg = event.message;
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) return;
+    const text = (msg.content as { type: string; text?: string }[])
+      .filter((b) => b.type === "text" && typeof b.text === "string")
+      .map((b) => b.text as string)
+      .join("\n");
+    if (text) assistantTextBuffer += (assistantTextBuffer ? "\n" : "") + text;
+  });
 
-function runSimplify(pi: ExtensionAPI, ctx: ExtensionCommandContext, args: string): void {
-	const message = {
-		customType: CUSTOM_TYPE,
-		content: buildPrompt(args),
-		display: false,
-	};
-
-	if (ctx.isIdle()) {
-		pi.sendMessage(message, { triggerTurn: true });
-		ctx.ui.notify(NOTIFY_REVIEW_STARTED, "info");
-		return;
-	}
-
-	pi.sendMessage(message, { deliverAs: DELIVERY_FOLLOW_UP, triggerTurn: true });
-	ctx.ui.notify(NOTIFY_REVIEW_QUEUED, "info");
-}
+  const RISK_VALUES = new Set(["safe", "confirm", "review"]);
+
+  function normalizeRisk(value: unknown): "safe" | "confirm" | "review" {
+    const v = String(value ?? "")
+      .toLowerCase()
+      .trim();
+    return RISK_VALUES.has(v) ? (v as "safe" | "confirm" | "review") : "review";
+  }
+
+  function stripMarkdown(text: string): string {
+    return text.replace(/[`*_]/g, "").trim();
+  }
+
+  /**
+   * Try to parse a JSON candidates block. The prompt requires this format,
+   * but we tolerate the AI wrapping it in ```json ... ``` or ``` ... ```,
+   * and also handle the case where it embeds the JSON inline without fences.
+   * Returns null only when no valid JSON with a `candidates` array is found —
+   * a valid empty list returns [] (which means "the AI found nothing").
+   */
+  function parseCandidatesJSON(response: string): SimplifyResult[] | null {
+    const fenceRe = /```(?:json)?\s*\n([\s\S]*?)\n```/gi;
+    const blocks: string[] = [];
+    let m: RegExpExecArray | null;
+    while ((m = fenceRe.exec(response)) !== null) blocks.push(m[1]);
+
+    const bareMatch = response.match(/\{[\s\S]*"candidates"[\s\S]*\}/);
+    if (bareMatch) blocks.push(bareMatch[0]);
+
+    // Walk newest-first: the contract puts the JSON at the end of the response.
+    for (let i = blocks.length - 1; i >= 0; i--) {
+      try {
+        const parsed = JSON.parse(blocks[i]);
+        const list = parsed?.candidates;
+        if (!Array.isArray(list)) continue;
+        const out: SimplifyResult[] = [];
+        for (const item of list) {
+          if (!item || typeof item !== "object") continue;
+          const file = stripMarkdown(String(item.file ?? item.location ?? ""));
+          if (!file) continue;
+          const reason = stripMarkdown(String(item.reason ?? item.description ?? ""));
+          const action = item.action ? ` [${stripMarkdown(String(item.action))}]` : "";
+          out.push({
+            file,
+            lines: stripMarkdown(String(item.lines ?? "")),
+            reason: reason ? reason + action : action.trim() || "(no reason provided)",
+            risk: normalizeRisk(item.risk),
+          });
+        }
+        // A valid candidates array (even empty) is a successful parse
+        return out;
+      } catch {
+        // try next block
+      }
+    }
+    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[],
+  ): Promise<SimplifyResult[]> {
+    if (candidates.length === 0) {
+      return [];
+    }
+
+    // Categorize by risk level for display
+    const safeCandidates = candidates.filter((c) => c.risk === "safe");
+    const confirmCandidates = candidates.filter((c) => c.risk === "confirm");
+    const reviewCandidates = candidates.filter((c) => c.risk === "review");
+
+    // Build display items with section headers
+    const displayItems: SelectItem[] = [];
+    const selectableItems: { index: number; candidate: SimplifyResult }[] = [];
+    let globalIndex = 0;
+
+    if (safeCandidates.length > 0) {
+      displayItems.push({
+        value: "__section__safe__",
+        label: `── Safe to delete (${safeCandidates.length}) ──`,
+        description: "",
+      });
+      globalIndex++;
+      for (const c of safeCandidates) {
+        displayItems.push({
+          value: JSON.stringify(c),
+          label: `${c.file} - ${c.reason}`,
+          description: "Will be deleted",
+        });
+        selectableItems.push({ index: globalIndex, candidate: c });
+        globalIndex++;
+      }
+    }
+
+    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);
+    }
+
+    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];
+          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 });
+            }
+          }
+        }
+
+        // Show visible range with scroll
+        const startIdx = Math.max(0, scrollOffset);
+        const endIdx = Math.min(visibleItems.length, startIdx + maxVisible);
+
+        for (let vIdx = startIdx; vIdx < endIdx; vIdx++) {
+          const { selectableIdx, item } = visibleItems[vIdx];
+
+          if (item.value.startsWith("__section__")) {
+            // Section header
+            lines.push(theme.fg("accent", item.label));
+          } else {
+            // Selectable item
+            const isCursor = selectableIdx === cursorPos;
+            const isSelected = selectableIdx !== null && selectedSet.has(selectableIdx);
+            const prefix = isCursor ? theme.fg("accent", "> ") : "  ";
+            const checkbox = isSelected ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
+            const truncatedLabel = truncateToWidth(item.label, width - 6);
+            const line = `${prefix}${checkbox} ${truncatedLabel}`;
+            lines.push(isCursor ? theme.fg("accent", line) : line);
+          }
+        }
+
+        // Scroll indicator
+        if (visibleItems.length > maxVisible) {
+          const scrollInfo = `  (${startIdx + 1}-${endIdx}/${visibleItems.length})`;
+          lines.push(theme.fg("dim", scrollInfo));
+        }
+
+        return lines;
+      };
+
+      return {
+        render(width: number) {
+          const lines: string[] = [];
+          lines.push(theme.bold("Simplify: Select items to remove"));
+          lines.push(
+            theme.fg(
+              "muted",
+              `Found ${candidates.length} candidates (${safeCandidates.length} safe, ${confirmCandidates.length} confirm, ${reviewCandidates.length} review)`,
+            ),
+          );
+          lines.push("");
+          lines.push(...renderList(width));
+          lines.push("");
+          lines.push(
+            theme.fg(
+              "muted",
+              `Selected: ${selectedSet.size} • ↑↓ navigate • space toggle • a select all • enter confirm • esc cancel`,
+            ),
+          );
+          return lines;
+        },
+        invalidate() {},
+        handleInput(data: string) {
+          if (matchesKey(data, Key.enter)) {
+            const results = Array.from(selectedSet).map((i) => selectableItems[i].candidate);
+            done(results);
+            return;
+          }
+          if (matchesKey(data, Key.escape)) {
+            done([]);
+            return;
+          }
+          if (matchesKey(data, Key.space)) {
+            // Toggle current selection
+            if (selectedSet.has(cursorPos)) {
+              selectedSet.delete(cursorPos);
+            } else {
+              selectedSet.add(cursorPos);
+            }
+            tui.requestRender();
+            return;
+          }
+          if (matchesKey(data, "a")) {
+            // Select/deselect all
+            if (selectedSet.size === selectableItems.length) {
+              selectedSet.clear();
+            } else {
+              for (let i = 0; i < selectableItems.length; i++) {
+                selectedSet.add(i);
+              }
+            }
+            tui.requestRender();
+            return;
+          }
+
+          // Navigation
+          if (matchesKey(data, Key.down)) {
+            cursorPos = Math.min(selectableItems.length - 1, cursorPos + 1);
+            // Ensure cursor is within visible window
+            const displayIdx = selectableItems[cursorPos].index;
+            if (displayIdx >= scrollOffset + maxVisible) {
+              scrollOffset = displayIdx - maxVisible + 1;
+            }
+            tui.requestRender();
+            return;
+          }
+          if (matchesKey(data, Key.up)) {
+            cursorPos = Math.max(0, cursorPos - 1);
+            // Ensure cursor is within visible window
+            const displayIdx = selectableItems[cursorPos].index;
+            if (displayIdx < scrollOffset) {
+              // Scroll up to show the item, and include section header if it's just above
+              scrollOffset = Math.max(0, displayIdx - 1);
+            }
+            tui.requestRender();
+            return;
+          }
+          if (matchesKey(data, Key.home)) {
+            cursorPos = 0;
+            scrollOffset = 0;
+            tui.requestRender();
+            return;
+          }
+          if (matchesKey(data, Key.end)) {
+            cursorPos = selectableItems.length - 1;
+            const lastDisplayIdx = selectableItems[cursorPos].index;
+            scrollOffset = Math.max(0, lastDisplayIdx - maxVisible + 1);
+            tui.requestRender();
+            return;
+          }
+        },
+      };
+    });
+
+    return result ?? [];
+  }
+
+  /**
+   * Execute the cleanup by sending deletion commands
+   */
+  async function executeCleanup(
+    ctx: ExtensionCommandContext,
+    selected: SimplifyResult[],
+  ): Promise<void> {
+    if (selected.length === 0) {
+      ctx.ui.notify("No items selected for cleanup", "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
+
+Delete the following code:
+
+${selected.map((c) => `- ${c.file}: ${c.reason}`).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
+
+Report:
+- What was deleted
+- Any issues encountered
+- Files that may need further attention`;
+
+    ctx.ui.notify(
+      `Starting cleanup of ${selected.length} items (${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)",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Simplify requires interactive mode", "error");
+        return;
+      }
+
+      if (!ctx.isIdle()) {
+        ctx.ui.notify(
+          "Cannot run simplify while agent is busy. Wait for current task to complete.",
+          "warning",
+        );
+        return;
+      }
+
+      // Check if in git repo
+      const { code } = await pi.exec("git", ["rev-parse", "--git-dir"]);
+      if (code !== 0) {
+        ctx.ui.notify("Not a git repository", "error");
+        return;
+      }
+
+      // Check if there are changes
+      const { stdout: gitStatus } = await pi.exec("git", ["status", "--porcelain"]);
+      if (!gitStatus.trim()) {
+        ctx.ui.notify("No git changes found. Simplify reviews uncommitted changes.", "info");
+        return;
+      }
+
+      ctx.ui.notify("Analyzing code for cleanup candidates...", "info");
+
+      // Build prompt with optional focus
+      let fullPrompt = SIMPLIFY_PROMPT;
+      if (args.trim()) {
+        fullPrompt += `\n\n## Additional Focus\n\n${args.trim()}`;
+      }
+
+      // 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.
+      assistantTextBuffer = "";
+      let resolveTurnStarted: () => void;
+      const turnStarted = new Promise<void>((r) => {
+        resolveTurnStarted = r;
+      });
+      pi.on("turn_start", () => resolveTurnStarted!());
+      pi.sendUserMessage(fullPrompt);
+      await turnStarted;
+      await ctx.waitForIdle();
+      const analysisText = assistantTextBuffer;
+
+      if (!analysisText) {
+        ctx.ui.notify("Could not read analysis — no response captured.", "error");
+        return;
+      }
+
+      const outcome = parseCandidates(analysisText);
+
+      if (outcome.kind === "unparseable") {
+        const debugPath = dumpDebug(analysisText);
+        const suffix = debugPath ? ` Raw response saved to ${debugPath}` : "";
+        ctx.ui.notify(
+          `Could not parse cleanup candidates — the model did not return the expected JSON block.${suffix}`,
+          "warning",
+        );
+        return;
+      }
+
+      const candidates = outcome.candidates;
+      if (candidates.length === 0) {
+        ctx.ui.notify("No cleanup candidates found!", "info");
+        return;
+      }
+
+      ctx.ui.notify(`Found ${candidates.length} candidates. Select items to remove...`, "info");
+
+      // Show selector
+      const selected = await showCandidateSelector(ctx, candidates);
+
+      if (!selected || selected.length === 0) {
+        ctx.ui.notify("Cleanup cancelled", "info");
+        return;
+      }
+
+      // Execute cleanup
+      await executeCleanup(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) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Simplify requires interactive mode", "error");
+        return;
+      }
+
+      if (!ctx.isIdle()) {
+        ctx.ui.notify("Agent is busy. Try again after current task.", "warning");
+        return;
+      }
+
+      const quickPrompt = `# Quick Cleanup
+
+Find and delete ONLY the most obviously safe cleanup items:
+
+1. \`console.log\`, \`console.warn\`, \`console.error\` statements
+2. \`debugger\` statements
+3. Unused \`import\` statements (imported but never used)
+4. Empty \`catch\` blocks (just \`catch (e) {}\`)
+5. Unused \`const\`/\`let\`/\`var\` declarations
+
+DO NOT delete:
+- Commented-out code
+- Over-engineered abstractions
+- Duplicate logic
+- Anything that might be needed
+
+For each item found:
+1. Confirm it's truly unused by searching for references
+2. Delete only the specific lines
+3. Report what was deleted
+
+Return a summary of what was deleted.`;
+
+      ctx.ui.notify("Running quick cleanup...", "info");
+      pi.sendUserMessage(quickPrompt, { deliverAs: "followUp" });
+    },
+  });
 
-export default function simplifyExtension(pi: ExtensionAPI): void {
-	pi.registerCommand("simplify", {
-		description: "Review changed code for reuse, quality, and efficiency, then fix issues",
-		handler: async (args: string, ctx: ExtensionCommandContext) => {
-			runSimplify(pi, ctx, args);
-		},
-	});
+  /**
+   * 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,23 +1,34 @@
 {
-	"name": "@geminixiang/pi-simplify",
-	"version": "0.0.3",
-	"description": "Simplify: code reuse, quality, and efficiency review for pi coding agent",
-	"main": "index.ts",
-	"keywords": [
-		"pi-package"
-	],
-	"author": "geminixiang",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/geminixiang/pi-simplify"
-	},
-	"license": "MIT",
-	"pi": {
-		"extensions": [
-			"./index.ts"
-		]
-	},
-	"dependencies": {
-		"@mariozechner/pi-coding-agent": "^0.65.2"
-	}
+  "name": "@geminixiang/pi-simplify",
+  "version": "0.0.4",
+  "description": "Simplify: Clean up leftover code after feature implementation",
+  "keywords": [
+    "pi-package"
+  ],
+  "license": "MIT",
+  "author": "geminixiang",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geminixiang/pi-simplify"
+  },
+  "main": "index.ts",
+  "scripts": {
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check"
+  },
+  "dependencies": {
+    "@mariozechner/pi-coding-agent": "^0.65.2"
+  },
+  "devDependencies": {
+    "oxfmt": "^0.45.0",
+    "oxlint": "^1.60.0",
+    "typescript": "^6.0.2"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
 }

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  }
+}