@geminixiang/pi-simplify 0.0.5 → 0.0.7

package/.pi/skills/release/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: release
+description: Prepare and publish a new pi-simplify release. Use when bumping the version, committing and pushing it, and creating a GitHub release in the style of earlier pi-simplify releases.
+---
+
+# pi-simplify Release
+
+Repo defaults:
+
+- branch: `main`
+- remote: `origin`
+- repo: `geminixiang/pi-simplify`
+- npm package: `@geminixiang/pi-simplify`
+- use `package.json` version as the git tag and GitHub release title
+- versions with `-alpha.`, `-beta.`, or `-rc.` are prereleases by default
+
+## Version rules
+
+Examples:
+
+- stable: `0.2.1`, `0.3.0`, `1.0.0`
+- prerelease: `0.2.0-beta.8`, `0.3.0-rc.1`, `1.0.0-alpha.2`
+
+Guidance:
+
+- `patch` = bugfix / small maintenance
+- `minor` = backward-compatible features
+- `major` = breaking changes
+- prerelease numbers increase within the same line, e.g. `beta.8 -> beta.9`
+- promote prerelease to stable by dropping the suffix, e.g. `0.2.0-beta.8 -> 0.2.0`
+
+## Flow
+
+### 1. Check state
+
+```bash
+git status --short
+git branch --show-current
+git remote -v
+git tag --list | tail -20
+```
+
+Read `package.json` and `package-lock.json`. If unrelated files are modified, ask before committing.
+
+### 2. Sync version files
+
+Preferred:
+
+```bash
+npm version <version> --no-git-tag-version
+```
+
+Use this to sync `package.json` and `package-lock.json` without creating an automatic commit or tag. If the user already edited `package.json`, just verify `package-lock.json` matches.
+
+### 3. Update CHANGELOG
+
+`CHANGELOG.md` follows Keep a Changelog with `### Added / Changed / Fixed / Removed / Security / Performance / Tests` subsections. The newest release sits at the top under an `## [Unreleased]` placeholder.
+
+Gather user-visible changes since the previous tag:
+
+```bash
+git log --pretty=format:'%h %s' <previous-tag>..HEAD | grep -v "^[a-f0-9]* chore: bump version"
+```
+
+Then in `CHANGELOG.md`:
+
+- Keep `## [Unreleased]` at the top as an empty placeholder.
+- Insert a new section `## [<version>] - <YYYY-MM-DD>` (use today's date for stable, omit the date for prereleases to match the existing style).
+- Group entries by subsection; one bullet per user-visible change, imperative voice, no commit hashes.
+- Skip pure internal refactors that don't change behavior unless they affect contributors (then list under `### Changed`).
+
+If you generated draft release notes in step 5 first, copy the same wording into CHANGELOG — they should match.
+
+### 4. Commit and push
+
+Stage version files and CHANGELOG together — the bump and the changelog entry belong in the same commit.
+
+```bash
+git add package.json package-lock.json CHANGELOG.md
+git commit -m "chore: bump version to <version>"
+git push origin main
+```
+
+### 5. Draft release notes
+
+Use the previous GitHub release as the style reference.
+
+```bash
+gh release list --repo geminixiang/pi-simplify --limit 10
+gh release view <previous-tag> --repo geminixiang/pi-simplify --json tagName,name,body,url,publishedAt
+git log --pretty=format:'%h %s' <previous-tag>..HEAD
+git diff --stat <previous-tag>..HEAD
+```
+
+Write concise notes focused on user-visible changes, usually with:
+
+- `## What's changed`
+- `### Highlights`
+- `### Notable changes`
+- `### Docs and maintenance`
+- `### Verification`
+
+Write notes to `/tmp/pi-simplify-release-<version>.md`. Keep them consistent with the CHANGELOG entry from step 3.
+
+### 6. Create or update release
+
+Prerelease:
+
+```bash
+gh release create <version> \
+  --repo geminixiang/pi-simplify \
+  --target main \
+  --title <version> \
+  --notes-file /tmp/pi-simplify-release-<version>.md \
+  --prerelease
+```
+
+Stable:
+
+```bash
+gh release create <version> \
+  --repo geminixiang/pi-simplify \
+  --target main \
+  --title <version> \
+  --notes-file /tmp/pi-simplify-release-<version>.md
+```
+
+If it already exists, use `gh release edit <version> ...` and keep prerelease/stable intent consistent.
+
+## Report back
+
+Return:
+
+- released version
+- stable or prerelease
+- version-bump commit hash
+- push status
+- release URL
+
+## Guardrails
+
+- Always use `geminixiang/pi-simplify`.
+- Infer stable vs prerelease from the version, or ask.
+- Do not include raw commit hashes in release notes unless requested.
+- If hooks fail during commit, fix or report before retrying.
+- Never publish a release without a corresponding CHANGELOG entry — the version bump commit must include the new CHANGELOG section.

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [Unreleased]
+
+## [0.0.7] - 2026-05-25
+
+### Changed
+
+- Use pi's native select list for findings selection.
+- Wrap long finding recommendations in the selection menu.
+- Split the simplify extension into prompt, selector, workflow, and shared type modules.
+- Update dependencies to the current `@earendil-works` pi packages.
+
+### Removed
+
+- Remove the `/simplify-quick` command and its documentation.
+
+### Added
+
+- Add a project release workflow skill for future releases.

package/README.md

@@ -36,21 +36,6 @@ Analyzes all git changes and presents cleanup candidates:
 - **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
 
 ```

package/index.ts

@@ -1,610 +1,16 @@
 /**
- * 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 type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
-import { matchesKey, Key, truncateToWidth, type SelectItem } from "@mariozechner/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-type SimplifyResult = {
-  file: string;
-  lines: string;
-  reason: string;
-  risk: "safe" | "confirm" | "review";
-};
-
-const SIMPLIFY_PROMPT = `# Simplify: Clean Up Leftover Code
-
-You are a code cleanup assistant. Your job is to identify and remove unnecessary code left over after feature implementation.
-
-## 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
-
-## How to Analyze
-
-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
-
-3. For each residual item:
-   - Identify exact file and line(s)
-   - Assess risk level
-   - Provide clear reason for removal
-
-## 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)
-
-## 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:
-   - Error handling code
-   - Security-related logic
-   - Code that looks "unused" but is called via reflection/eval
-   - Database migration files
-
-## Output Format (REQUIRED)
-
-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",
-      "reason": "Why this should be removed",
-      "action": "delete"
-    }
-  ]
-}
-\`\`\`
-
-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.
-`;
+import { registerSimplifyWorkflow } from "./workflow.js";
 
 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;
-
-  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" });
-    },
-  });
-
-  /**
-   * 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)")}`,
-      );
-    }
-  });
-  */
+  registerSimplifyWorkflow(pi);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@geminixiang/pi-simplify",
-  "version": "0.0.5",
-  "description": "Simplify: Clean up leftover code after feature implementation",
+  "version": "0.0.7",
+  "description": "Simplify: Review changed code for reuse, quality, and efficiency",
   "keywords": [
     "pi-package"
   ],
@@ -19,7 +19,9 @@
     "fmt:check": "oxfmt --check"
   },
   "dependencies": {
-    "@mariozechner/pi-coding-agent": "^0.65.2"
+    "@earendil-works/pi-coding-agent": ">=0.74.0",
+    "@earendil-works/pi-tui": ">=0.74.0",
+    "typebox": "^1.1.38"
   },
   "devDependencies": {
     "oxfmt": "^0.45.0",

package/prompt.ts

@@ -0,0 +1,93 @@
+export const SIMPLIFY_PROMPT = `# Simplify: Review Changed Code for Reuse, Quality, and Efficiency
+
+You are a code review assistant. Review the changed code along three axes — **Reuse**, **Quality**, and **Efficiency** — and surface concrete fixes.
+
+Match the user's language for candidate reasons and summaries; if the user's request is in Chinese, write the candidate \`reason\` fields in Chinese.
+
+## What to Find
+
+### A. Reuse (Confirm Before Replacing)
+
+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
+
+#### 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
+
+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)
+   - 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 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 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
+   - Database migration files
+
+## Output Format (REQUIRED)
+
+When analysis is complete, call the \`simplify_candidates\` tool exactly once as your final action. Put ALL candidates in that tool call.
+
+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
+- \`reason\` — single plain-text sentence stating the concrete fix
+- \`action\` — one of: "delete", "inline", "refactor", "parallelize"
+
+If there are no candidates, call \`simplify_candidates\` with an empty \`candidates\` array.
+Do NOT write a prose-only final answer; the extension relies on the tool result.
+`;

package/selector.ts

@@ -0,0 +1,176 @@
+import { getSelectListTheme, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  matchesKey,
+  Key,
+  SelectList,
+  wrapTextWithAnsi,
+  type SelectItem,
+} from "@earendil-works/pi-tui";
+
+import type { Action, SimplifyResult } from "./types.js";
+
+const RISK_CONFIG = {
+  safe: { label: "Safe to apply" },
+  confirm: { label: "Needs confirmation" },
+  review: { label: "Needs review" },
+} as const;
+
+const ACTION_LABEL: Record<Action, string> = {
+  delete: "Delete code",
+  inline: "Inline code",
+  refactor: "Refactor code",
+  parallelize: "Run work in parallel",
+};
+
+export async function showCandidateSelector(
+  ctx: ExtensionCommandContext,
+  candidates: SimplifyResult[],
+): Promise<SimplifyResult[]> {
+  if (candidates.length === 0) return [];
+
+  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 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 selectableItems = sections.flatMap((section) =>
+    section.items.map((candidate) => ({ section, candidate })),
+  );
+
+  const listItems: SelectItem[] = selectableItems.map(({ section, candidate }, index) => ({
+    value: String(index),
+    label: "",
+    description: `${section.config.label} · ${ACTION_LABEL[candidate.action]}`,
+  }));
+
+  const selectedSet = new Set<number>();
+  selectableItems.forEach(({ candidate }, index) => {
+    if (candidate.risk === "safe") selectedSet.add(index);
+  });
+
+  const maxVisible = 8;
+  let cursorPos = 0;
+
+  const getSelectListStartIndex = (selectedIndex: number) =>
+    Math.max(
+      0,
+      Math.min(selectedIndex - Math.floor(maxVisible / 2), selectableItems.length - maxVisible),
+    );
+
+  const result = await ctx.ui.custom<SimplifyResult[]>((tui, theme, _keybindings, done) => {
+    const updateListLabel = (index: number) => {
+      const item = listItems[index];
+      const { candidate } = selectableItems[index];
+      const checkbox = selectedSet.has(index) ? "[x]" : "[ ]";
+      const location = candidate.lines ? `${candidate.file}:${candidate.lines}` : candidate.file;
+      item.label = `${checkbox} ${location}`;
+    };
+    const updateAllListLabels = () => listItems.forEach((_item, index) => updateListLabel(index));
+
+    updateAllListLabels();
+
+    const selectList = new SelectList(listItems, maxVisible, getSelectListTheme());
+    selectList.onSelectionChange = (item) => {
+      cursorPos = Number(item.value);
+    };
+    selectList.onCancel = () => done([]);
+
+    return {
+      render(width: number) {
+        selectList.setSelectedIndex(cursorPos);
+
+        const lines: string[] = [];
+        lines.push(theme.bold("Simplify: Select findings to apply"));
+        lines.push(
+          theme.fg(
+            "muted",
+            `Found ${candidates.length} candidates (${safeCandidates.length} safe, ${confirmCandidates.length} confirm, ${reviewCandidates.length} review)`,
+          ),
+        );
+        lines.push("");
+
+        const listLines = selectList.render(width);
+        const selectedLineIndex = cursorPos - getSelectListStartIndex(cursorPos);
+        const current = selectableItems[cursorPos]?.candidate;
+        for (const [lineIndex, line] of listLines.entries()) {
+          lines.push(line);
+          if (lineIndex !== selectedLineIndex || !current) continue;
+
+          const detailIndent = "    ";
+          const detailPrefix = `${detailIndent}│ `;
+          const location = current.lines ? `${current.file}:${current.lines}` : current.file;
+          lines.push(theme.fg("borderMuted", `${detailIndent}┌─ recommendation`));
+          lines.push(
+            ...wrapTextWithAnsi(current.reason, Math.max(1, width - detailPrefix.length)).map(
+              (wrappedLine) => theme.fg("muted", `${detailPrefix}${wrappedLine}`),
+            ),
+          );
+          lines.push(theme.fg("muted", `${detailPrefix}`));
+          lines.push(theme.fg("muted", `${detailPrefix}File: ${location}`));
+          lines.push(
+            theme.fg("muted", `${detailPrefix}Review: ${RISK_CONFIG[current.risk].label}`),
+          );
+          lines.push(theme.fg("muted", `${detailPrefix}Kind: ${current.category}`));
+          lines.push(theme.fg("muted", `${detailPrefix}Fix: ${ACTION_LABEL[current.action]}`));
+          lines.push(theme.fg("borderMuted", `${detailIndent}└─ space selects this fix`));
+        }
+
+        lines.push("");
+        lines.push(
+          theme.fg(
+            "muted",
+            `Selected: ${selectedSet.size} • ↑↓ navigate • space toggle • a select all • enter confirm • esc cancel`,
+          ),
+        );
+        return lines;
+      },
+      invalidate() {
+        selectList.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)) {
+          if (selectedSet.has(cursorPos)) {
+            selectedSet.delete(cursorPos);
+          } else {
+            selectedSet.add(cursorPos);
+          }
+          updateListLabel(cursorPos);
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, "a")) {
+          if (selectedSet.size === selectableItems.length) {
+            selectedSet.clear();
+          } else {
+            for (let i = 0; i < selectableItems.length; i++) selectedSet.add(i);
+          }
+          updateAllListLabels();
+          tui.requestRender();
+          return;
+        }
+
+        const previousCursorPos = cursorPos;
+        selectList.handleInput(data);
+        if (cursorPos !== previousCursorPos) tui.requestRender();
+      },
+    };
+  });
+
+  return result ?? [];
+}

package/types.ts

@@ -0,0 +1,12 @@
+export type Category = "reuse" | "quality" | "efficiency";
+export type Risk = "safe" | "confirm" | "review";
+export type Action = "delete" | "inline" | "refactor" | "parallelize";
+
+export type SimplifyResult = {
+  category: Category;
+  file: string;
+  lines: string;
+  reason: string;
+  risk: Risk;
+  action: Action;
+};

package/workflow.ts

@@ -0,0 +1,257 @@
+import {
+  defineTool,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+import { SIMPLIFY_PROMPT } from "./prompt.js";
+import { showCandidateSelector } from "./selector.js";
+import type { SimplifyResult } from "./types.js";
+
+const categorySchema = Type.Union([
+  Type.Literal("reuse"),
+  Type.Literal("quality"),
+  Type.Literal("efficiency"),
+]);
+const riskSchema = Type.Union([
+  Type.Literal("safe"),
+  Type.Literal("confirm"),
+  Type.Literal("review"),
+]);
+const actionSchema = Type.Union([
+  Type.Literal("delete"),
+  Type.Literal("inline"),
+  Type.Literal("refactor"),
+  Type.Literal("parallelize"),
+]);
+
+function registerSimplifyCandidatesTool(
+  pi: ExtensionAPI,
+  state: {
+    getResolver: () => ((candidates: SimplifyResult[]) => void) | null;
+    clearResolver: () => void;
+    setLatestCandidates: (candidates: SimplifyResult[]) => void;
+  },
+) {
+  const parameters = Type.Object({
+    candidates: Type.Array(
+      Type.Object({
+        category: categorySchema,
+        risk: riskSchema,
+        file: Type.String({
+          description: "Repository-relative path",
+          minLength: 1,
+          pattern: "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$)).+$",
+        }),
+        lines: Type.String({ description: "Line number or range, or empty string if unknown" }),
+        reason: Type.String({ description: "Concrete fix in one sentence" }),
+        action: actionSchema,
+      }),
+    ),
+  });
+
+  pi.registerTool(
+    defineTool({
+      name: "simplify_candidates",
+      label: "Simplify Candidates",
+      description:
+        "Return the complete candidate list for /simplify. Use as the final action after analyzing changed code.",
+      promptSnippet: "Return structured cleanup candidates for /simplify as a terminating result",
+      promptGuidelines: [
+        "Use simplify_candidates exactly once as the final action when the /simplify command asks for cleanup candidates.",
+      ],
+      parameters,
+      async execute(_toolCallId, params) {
+        const candidates: SimplifyResult[] = params.candidates;
+        const resolve = state.getResolver();
+        if (!resolve) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "Ignored simplify candidates because no /simplify analysis is pending.",
+              },
+            ],
+            details: {
+              ignored: true,
+              candidates: [],
+              byRisk: { safe: 0, confirm: 0, review: 0 },
+            },
+            terminate: true,
+          };
+        }
+
+        state.setLatestCandidates(candidates);
+        state.clearResolver();
+        resolve(candidates);
+
+        const byRisk = {
+          safe: candidates.filter((c) => c.risk === "safe").length,
+          confirm: candidates.filter((c) => c.risk === "confirm").length,
+          review: candidates.filter((c) => c.risk === "review").length,
+        };
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Captured ${candidates.length} simplify candidates (${byRisk.safe} safe, ${byRisk.confirm} confirm, ${byRisk.review} review).`,
+            },
+          ],
+          details: { ignored: false, candidates, byRisk },
+          terminate: true,
+        };
+      },
+    }),
+  );
+}
+
+async function applyFindings(
+  ctx: ExtensionCommandContext,
+  selected: SimplifyResult[],
+  pi: ExtensionAPI,
+) {
+  if (selected.length === 0) {
+    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");
+
+  const cleanupPrompt = `# Apply Review Findings
+
+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.lines || "?"}): ${c.reason} [${c.action}]`).join("\n")}
+
+For each item:
+1. Read the file to find the exact location
+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
+
+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(
+    `Applying ${selected.length} findings (${safeItems.length} safe, ${confirmItems.length} confirmed)`,
+    "info",
+  );
+
+  pi.sendUserMessage(cleanupPrompt);
+}
+
+export function registerSimplifyWorkflow(pi: ExtensionAPI) {
+  let resolvePendingTurnStart: (() => void) | null = null;
+  let resolvePendingCandidatesTool: ((candidates: SimplifyResult[]) => void) | null = null;
+  let latestToolCandidates: SimplifyResult[] | null = null;
+
+  pi.on("turn_start", () => {
+    if (!resolvePendingTurnStart) return;
+    const resolve = resolvePendingTurnStart;
+    resolvePendingTurnStart = null;
+    resolve();
+  });
+
+  registerSimplifyCandidatesTool(pi, {
+    getResolver: () => resolvePendingCandidatesTool,
+    clearResolver: () => {
+      resolvePendingCandidatesTool = null;
+    },
+    setLatestCandidates: (candidates) => {
+      latestToolCandidates = candidates;
+    },
+  });
+
+  pi.registerCommand("simplify", {
+    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");
+        return;
+      }
+
+      if (!ctx.isIdle()) {
+        ctx.ui.notify(
+          "Cannot run simplify while agent is busy. Wait for current task to complete.",
+          "warning",
+        );
+        return;
+      }
+
+      const { code } = await pi.exec("git", ["rev-parse", "--git-dir"]);
+      if (code !== 0) {
+        ctx.ui.notify("Not a git repository", "error");
+        return;
+      }
+
+      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 review findings...", "info");
+
+      let fullPrompt = SIMPLIFY_PROMPT;
+      if (args.trim()) fullPrompt += `\n\n## Additional Focus\n\n${args.trim()}`;
+
+      latestToolCandidates = null;
+      const turnStarted = new Promise<void>((r) => {
+        resolvePendingTurnStart = r;
+      });
+      const toolResult = new Promise<SimplifyResult[]>((r) => {
+        resolvePendingCandidatesTool = 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;
+        resolvePendingCandidatesTool = null;
+        ctx.ui.notify("Analysis did not start within 10 seconds. Please try again.", "warning");
+        return;
+      }
+
+      await ctx.waitForIdle();
+
+      const candidates =
+        latestToolCandidates ??
+        (await Promise.race<SimplifyResult[] | null>([
+          toolResult,
+          new Promise<null>((r) => setTimeout(() => r(null), 100)),
+        ]));
+      resolvePendingCandidatesTool = null;
+
+      if (candidates === null) {
+        ctx.ui.notify(
+          "Could not read review findings — the model did not call simplify_candidates.",
+          "warning",
+        );
+        return;
+      }
+
+      if (candidates.length === 0) {
+        ctx.ui.notify("No review findings found!", "info");
+        return;
+      }
+
+      ctx.ui.notify(`Found ${candidates.length} findings. Select findings to apply...`, "info");
+
+      const selected = await showCandidateSelector(ctx, candidates);
+      if (!selected || selected.length === 0) {
+        ctx.ui.notify("Apply findings cancelled", "info");
+        return;
+      }
+
+      await applyFindings(ctx, selected, pi);
+    },
+  });
+}