@geminixiang/pi-simplify 0.0.3 → 0.0.5

package/README.md

@@ -1,47 +1,72 @@
 # 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.
+[![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
 
-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-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 performance in the database layer
+/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,610 @@
+/**
+ * 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 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:
 
-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.
+\`\`\`json
+{
+  "candidates": [
+    {
+      "risk": "safe",
+      "file": "path/to/file.ext",
+      "lines": "12-15",
+      "reason": "Why this should be removed",
+      "action": "delete"
+    }
+  ]
+}
+\`\`\`
 
-When done, briefly summarize what was fixed (or confirm the code was already clean).
+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
+- \`reason\` — single plain-text sentence
+- \`action\` — one of: "delete", "inline", "confirm" (appended to reason)
+
+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 = "";
+  let resolvePendingTurnStart: (() => void) | null = null;
 
-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");
-}
+  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;
+    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;
+  });
+
+  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 ?? ""));
+          // 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))}]` : "";
+          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;
+  }
+
+  /**
+   * 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");
+
+    const RISK_CONFIG = {
+      safe: { label: "Safe to delete", description: "Will be deleted", selected: true },
+      confirm: { label: "Needs confirmation", description: "Select to delete", selected: false },
+      review: { label: "Needs review", description: "Review before deleting", selected: false },
+    } 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;
+
+    for (const section of sections) {
+      displayItems.push({
+        value: `__section__${section.key}__`,
+        label: `── ${section.config.label} (${section.total}) ──`,
+        description: "",
+      });
+      globalIndex++;
+      for (const c of section.items) {
+        displayItems.push({
+          value: JSON.stringify(c),
+          label: `${c.file} - ${c.reason}`,
+          description: section.config.description,
+        });
+        selectableItems.push({ index: globalIndex++, candidate: c });
+      }
+    }
+
+    // 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];
+          if (item.value.startsWith("__section__")) {
+            visibleItems.push({ selectableIdx: null, item });
+          } else {
+            const selectableIdx = selectableItems.findIndex((si) => si.index === i);
+            if (selectableIdx >= 0) {
+              visibleItems.push({ selectableIdx, item: displayItems[i] });
+            }
+          }
+        }
+
+        // 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 with verification step
+    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
+
+IMPORTANT: After completing deletions:
+- Run \`npm test\` or equivalent test command
+- If tests fail, report which tests failed and whether it's related to the cleanup
+- If there are no tests, at least verify the files parse correctly (e.g., \`node --check\`)
+
+Report:
+- What was deleted
+- Test results (pass/fail)
+- 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.
+      //
+      // 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 = "";
+      const turnStarted = new Promise<void>((r) => {
+        resolvePendingTurnStart = r;
+      });
+
+      pi.sendUserMessage(fullPrompt);
+
+      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;
+
+      if (!analysisText) {
+        ctx.ui.notify("Could not read analysis — no response captured.", "error");
+        return;
+      }
+
+      const candidates = parseCandidatesJSON(analysisText);
+
+      if (candidates === null) {
+        ctx.ui.notify(
+          "Could not parse cleanup candidates — the model did not return the expected JSON block.",
+          "warning",
+        );
+        return;
+      }
+
+      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.5",
+  "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"
+  }
+}