@staff0rd/assist 0.42.1 → 0.43.0

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { execSync as execSync18 } from "child_process";
+import { execSync as execSync19 } from "child_process";
 import { Command } from "commander";
 
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.42.1",
+  version: "0.43.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -28,7 +28,7 @@ var package_default = {
     "verify:types": "tsc --noEmit",
     "verify:knip": "knip --no-progress --treat-config-hints-as-errors",
     "verify:duplicate-code": "jscpd --format 'typescript,tsx' --exitCode 1 --ignore '**/*.test.*' -r consoleFull src",
-    "verify:maintainability": "assist complexity maintainability ./src --threshold 50",
+    "verify:maintainability": "assist complexity maintainability ./src --threshold 60",
     "verify:custom-lint": "assist lint"
   },
   keywords: [],
@@ -107,6 +107,9 @@ var assistConfigSchema = z.strictObject({
   complexity: z.strictObject({
     ignore: z.array(z.string()).default(["**/*test.ts*"])
   }).default({ ignore: ["**/*test.ts*"] }),
+  restructure: z.strictObject({
+    ignore: z.array(z.string()).default([])
+  }).optional(),
   run: z.array(runConfigSchema).optional(),
   transcript: transcriptConfigSchema.optional()
 });
@@ -212,72 +215,159 @@ function commit(message) {
 import chalk3 from "chalk";
 
 // src/commands/complexity/shared.ts
+import fs2 from "fs";
+import path2 from "path";
+import chalk2 from "chalk";
+import ts4 from "typescript";
+
+// src/commands/complexity/findSourceFiles.ts
 import fs from "fs";
 import path from "path";
-import chalk2 from "chalk";
 import { minimatch } from "minimatch";
-import ts3 from "typescript";
+function applyIgnoreGlobs(files) {
+  const { complexity } = loadConfig();
+  return files.filter(
+    (f) => !complexity.ignore.some((glob) => minimatch(f, glob))
+  );
+}
+function walk(dir, results) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+  const extensions = [".ts", ".tsx"];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "node_modules" && entry.name !== ".git") {
+        walk(fullPath, results);
+      }
+    } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
+      results.push(fullPath);
+    }
+  }
+}
+function findSourceFiles(pattern2, baseDir = ".") {
+  const results = [];
+  if (pattern2.includes("*")) {
+    walk(baseDir, results);
+    return applyIgnoreGlobs(results.filter((f) => minimatch(f, pattern2)));
+  }
+  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isFile()) {
+    return [pattern2];
+  }
+  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isDirectory()) {
+    walk(pattern2, results);
+    return applyIgnoreGlobs(results);
+  }
+  walk(baseDir, results);
+  return applyIgnoreGlobs(results.filter((f) => minimatch(f, pattern2)));
+}
 
-// src/commands/complexity/calculateCyclomaticComplexity.ts
+// src/commands/complexity/getNodeName.ts
 import ts from "typescript";
+function getNodeName(node) {
+  if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+    return node.name?.text ?? "<anonymous>";
+  }
+  if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) {
+    if (ts.isIdentifier(node.name)) {
+      return node.name.text;
+    }
+    if (ts.isStringLiteral(node.name)) {
+      return node.name.text;
+    }
+    return "<computed>";
+  }
+  if (ts.isArrowFunction(node)) {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+      return parent.name.text;
+    }
+    if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
+      return parent.name.text;
+    }
+    return "<arrow>";
+  }
+  if (ts.isGetAccessor(node) || ts.isSetAccessor(node)) {
+    const prefix = ts.isGetAccessor(node) ? "get " : "set ";
+    if (ts.isIdentifier(node.name)) {
+      return `${prefix}${node.name.text}`;
+    }
+    return `${prefix}<computed>`;
+  }
+  if (ts.isConstructorDeclaration(node)) {
+    return "constructor";
+  }
+  return "<unknown>";
+}
+function hasFunctionBody(node) {
+  if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isConstructorDeclaration(node)) {
+    return node.body !== void 0;
+  }
+  return false;
+}
+
+// src/commands/complexity/calculateCyclomaticComplexity.ts
+import ts2 from "typescript";
 var complexityKinds = /* @__PURE__ */ new Set([
-  ts.SyntaxKind.IfStatement,
-  ts.SyntaxKind.ForStatement,
-  ts.SyntaxKind.ForInStatement,
-  ts.SyntaxKind.ForOfStatement,
-  ts.SyntaxKind.WhileStatement,
-  ts.SyntaxKind.DoStatement,
-  ts.SyntaxKind.CaseClause,
-  ts.SyntaxKind.CatchClause,
-  ts.SyntaxKind.ConditionalExpression
+  ts2.SyntaxKind.IfStatement,
+  ts2.SyntaxKind.ForStatement,
+  ts2.SyntaxKind.ForInStatement,
+  ts2.SyntaxKind.ForOfStatement,
+  ts2.SyntaxKind.WhileStatement,
+  ts2.SyntaxKind.DoStatement,
+  ts2.SyntaxKind.CaseClause,
+  ts2.SyntaxKind.CatchClause,
+  ts2.SyntaxKind.ConditionalExpression
 ]);
 var logicalOperators = /* @__PURE__ */ new Set([
-  ts.SyntaxKind.AmpersandAmpersandToken,
-  ts.SyntaxKind.BarBarToken,
-  ts.SyntaxKind.QuestionQuestionToken
+  ts2.SyntaxKind.AmpersandAmpersandToken,
+  ts2.SyntaxKind.BarBarToken,
+  ts2.SyntaxKind.QuestionQuestionToken
 ]);
 function calculateCyclomaticComplexity(node) {
   let complexity = 1;
   function visit(n) {
     if (complexityKinds.has(n.kind)) {
       complexity++;
-    } else if (ts.isBinaryExpression(n) && logicalOperators.has(n.operatorToken.kind)) {
+    } else if (ts2.isBinaryExpression(n) && logicalOperators.has(n.operatorToken.kind)) {
       complexity++;
     }
-    ts.forEachChild(n, visit);
+    ts2.forEachChild(n, visit);
   }
-  ts.forEachChild(node, visit);
+  ts2.forEachChild(node, visit);
   return complexity;
 }
 
 // src/commands/complexity/calculateHalstead.ts
-import ts2 from "typescript";
+import ts3 from "typescript";
 var operatorChecks = [
-  (n) => ts2.isBinaryExpression(n) ? n.operatorToken.getText() : void 0,
-  (n) => ts2.isPrefixUnaryExpression(n) || ts2.isPostfixUnaryExpression(n) ? ts2.tokenToString(n.operator) ?? "" : void 0,
-  (n) => ts2.isCallExpression(n) ? "()" : void 0,
-  (n) => ts2.isPropertyAccessExpression(n) ? "." : void 0,
-  (n) => ts2.isElementAccessExpression(n) ? "[]" : void 0,
-  (n) => ts2.isConditionalExpression(n) ? "?:" : void 0,
-  (n) => ts2.isReturnStatement(n) ? "return" : void 0,
-  (n) => ts2.isIfStatement(n) ? "if" : void 0,
-  (n) => ts2.isForStatement(n) || ts2.isForInStatement(n) || ts2.isForOfStatement(n) ? "for" : void 0,
-  (n) => ts2.isWhileStatement(n) ? "while" : void 0,
-  (n) => ts2.isDoStatement(n) ? "do" : void 0,
-  (n) => ts2.isSwitchStatement(n) ? "switch" : void 0,
-  (n) => ts2.isCaseClause(n) ? "case" : void 0,
-  (n) => ts2.isDefaultClause(n) ? "default" : void 0,
-  (n) => ts2.isBreakStatement(n) ? "break" : void 0,
-  (n) => ts2.isContinueStatement(n) ? "continue" : void 0,
-  (n) => ts2.isThrowStatement(n) ? "throw" : void 0,
-  (n) => ts2.isTryStatement(n) ? "try" : void 0,
-  (n) => ts2.isCatchClause(n) ? "catch" : void 0,
-  (n) => ts2.isNewExpression(n) ? "new" : void 0,
-  (n) => ts2.isTypeOfExpression(n) ? "typeof" : void 0,
-  (n) => ts2.isAwaitExpression(n) ? "await" : void 0
+  (n) => ts3.isBinaryExpression(n) ? n.operatorToken.getText() : void 0,
+  (n) => ts3.isPrefixUnaryExpression(n) || ts3.isPostfixUnaryExpression(n) ? ts3.tokenToString(n.operator) ?? "" : void 0,
+  (n) => ts3.isCallExpression(n) ? "()" : void 0,
+  (n) => ts3.isPropertyAccessExpression(n) ? "." : void 0,
+  (n) => ts3.isElementAccessExpression(n) ? "[]" : void 0,
+  (n) => ts3.isConditionalExpression(n) ? "?:" : void 0,
+  (n) => ts3.isReturnStatement(n) ? "return" : void 0,
+  (n) => ts3.isIfStatement(n) ? "if" : void 0,
+  (n) => ts3.isForStatement(n) || ts3.isForInStatement(n) || ts3.isForOfStatement(n) ? "for" : void 0,
+  (n) => ts3.isWhileStatement(n) ? "while" : void 0,
+  (n) => ts3.isDoStatement(n) ? "do" : void 0,
+  (n) => ts3.isSwitchStatement(n) ? "switch" : void 0,
+  (n) => ts3.isCaseClause(n) ? "case" : void 0,
+  (n) => ts3.isDefaultClause(n) ? "default" : void 0,
+  (n) => ts3.isBreakStatement(n) ? "break" : void 0,
+  (n) => ts3.isContinueStatement(n) ? "continue" : void 0,
+  (n) => ts3.isThrowStatement(n) ? "throw" : void 0,
+  (n) => ts3.isTryStatement(n) ? "try" : void 0,
+  (n) => ts3.isCatchClause(n) ? "catch" : void 0,
+  (n) => ts3.isNewExpression(n) ? "new" : void 0,
+  (n) => ts3.isTypeOfExpression(n) ? "typeof" : void 0,
+  (n) => ts3.isAwaitExpression(n) ? "await" : void 0
 ];
 function classifyNode(n, operators, operands) {
-  if (ts2.isIdentifier(n) || ts2.isNumericLiteral(n) || ts2.isStringLiteral(n)) {
+  if (ts3.isIdentifier(n) || ts3.isNumericLiteral(n) || ts3.isStringLiteral(n)) {
     operands.set(n.text, (operands.get(n.text) ?? 0) + 1);
     return;
   }
@@ -314,9 +404,9 @@ function calculateHalstead(node) {
   const operands = /* @__PURE__ */ new Map();
   function visit(n) {
     classifyNode(n, operators, operands);
-    ts2.forEachChild(n, visit);
+    ts3.forEachChild(n, visit);
   }
-  ts2.forEachChild(node, visit);
+  ts3.forEachChild(node, visit);
   return computeHalsteadMetrics(operators, operands);
 }
 
@@ -358,53 +448,18 @@ function countSloc(content) {
 }
 
 // src/commands/complexity/shared.ts
-function getNodeName(node) {
-  if (ts3.isFunctionDeclaration(node) || ts3.isFunctionExpression(node)) {
-    return node.name?.text ?? "<anonymous>";
-  }
-  if (ts3.isMethodDeclaration(node) || ts3.isMethodSignature(node)) {
-    if (ts3.isIdentifier(node.name)) {
-      return node.name.text;
-    }
-    if (ts3.isStringLiteral(node.name)) {
-      return node.name.text;
-    }
-    return "<computed>";
-  }
-  if (ts3.isArrowFunction(node)) {
-    const parent = node.parent;
-    if (ts3.isVariableDeclaration(parent) && ts3.isIdentifier(parent.name)) {
-      return parent.name.text;
-    }
-    if (ts3.isPropertyAssignment(parent) && ts3.isIdentifier(parent.name)) {
-      return parent.name.text;
-    }
-    return "<arrow>";
-  }
-  if (ts3.isGetAccessor(node) || ts3.isSetAccessor(node)) {
-    const prefix = ts3.isGetAccessor(node) ? "get " : "set ";
-    if (ts3.isIdentifier(node.name)) {
-      return `${prefix}${node.name.text}`;
-    }
-    return `${prefix}<computed>`;
-  }
-  if (ts3.isConstructorDeclaration(node)) {
-    return "constructor";
-  }
-  return "<unknown>";
-}
 function createSourceFromFile(filePath) {
-  const content = fs.readFileSync(filePath, "utf-8");
-  return ts3.createSourceFile(
-    path.basename(filePath),
+  const content = fs2.readFileSync(filePath, "utf-8");
+  return ts4.createSourceFile(
+    path2.basename(filePath),
     content,
-    ts3.ScriptTarget.Latest,
+    ts4.ScriptTarget.Latest,
     true,
-    filePath.endsWith(".tsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
+    filePath.endsWith(".tsx") ? ts4.ScriptKind.TSX : ts4.ScriptKind.TS
   );
 }
 function withSourceFiles(pattern2, callback) {
-  const files = findSourceFilesWithPattern(pattern2);
+  const files = findSourceFiles(pattern2);
   if (files.length === 0) {
     console.log(chalk2.yellow("No files found matching pattern"));
     return void 0;
@@ -418,56 +473,11 @@ function forEachFunction(files, callback) {
       if (hasFunctionBody(node)) {
         callback(file, getNodeName(node), node);
       }
-      ts3.forEachChild(node, visit);
+      ts4.forEachChild(node, visit);
     };
     visit(sourceFile);
   }
 }
-function applyIgnoreGlobs(files) {
-  const { complexity } = loadConfig();
-  return files.filter(
-    (f) => !complexity.ignore.some((glob) => minimatch(f, glob))
-  );
-}
-function findSourceFilesWithPattern(pattern2, baseDir = ".") {
-  const results = [];
-  const extensions = [".ts", ".tsx"];
-  function walk(dir) {
-    if (!fs.existsSync(dir)) {
-      return;
-    }
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name !== "node_modules" && entry.name !== ".git") {
-          walk(fullPath);
-        }
-      } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
-        results.push(fullPath);
-      }
-    }
-  }
-  if (pattern2.includes("*")) {
-    walk(baseDir);
-    return applyIgnoreGlobs(results.filter((f) => minimatch(f, pattern2)));
-  }
-  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isFile()) {
-    return [pattern2];
-  }
-  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isDirectory()) {
-    walk(pattern2);
-    return applyIgnoreGlobs(results);
-  }
-  walk(baseDir);
-  return applyIgnoreGlobs(results.filter((f) => minimatch(f, pattern2)));
-}
-function hasFunctionBody(node) {
-  if (ts3.isFunctionDeclaration(node) || ts3.isFunctionExpression(node) || ts3.isArrowFunction(node) || ts3.isMethodDeclaration(node) || ts3.isGetAccessor(node) || ts3.isSetAccessor(node) || ts3.isConstructorDeclaration(node)) {
-    return node.body !== void 0;
-  }
-  return false;
-}
 
 // src/commands/complexity/cyclomatic.ts
 async function cyclomatic(pattern2 = "**/*.ts", options = {}) {
@@ -533,7 +543,7 @@ Analyzed ${results.length} functions across ${files.length} files`
 }
 
 // src/commands/complexity/maintainability.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import chalk5 from "chalk";
 function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, sloc2) {
   if (halsteadVolume === 0 || sloc2 === 0) {
@@ -542,69 +552,79 @@ function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, slo
   const mi = 171 - 5.2 * Math.log(halsteadVolume) - 0.23 * cyclomaticComplexity - 16.2 * Math.log(sloc2);
   return Math.max(0, Math.min(100, mi));
 }
-async function maintainability(pattern2 = "**/*.ts", options = {}) {
-  withSourceFiles(pattern2, (files) => {
-    const fileMetrics = /* @__PURE__ */ new Map();
-    for (const file of files) {
-      const content = fs2.readFileSync(file, "utf-8");
-      fileMetrics.set(file, { sloc: countSloc(content), functions: [] });
-    }
-    forEachFunction(files, (file, _name, node) => {
-      const metrics = fileMetrics.get(file);
-      if (metrics) {
-        const complexity = calculateCyclomaticComplexity(node);
-        const halstead2 = calculateHalstead(node);
-        const mi = calculateMaintainabilityIndex(
-          halstead2.volume,
-          complexity,
-          metrics.sloc
-        );
-        metrics.functions.push(mi);
-      }
-    });
-    const results = [];
-    const { threshold } = options;
-    for (const [file, metrics] of fileMetrics) {
-      if (metrics.functions.length === 0) continue;
-      const avgMaintainability = metrics.functions.reduce((a, b) => a + b, 0) / metrics.functions.length;
-      const minMaintainability = Math.min(...metrics.functions);
-      results.push({ file, avgMaintainability, minMaintainability });
-    }
-    results.sort((a, b) => a.minMaintainability - b.minMaintainability);
-    const filtered = threshold !== void 0 ? results.filter((r) => r.minMaintainability < threshold) : results;
-    if (threshold !== void 0 && filtered.length === 0) {
-      console.log(chalk5.green("All files pass maintainability threshold"));
-    } else {
-      for (const { file, avgMaintainability, minMaintainability } of filtered) {
-        const color = threshold !== void 0 ? chalk5.red : chalk5.white;
-        console.log(
-          `${color(file)} \u2192 avg: ${chalk5.cyan(avgMaintainability.toFixed(1))}, min: ${chalk5.yellow(minMaintainability.toFixed(1))}`
-        );
-      }
+function collectFileMetrics(files) {
+  const fileMetrics = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const content = fs3.readFileSync(file, "utf-8");
+    fileMetrics.set(file, { sloc: countSloc(content), functions: [] });
+  }
+  forEachFunction(files, (file, _name, node) => {
+    const metrics = fileMetrics.get(file);
+    if (metrics) {
+      const complexity = calculateCyclomaticComplexity(node);
+      const halstead2 = calculateHalstead(node);
+      const mi = calculateMaintainabilityIndex(
+        halstead2.volume,
+        complexity,
+        metrics.sloc
+      );
+      metrics.functions.push(mi);
     }
-    console.log(chalk5.dim(`
-Analyzed ${results.length} files`));
-    if (filtered.length > 0 && threshold !== void 0) {
+  });
+  return fileMetrics;
+}
+function aggregateResults(fileMetrics) {
+  const results = [];
+  for (const [file, metrics] of fileMetrics) {
+    if (metrics.functions.length === 0) continue;
+    const avgMaintainability = metrics.functions.reduce((a, b) => a + b, 0) / metrics.functions.length;
+    const minMaintainability = Math.min(...metrics.functions);
+    results.push({ file, avgMaintainability, minMaintainability });
+  }
+  results.sort((a, b) => a.minMaintainability - b.minMaintainability);
+  return results;
+}
+function displayResults(results, threshold) {
+  const filtered = threshold !== void 0 ? results.filter((r) => r.minMaintainability < threshold) : results;
+  if (threshold !== void 0 && filtered.length === 0) {
+    console.log(chalk5.green("All files pass maintainability threshold"));
+  } else {
+    for (const { file, avgMaintainability, minMaintainability } of filtered) {
+      const color = threshold !== void 0 ? chalk5.red : chalk5.white;
       console.log(
-        chalk5.red(
-          `
-Fail: ${filtered.length} file(s) below threshold ${threshold}. Maintainability index (0\u2013100) is derived from Halstead volume, cyclomatic complexity, and lines of code.`
-        )
+        `${color(file)} \u2192 avg: ${chalk5.cyan(avgMaintainability.toFixed(1))}, min: ${chalk5.yellow(minMaintainability.toFixed(1))}`
       );
-      process.exit(1);
     }
+  }
+  console.log(chalk5.dim(`
+Analyzed ${results.length} files`));
+  if (filtered.length > 0 && threshold !== void 0) {
+    console.error(
+      chalk5.red(
+        `
+Fail: ${filtered.length} file(s) below threshold ${threshold}. Maintainability index (0\u2013100) is derived from Halstead volume, cyclomatic complexity, and lines of code. Try 'complexity cyclomatic', 'complexity halstead', or 'complexity sloc' to help identify which metric is contributing most. For larger files, start by extracting responsibilities into smaller files.`
+      )
+    );
+    process.exit(1);
+  }
+}
+async function maintainability(pattern2 = "**/*.ts", options = {}) {
+  withSourceFiles(pattern2, (files) => {
+    const fileMetrics = collectFileMetrics(files);
+    const results = aggregateResults(fileMetrics);
+    displayResults(results, options.threshold);
   });
 }
 
 // src/commands/complexity/sloc.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import chalk6 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
     let hasViolation = false;
     for (const file of files) {
-      const content = fs3.readFileSync(file, "utf-8");
+      const content = fs4.readFileSync(file, "utf-8");
       const lines = countSloc(content);
       results.push({ file, lines });
       if (options.threshold !== void 0 && lines > options.threshold) {
@@ -631,8 +651,8 @@ Total: ${total} lines across ${files.length} files`)
 // src/commands/config/index.ts
 import chalk7 from "chalk";
 import { stringify as stringifyYaml2 } from "yaml";
-function getNestedValue(obj, path19) {
-  const keys = path19.split(".");
+function getNestedValue(obj, path28) {
+  const keys = path28.split(".");
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -642,8 +662,8 @@ function getNestedValue(obj, path19) {
   }
   return current;
 }
-function setNestedValue(obj, path19, value) {
-  const keys = path19.split(".");
+function setNestedValue(obj, path28, value) {
+  const keys = path28.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -670,8 +690,8 @@ function configSet(key, value) {
   const result = assistConfigSchema.safeParse(updated);
   if (!result.success) {
     for (const issue of result.error.issues) {
-      const path19 = issue.path.length > 0 ? issue.path.join(".") : key;
-      console.error(chalk7.red(`${path19}: ${issue.message}`));
+      const path28 = issue.path.length > 0 ? issue.path.join(".") : key;
+      console.error(chalk7.red(`${path28}: ${issue.message}`));
     }
     process.exit(1);
   }
@@ -698,10 +718,7 @@ function configList() {
 
 // src/commands/deploy/init.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname, join as join2 } from "path";
-import { fileURLToPath } from "url";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import enquirer2 from "enquirer";
 
 // src/shared/promptConfirm.ts
@@ -721,6 +738,12 @@ async function promptConfirm(message, initial = true) {
   return confirmed;
 }
 
+// src/commands/deploy/updateWorkflow.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import chalk9 from "chalk";
+
 // src/utils/printDiff.ts
 import chalk8 from "chalk";
 import * as diff from "diff";
@@ -750,7 +773,7 @@ function printDiff(oldContent, newContent) {
   }
 }
 
-// src/commands/deploy/init.ts
+// src/commands/deploy/updateWorkflow.ts
 var WORKFLOW_PATH = ".github/workflows/build.yml";
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
 function getExistingSiteId() {
@@ -791,11 +814,13 @@ async function updateWorkflow(siteId) {
   console.log(chalk9.green(`
 Created ${WORKFLOW_PATH}`));
 }
+
+// src/commands/deploy/init.ts
 async function init() {
-  console.log(chalk9.bold("Initializing Netlify deployment...\n"));
+  console.log(chalk10.bold("Initializing Netlify deployment...\n"));
   const existingSiteId = getExistingSiteId();
   if (existingSiteId) {
-    console.log(chalk9.dim(`Using existing site ID: ${existingSiteId}
+    console.log(chalk10.dim(`Using existing site ID: ${existingSiteId}
 `));
     await updateWorkflow(existingSiteId);
     return;
@@ -807,10 +832,10 @@ async function init() {
     });
   } catch (error) {
     if (error instanceof Error && error.message.includes("command not found")) {
-      console.error(chalk9.red("\nNetlify CLI is not installed.\n"));
+      console.error(chalk10.red("\nNetlify CLI is not installed.\n"));
       const install = await promptConfirm("Would you like to install it now?");
       if (install) {
-        console.log(chalk9.dim("\nInstalling netlify-cli...\n"));
+        console.log(chalk10.dim("\nInstalling netlify-cli...\n"));
         execSync2("npm install -g netlify-cli", { stdio: "inherit" });
         console.log();
         execSync2("netlify sites:create --disable-linking", {
@@ -818,7 +843,7 @@ async function init() {
         });
       } else {
         console.log(
-          chalk9.yellow(
+          chalk10.yellow(
             "\nInstall it manually with: npm install -g netlify-cli\n"
           )
         );
@@ -835,17 +860,17 @@ async function init() {
     validate: (value) => /^[a-f0-9-]+$/i.test(value) || "Invalid site ID format"
   });
   await updateWorkflow(siteId);
-  console.log(chalk9.bold("\nDeployment initialized successfully!"));
+  console.log(chalk10.bold("\nDeployment initialized successfully!"));
   console.log(
-    chalk9.yellow("\nTo complete setup, create a personal access token at:")
+    chalk10.yellow("\nTo complete setup, create a personal access token at:")
   );
   console.log(
-    chalk9.cyan(
+    chalk10.cyan(
       "https://app.netlify.com/user/applications#personal-access-tokens"
     )
   );
   console.log(
-    chalk9.yellow(
+    chalk10.yellow(
       "\nThen add it as NETLIFY_AUTH_TOKEN in your GitHub repository secrets."
     )
   );
@@ -853,7 +878,7 @@ async function init() {
 
 // src/commands/deploy/redirect.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
         window.location.href = \`\${window.location.pathname}/\${window.location.search}\${window.location.hash}\`;
@@ -862,32 +887,32 @@ var TRAILING_SLASH_SCRIPT = `    <script>
 function redirect() {
   const indexPath = "index.html";
   if (!existsSync3(indexPath)) {
-    console.log(chalk10.yellow("No index.html found"));
+    console.log(chalk11.yellow("No index.html found"));
     return;
   }
   const content = readFileSync3(indexPath, "utf-8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
-    console.log(chalk10.dim("Trailing slash script already present"));
+    console.log(chalk11.dim("Trailing slash script already present"));
     return;
   }
   const headCloseIndex = content.indexOf("</head>");
   if (headCloseIndex === -1) {
-    console.log(chalk10.red("Could not find </head> tag in index.html"));
+    console.log(chalk11.red("Could not find </head> tag in index.html"));
     return;
   }
   const newContent = content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT + "\n  " + content.slice(headCloseIndex);
   writeFileSync3(indexPath, newContent);
-  console.log(chalk10.green("Added trailing slash redirect to index.html"));
+  console.log(chalk11.green("Added trailing slash redirect to index.html"));
 }
 
 // src/commands/devlog/list.ts
 import { execSync as execSync4 } from "child_process";
 import { basename as basename2 } from "path";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 
 // src/commands/devlog/shared.ts
 import { execSync as execSync3 } from "child_process";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 
 // src/commands/devlog/loadDevlogEntries.ts
 import { readdirSync, readFileSync as readFileSync4 } from "fs";
@@ -948,17 +973,35 @@ function shouldIgnoreCommit(files, ignorePaths) {
 }
 function printCommitsWithFiles(commits, ignore2, verbose) {
   for (const commit2 of commits) {
-    console.log(`  ${chalk11.yellow(commit2.hash)} ${commit2.message}`);
+    console.log(`  ${chalk12.yellow(commit2.hash)} ${commit2.message}`);
     if (verbose) {
       const visibleFiles = commit2.files.filter(
         (file) => !ignore2.some((p) => file.startsWith(p))
       );
       for (const file of visibleFiles) {
-        console.log(`    ${chalk11.dim(file)}`);
+        console.log(`    ${chalk12.dim(file)}`);
       }
     }
   }
 }
+function parseGitLogCommits(output, ignore2, afterDate) {
+  const lines = output.trim().split("\n");
+  const commitsByDate = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const [date, hash, ...messageParts] = line.split("|");
+    const message = messageParts.join("|");
+    if (afterDate && date <= afterDate) {
+      continue;
+    }
+    const files = getCommitFiles(hash);
+    if (!shouldIgnoreCommit(files, ignore2)) {
+      const existing = commitsByDate.get(date) || [];
+      existing.push({ date, hash, message, files });
+      commitsByDate.set(date, existing);
+    }
+  }
+  return commitsByDate;
+}
 
 // src/commands/devlog/list.ts
 function list(options) {
@@ -974,22 +1017,7 @@ function list(options) {
     `git log ${reverseFlag}${limitFlag}--pretty=format:'%ad|%h|%s' --date=short`,
     { encoding: "utf-8" }
   );
-  const lines = output.trim().split("\n");
-  const commits = [];
-  for (const line of lines) {
-    const [date, hash, ...messageParts] = line.split("|");
-    const message = messageParts.join("|");
-    const files = getCommitFiles(hash);
-    if (!shouldIgnoreCommit(files, ignore2)) {
-      commits.push({ date, hash, message, files });
-    }
-  }
-  const commitsByDate = /* @__PURE__ */ new Map();
-  for (const commit2 of commits) {
-    const existing = commitsByDate.get(commit2.date) || [];
-    existing.push(commit2);
-    commitsByDate.set(commit2.date, existing);
-  }
+  const commitsByDate = parseGitLogCommits(output, ignore2);
   let dateCount = 0;
   let isFirst = true;
   for (const [date, dateCommits] of commitsByDate) {
@@ -1007,12 +1035,12 @@ function list(options) {
     isFirst = false;
     const entries = devlogEntries.get(date);
     if (skipDays.has(date)) {
-      console.log(`${chalk12.bold.blue(date)} ${chalk12.dim("skipped")}`);
+      console.log(`${chalk13.bold.blue(date)} ${chalk13.dim("skipped")}`);
     } else if (entries && entries.length > 0) {
-      const entryInfo = entries.map((e) => `${chalk12.green(e.version)} ${e.title}`).join(" | ");
-      console.log(`${chalk12.bold.blue(date)} ${entryInfo}`);
+      const entryInfo = entries.map((e) => `${chalk13.green(e.version)} ${e.title}`).join(" | ");
+      console.log(`${chalk13.bold.blue(date)} ${entryInfo}`);
     } else {
-      console.log(`${chalk12.bold.blue(date)} ${chalk12.red("\u26A0 devlog missing")}`);
+      console.log(`${chalk13.bold.blue(date)} ${chalk13.red("\u26A0 devlog missing")}`);
     }
     printCommitsWithFiles(dateCommits, ignore2, options.verbose ?? false);
   }
@@ -1020,7 +1048,7 @@ function list(options) {
 
 // src/commands/devlog/next.ts
 import { execSync as execSync6 } from "child_process";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 
 // src/commands/devlog/getLastVersionInfo.ts
 import { execSync as execSync5 } from "child_process";
@@ -1097,6 +1125,22 @@ function bumpVersion(version2, type) {
 }
 
 // src/commands/devlog/next.ts
+function displayVersion(conventional, firstHash, patchVersion, minorVersion) {
+  if (conventional && firstHash) {
+    const version2 = getVersionAtCommit(firstHash);
+    if (version2) {
+      console.log(`${chalk14.bold("version:")} ${stripToMinor(version2)}`);
+    } else {
+      console.log(`${chalk14.bold("version:")} ${chalk14.red("unknown")}`);
+    }
+  } else if (patchVersion && minorVersion) {
+    console.log(
+      `${chalk14.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
+    );
+  } else {
+    console.log(`${chalk14.bold("version:")} v0.1 (initial)`);
+  }
+}
 function next(options) {
   const config = loadConfig();
   const ignore2 = options.ignore ?? config.devlog?.ignore ?? [];
@@ -1110,62 +1154,40 @@ function next(options) {
     "git log --pretty=format:'%ad|%h|%s' --date=short -n 500",
     { encoding: "utf-8" }
   );
-  const lines = output.trim().split("\n");
-  const commitsByDate = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    const [date, hash, ...messageParts] = line.split("|");
-    const message = messageParts.join("|");
-    if (lastDate && date <= lastDate) {
-      continue;
-    }
-    const files = getCommitFiles(hash);
-    if (!shouldIgnoreCommit(files, ignore2)) {
-      const existing = commitsByDate.get(date) || [];
-      existing.push({ date, hash, message, files });
-      commitsByDate.set(date, existing);
-    }
-  }
+  const commitsByDate = parseGitLogCommits(output, ignore2, lastDate);
   const dates = Array.from(commitsByDate.keys()).filter((d) => !skipDays.has(d)).sort();
   const targetDate = dates[0];
   if (!targetDate) {
     if (lastInfo) {
-      console.log(chalk13.dim("No commits after last versioned entry"));
+      console.log(chalk14.dim("No commits after last versioned entry"));
     } else {
-      console.log(chalk13.dim("No commits found"));
+      console.log(chalk14.dim("No commits found"));
     }
     return;
   }
   const commits = commitsByDate.get(targetDate) ?? [];
-  console.log(`${chalk13.bold("name:")} ${repoName}`);
-  if (config.commit?.conventional && commits.length > 0) {
-    const version2 = getVersionAtCommit(commits[0].hash);
-    if (version2) {
-      console.log(`${chalk13.bold("version:")} ${stripToMinor(version2)}`);
-    } else {
-      console.log(`${chalk13.bold("version:")} ${chalk13.red("unknown")}`);
-    }
-  } else if (patchVersion && minorVersion) {
-    console.log(
-      `${chalk13.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
-    );
-  } else {
-    console.log(`${chalk13.bold("version:")} v0.1 (initial)`);
-  }
-  console.log(`${chalk13.bold.blue(targetDate)}`);
+  console.log(`${chalk14.bold("name:")} ${repoName}`);
+  displayVersion(
+    !!config.commit?.conventional,
+    commits[0]?.hash,
+    patchVersion,
+    minorVersion
+  );
+  console.log(`${chalk14.bold.blue(targetDate)}`);
   printCommitsWithFiles(commits, ignore2, options.verbose ?? false);
 }
 
 // src/commands/devlog/skip.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
-    console.log(chalk14.red("Invalid date format. Use YYYY-MM-DD"));
+    console.log(chalk15.red("Invalid date format. Use YYYY-MM-DD"));
     process.exit(1);
   }
   const config = loadConfig();
   const skipDays = config.devlog?.skip?.days ?? [];
   if (skipDays.includes(date)) {
-    console.log(chalk14.yellow(`${date} is already in skip list`));
+    console.log(chalk15.yellow(`${date} is already in skip list`));
     return;
   }
   skipDays.push(date);
@@ -1178,27 +1200,27 @@ function skip(date) {
     }
   };
   saveConfig(config);
-  console.log(chalk14.green(`Added ${date} to skip list`));
+  console.log(chalk15.green(`Added ${date} to skip list`));
 }
 
 // src/commands/devlog/version.ts
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 function version() {
   const config = loadConfig();
   const name = getRepoName();
   const lastInfo = getLastVersionInfo(name, config);
   const lastVersion = lastInfo?.version ?? null;
   const nextVersion = lastVersion ? bumpVersion(lastVersion, "patch") : null;
-  console.log(`${chalk15.bold("name:")} ${name}`);
-  console.log(`${chalk15.bold("last:")} ${lastVersion ?? chalk15.dim("none")}`);
-  console.log(`${chalk15.bold("next:")} ${nextVersion ?? chalk15.dim("none")}`);
+  console.log(`${chalk16.bold("name:")} ${name}`);
+  console.log(`${chalk16.bold("last:")} ${lastVersion ?? chalk16.dim("none")}`);
+  console.log(`${chalk16.bold("next:")} ${nextVersion ?? chalk16.dim("none")}`);
 }
 
 // src/commands/verify/init.ts
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 
 // src/shared/promptMultiselect.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 import enquirer3 from "enquirer";
 async function promptMultiselect(message, options) {
   const { selected } = await enquirer3.prompt({
@@ -1207,7 +1229,7 @@ async function promptMultiselect(message, options) {
     message,
     choices: options.map((opt) => ({
       name: opt.value,
-      message: `${opt.name} - ${chalk16.dim(opt.description)}`
+      message: `${opt.name} - ${chalk17.dim(opt.description)}`
     })),
     // @ts-expect-error - enquirer types don't include symbols but it's supported
     symbols: {
@@ -1221,23 +1243,23 @@ async function promptMultiselect(message, options) {
 }
 
 // src/shared/readPackageJson.ts
-import * as fs4 from "fs";
-import * as path2 from "path";
-import chalk17 from "chalk";
-function findPackageJson() {
-  const packageJsonPath = path2.join(process.cwd(), "package.json");
-  if (fs4.existsSync(packageJsonPath)) {
-    return packageJsonPath;
+import * as fs5 from "fs";
+import * as path3 from "path";
+import chalk18 from "chalk";
+function findPackageJson() {
+  const packageJsonPath = path3.join(process.cwd(), "package.json");
+  if (fs5.existsSync(packageJsonPath)) {
+    return packageJsonPath;
   }
   return null;
 }
 function readPackageJson(filePath) {
-  return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
 }
 function requirePackageJson() {
   const packageJsonPath = findPackageJson();
   if (!packageJsonPath) {
-    console.error(chalk17.red("No package.json found in current directory"));
+    console.error(chalk18.red("No package.json found in current directory"));
     process.exit(1);
   }
   const pkg = readPackageJson(packageJsonPath);
@@ -1246,9 +1268,9 @@ function requirePackageJson() {
 function findPackageJsonWithVerifyScripts(startDir) {
   let currentDir = startDir;
   while (true) {
-    const packageJsonPath = path2.join(currentDir, "package.json");
-    if (fs4.existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = path3.join(currentDir, "package.json");
+    if (fs5.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
       const scripts = packageJson.scripts || {};
       const verifyScripts = Object.keys(scripts).filter(
         (name) => name.startsWith("verify:")
@@ -1257,7 +1279,7 @@ function findPackageJsonWithVerifyScripts(startDir) {
         return { packageJsonPath, verifyScripts };
       }
     }
-    const parentDir = path2.dirname(currentDir);
+    const parentDir = path3.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -1275,15 +1297,15 @@ var expectedScripts = {
 };
 
 // src/commands/verify/setup/setupBuild.ts
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 
 // src/commands/verify/installPackage.ts
 import { execSync as execSync7 } from "child_process";
-import * as fs5 from "fs";
-import * as path3 from "path";
-import chalk18 from "chalk";
+import * as fs6 from "fs";
+import * as path4 from "path";
+import chalk19 from "chalk";
 function writePackageJson(filePath, pkg) {
-  fs5.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
+  fs6.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
 `);
 }
 function addScript(pkg, name, command) {
@@ -1296,36 +1318,36 @@ function addScript(pkg, name, command) {
   };
 }
 function installPackage(name, cwd) {
-  console.log(chalk18.dim(`Installing ${name}...`));
+  console.log(chalk19.dim(`Installing ${name}...`));
   try {
     execSync7(`npm install -D ${name}`, { stdio: "inherit", cwd });
     return true;
   } catch {
-    console.error(chalk18.red(`Failed to install ${name}`));
+    console.error(chalk19.red(`Failed to install ${name}`));
     return false;
   }
 }
 function addToKnipIgnoreBinaries(cwd, binary) {
-  const knipJsonPath = path3.join(cwd, "knip.json");
+  const knipJsonPath = path4.join(cwd, "knip.json");
   try {
     let knipConfig;
-    if (fs5.existsSync(knipJsonPath)) {
-      knipConfig = JSON.parse(fs5.readFileSync(knipJsonPath, "utf-8"));
+    if (fs6.existsSync(knipJsonPath)) {
+      knipConfig = JSON.parse(fs6.readFileSync(knipJsonPath, "utf-8"));
     } else {
       knipConfig = { $schema: "https://unpkg.com/knip@5/schema.json" };
     }
     const ignoreBinaries = knipConfig.ignoreBinaries ?? [];
     if (!ignoreBinaries.includes(binary)) {
       knipConfig.ignoreBinaries = [...ignoreBinaries, binary];
-      fs5.writeFileSync(
+      fs6.writeFileSync(
         knipJsonPath,
         `${JSON.stringify(knipConfig, null, "	")}
 `
       );
-      console.log(chalk18.dim(`Added '${binary}' to knip.json ignoreBinaries`));
+      console.log(chalk19.dim(`Added '${binary}' to knip.json ignoreBinaries`));
     }
   } catch {
-    console.log(chalk18.yellow("Warning: Could not update knip.json"));
+    console.log(chalk19.yellow("Warning: Could not update knip.json"));
   }
 }
 function setupVerifyScript(packageJsonPath, scriptName, command) {
@@ -1337,7 +1359,7 @@ function setupVerifyScript(packageJsonPath, scriptName, command) {
 
 // src/commands/verify/setup/setupBuild.ts
 async function setupBuild(packageJsonPath, hasVite, hasTypescript) {
-  console.log(chalk19.blue("\nSetting up build verification..."));
+  console.log(chalk20.blue("\nSetting up build verification..."));
   let command;
   if (hasVite && hasTypescript) {
     command = "tsc -b && vite build --logLevel error";
@@ -1346,17 +1368,17 @@ async function setupBuild(packageJsonPath, hasVite, hasTypescript) {
   } else {
     command = "tsc --noEmit";
   }
-  console.log(chalk19.dim(`Using: ${command}`));
+  console.log(chalk20.dim(`Using: ${command}`));
   const pkg = readPackageJson(packageJsonPath);
   writePackageJson(packageJsonPath, addScript(pkg, "verify:build", command));
 }
 
 // src/commands/verify/setup/setupDuplicateCode.ts
-import * as path4 from "path";
-import chalk20 from "chalk";
+import * as path5 from "path";
+import chalk21 from "chalk";
 async function setupDuplicateCode(packageJsonPath) {
-  console.log(chalk20.blue("\nSetting up jscpd..."));
-  const cwd = path4.dirname(packageJsonPath);
+  console.log(chalk21.blue("\nSetting up jscpd..."));
+  const cwd = path5.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   const hasJscpd = !!pkg.dependencies?.jscpd || !!pkg.devDependencies?.jscpd;
   if (!hasJscpd && !installPackage("jscpd", cwd)) {
@@ -1370,11 +1392,11 @@ async function setupDuplicateCode(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupHardcodedColors.ts
-import * as path5 from "path";
-import chalk21 from "chalk";
+import * as path6 from "path";
+import chalk22 from "chalk";
 async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
-  console.log(chalk21.blue("\nSetting up hardcoded colors check..."));
-  const cwd = path5.dirname(packageJsonPath);
+  console.log(chalk22.blue("\nSetting up hardcoded colors check..."));
+  const cwd = path6.dirname(packageJsonPath);
   if (!hasOpenColor) {
     installPackage("open-color", cwd);
   }
@@ -1387,11 +1409,11 @@ async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
 }
 
 // src/commands/verify/setup/setupKnip.ts
-import * as path6 from "path";
-import chalk22 from "chalk";
+import * as path7 from "path";
+import chalk23 from "chalk";
 async function setupKnip(packageJsonPath) {
-  console.log(chalk22.blue("\nSetting up knip..."));
-  const cwd = path6.dirname(packageJsonPath);
+  console.log(chalk23.blue("\nSetting up knip..."));
+  const cwd = path7.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.knip && !installPackage("knip", cwd)) {
     return;
@@ -1404,15 +1426,15 @@ async function setupKnip(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupLint.ts
-import * as path7 from "path";
-import chalk24 from "chalk";
+import * as path8 from "path";
+import chalk25 from "chalk";
 
 // src/commands/lint/init.ts
 import { execSync as execSync9 } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname6, join as join6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 
 // src/shared/removeEslint.ts
 import { execSync as execSync8 } from "child_process";
@@ -1518,10 +1540,10 @@ async function init2() {
     console.log("biome.json already has the correct linter config");
     return;
   }
-  console.log(chalk23.yellow("\n\u26A0\uFE0F  biome.json will be updated:"));
+  console.log(chalk24.yellow("\n\u26A0\uFE0F  biome.json will be updated:"));
   console.log();
   printDiff(oldContent, newContent);
-  const confirm = await promptConfirm(chalk23.red("Update biome.json?"));
+  const confirm = await promptConfirm(chalk24.red("Update biome.json?"));
   if (!confirm) {
     console.log("Skipped biome.json update");
     return;
@@ -1532,8 +1554,8 @@ async function init2() {
 
 // src/commands/verify/setup/setupLint.ts
 async function setupLint(packageJsonPath) {
-  console.log(chalk24.blue("\nSetting up biome..."));
-  const cwd = path7.dirname(packageJsonPath);
+  console.log(chalk25.blue("\nSetting up biome..."));
+  const cwd = path8.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.["@biomejs/biome"]) {
     if (!installPackage("@biomejs/biome", cwd)) {
@@ -1549,11 +1571,11 @@ async function setupLint(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupTest.ts
-import * as path8 from "path";
-import chalk25 from "chalk";
+import * as path9 from "path";
+import chalk26 from "chalk";
 async function setupTest(packageJsonPath) {
-  console.log(chalk25.blue("\nSetting up vitest..."));
-  const cwd = path8.dirname(packageJsonPath);
+  console.log(chalk26.blue("\nSetting up vitest..."));
+  const cwd = path9.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.vitest && !installPackage("vitest", cwd)) {
     return;
@@ -1695,16 +1717,16 @@ async function init3() {
   const setup = detectExistingSetup(pkg);
   const availableOptions = getAvailableOptions(setup);
   if (availableOptions.length === 0) {
-    console.log(chalk26.green("All verify scripts are already configured!"));
+    console.log(chalk27.green("All verify scripts are already configured!"));
     return;
   }
-  console.log(chalk26.bold("Available verify scripts to add:\n"));
+  console.log(chalk27.bold("Available verify scripts to add:\n"));
   const selected = await promptMultiselect(
     "Select verify scripts to add:",
     availableOptions
   );
   if (selected.length === 0) {
-    console.log(chalk26.yellow("No scripts selected"));
+    console.log(chalk27.yellow("No scripts selected"));
     return;
   }
   for (const choice of selected) {
@@ -1729,43 +1751,43 @@ async function init3() {
         break;
     }
   }
-  console.log(chalk26.green(`
+  console.log(chalk27.green(`
 Added ${selected.length} verify script(s):`));
   for (const choice of selected) {
-    console.log(chalk26.green(`  - verify:${choice}`));
+    console.log(chalk27.green(`  - verify:${choice}`));
   }
-  console.log(chalk26.dim("\nRun 'assist verify' to run all verify scripts"));
+  console.log(chalk27.dim("\nRun 'assist verify' to run all verify scripts"));
 }
 
 // src/commands/vscode/init.ts
+import * as fs8 from "fs";
+import * as path11 from "path";
+import chalk29 from "chalk";
+
+// src/commands/vscode/createLaunchJson.ts
 import * as fs7 from "fs";
 import * as path10 from "path";
 import chalk28 from "chalk";
-
-// src/commands/vscode/createLaunchJson.ts
-import * as fs6 from "fs";
-import * as path9 from "path";
-import chalk27 from "chalk";
 function ensureVscodeFolder() {
-  const vscodeDir = path9.join(process.cwd(), ".vscode");
-  if (!fs6.existsSync(vscodeDir)) {
-    fs6.mkdirSync(vscodeDir);
-    console.log(chalk27.dim("Created .vscode folder"));
+  const vscodeDir = path10.join(process.cwd(), ".vscode");
+  if (!fs7.existsSync(vscodeDir)) {
+    fs7.mkdirSync(vscodeDir);
+    console.log(chalk28.dim("Created .vscode folder"));
   }
 }
 function removeVscodeFromGitignore() {
-  const gitignorePath = path9.join(process.cwd(), ".gitignore");
-  if (!fs6.existsSync(gitignorePath)) {
+  const gitignorePath = path10.join(process.cwd(), ".gitignore");
+  if (!fs7.existsSync(gitignorePath)) {
     return;
   }
-  const content = fs6.readFileSync(gitignorePath, "utf-8");
+  const content = fs7.readFileSync(gitignorePath, "utf-8");
   const lines = content.split("\n");
   const filteredLines = lines.filter(
     (line) => !line.trim().toLowerCase().includes(".vscode")
   );
   if (filteredLines.length !== lines.length) {
-    fs6.writeFileSync(gitignorePath, filteredLines.join("\n"));
-    console.log(chalk27.dim("Removed .vscode references from .gitignore"));
+    fs7.writeFileSync(gitignorePath, filteredLines.join("\n"));
+    console.log(chalk28.dim("Removed .vscode references from .gitignore"));
   }
 }
 function createLaunchJson() {
@@ -1780,10 +1802,10 @@ function createLaunchJson() {
       }
     ]
   };
-  const launchPath = path9.join(process.cwd(), ".vscode", "launch.json");
-  fs6.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
+  const launchPath = path10.join(process.cwd(), ".vscode", "launch.json");
+  fs7.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
 `);
-  console.log(chalk27.green("Created .vscode/launch.json"));
+  console.log(chalk28.green("Created .vscode/launch.json"));
 }
 function createSettingsJson() {
   const settings = {
@@ -1793,31 +1815,31 @@ function createSettingsJson() {
       "source.organizeImports.biome": "explicit"
     }
   };
-  const settingsPath = path9.join(process.cwd(), ".vscode", "settings.json");
-  fs6.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
+  const settingsPath = path10.join(process.cwd(), ".vscode", "settings.json");
+  fs7.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
 `);
-  console.log(chalk27.green("Created .vscode/settings.json"));
+  console.log(chalk28.green("Created .vscode/settings.json"));
 }
 function createExtensionsJson() {
   const extensions = {
     recommendations: ["biomejs.biome"]
   };
-  const extensionsPath = path9.join(process.cwd(), ".vscode", "extensions.json");
-  fs6.writeFileSync(
+  const extensionsPath = path10.join(process.cwd(), ".vscode", "extensions.json");
+  fs7.writeFileSync(
     extensionsPath,
     `${JSON.stringify(extensions, null, "	")}
 `
   );
-  console.log(chalk27.green("Created .vscode/extensions.json"));
+  console.log(chalk28.green("Created .vscode/extensions.json"));
 }
 
 // src/commands/vscode/init.ts
 function detectExistingSetup2(pkg) {
-  const vscodeDir = path10.join(process.cwd(), ".vscode");
+  const vscodeDir = path11.join(process.cwd(), ".vscode");
   return {
-    hasVscodeFolder: fs7.existsSync(vscodeDir),
-    hasLaunchJson: fs7.existsSync(path10.join(vscodeDir, "launch.json")),
-    hasSettingsJson: fs7.existsSync(path10.join(vscodeDir, "settings.json")),
+    hasVscodeFolder: fs8.existsSync(vscodeDir),
+    hasLaunchJson: fs8.existsSync(path11.join(vscodeDir, "launch.json")),
+    hasSettingsJson: fs8.existsSync(path11.join(vscodeDir, "settings.json")),
     hasVite: !!pkg.devDependencies?.vite || !!pkg.dependencies?.vite
   };
 }
@@ -1840,16 +1862,16 @@ async function init4() {
     });
   }
   if (availableOptions.length === 0) {
-    console.log(chalk28.green("VS Code configuration already exists!"));
+    console.log(chalk29.green("VS Code configuration already exists!"));
     return;
   }
-  console.log(chalk28.bold("Available VS Code configurations to add:\n"));
+  console.log(chalk29.bold("Available VS Code configurations to add:\n"));
   const selected = await promptMultiselect(
     "Select configurations to add:",
     availableOptions
   );
   if (selected.length === 0) {
-    console.log(chalk28.yellow("No configurations selected"));
+    console.log(chalk29.yellow("No configurations selected"));
     return;
   }
   removeVscodeFromGitignore();
@@ -1866,7 +1888,7 @@ async function init4() {
     }
   }
   console.log(
-    chalk28.green(`
+    chalk29.green(`
 Added ${selected.length} VS Code configuration(s)`)
   );
 }
@@ -1878,25 +1900,25 @@ async function init5() {
 }
 
 // src/commands/lint/runFileNameCheck.ts
-import fs9 from "fs";
-import path12 from "path";
-import chalk29 from "chalk";
+import fs10 from "fs";
+import path13 from "path";
+import chalk30 from "chalk";
 
 // src/shared/findSourceFiles.ts
-import fs8 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path12 from "path";
 var EXTENSIONS = [".ts", ".tsx"];
-function findSourceFiles(dir, options = {}) {
+function findSourceFiles2(dir, options = {}) {
   const { includeTests = true } = options;
   const results = [];
-  if (!fs8.existsSync(dir)) {
+  if (!fs9.existsSync(dir)) {
     return results;
   }
-  const entries = fs8.readdirSync(dir, { withFileTypes: true });
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path11.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "node_modules") {
-      results.push(...findSourceFiles(fullPath, options));
+      results.push(...findSourceFiles2(fullPath, options));
     } else if (entry.isFile() && EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
       if (!includeTests && entry.name.includes(".test.")) {
         continue;
@@ -1915,13 +1937,13 @@ function hasClassOrComponent(content) {
   return classPattern.test(content) || functionComponentPattern.test(content) || arrowComponentPattern.test(content);
 }
 function checkFileNames() {
-  const sourceFiles = findSourceFiles("src");
+  const sourceFiles = findSourceFiles2("src");
   const violations = [];
   for (const filePath of sourceFiles) {
-    const fileName = path12.basename(filePath);
+    const fileName = path13.basename(filePath);
     const nameWithoutExt = fileName.replace(/\.(ts|tsx)$/, "");
     if (/^[A-Z]/.test(nameWithoutExt)) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs10.readFileSync(filePath, "utf-8");
       if (!hasClassOrComponent(content)) {
         violations.push({ filePath, fileName });
       }
@@ -1932,16 +1954,16 @@ function checkFileNames() {
 function runFileNameCheck() {
   const violations = checkFileNames();
   if (violations.length > 0) {
-    console.error(chalk29.red("\nFile name check failed:\n"));
+    console.error(chalk30.red("\nFile name check failed:\n"));
     console.error(
-      chalk29.red(
+      chalk30.red(
         "  Files without classes or React components should not start with a capital letter.\n"
       )
     );
     for (const violation of violations) {
-      console.error(chalk29.red(`  ${violation.filePath}`));
+      console.error(chalk30.red(`  ${violation.filePath}`));
       console.error(
-        chalk29.gray(
+        chalk30.gray(
           `    Rename to: ${violation.fileName.charAt(0).toLowerCase()}${violation.fileName.slice(1)}
 `
         )
@@ -1958,20 +1980,20 @@ function runFileNameCheck() {
 }
 
 // src/commands/lint/runImportExtensionCheck.ts
-import fs10 from "fs";
+import fs11 from "fs";
 
 // src/commands/lint/shared.ts
-import chalk30 from "chalk";
+import chalk31 from "chalk";
 function reportViolations(violations, checkName, errorMessage, successMessage) {
   if (violations.length > 0) {
-    console.error(chalk30.red(`
+    console.error(chalk31.red(`
 ${checkName} failed:
 `));
-    console.error(chalk30.red(`  ${errorMessage}
+    console.error(chalk31.red(`  ${errorMessage}
 `));
     for (const violation of violations) {
-      console.error(chalk30.red(`  ${violation.filePath}:${violation.line}`));
-      console.error(chalk30.gray(`    ${violation.content}
+      console.error(chalk31.red(`  ${violation.filePath}:${violation.line}`));
+      console.error(chalk31.gray(`    ${violation.content}
 `));
     }
     return false;
@@ -1984,7 +2006,7 @@ ${checkName} failed:
 
 // src/commands/lint/runImportExtensionCheck.ts
 function checkForImportExtensions(filePath) {
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const violations = [];
   const importExtensionPattern = /from\s+["']\..*\.(js|ts)["']/;
@@ -2001,7 +2023,7 @@ function checkForImportExtensions(filePath) {
   return violations;
 }
 function checkImportExtensions() {
-  const sourceFiles = findSourceFiles("src");
+  const sourceFiles = findSourceFiles2("src");
   const violations = [];
   for (const filePath of sourceFiles) {
     violations.push(...checkForImportExtensions(filePath));
@@ -2018,9 +2040,9 @@ function runImportExtensionCheck() {
 }
 
 // src/commands/lint/runStaticImportCheck.ts
-import fs11 from "fs";
+import fs12 from "fs";
 function checkForDynamicImports(filePath) {
-  const content = fs11.readFileSync(filePath, "utf-8");
+  const content = fs12.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const violations = [];
   const requirePattern = /\brequire\s*\(/;
@@ -2038,7 +2060,7 @@ function checkForDynamicImports(filePath) {
   return violations;
 }
 function checkStaticImports() {
-  const sourceFiles = findSourceFiles("src");
+  const sourceFiles = findSourceFiles2("src");
   const violations = [];
   for (const filePath of sourceFiles) {
     violations.push(...checkForDynamicImports(filePath));
@@ -2134,19 +2156,19 @@ function detectPlatform() {
 
 // src/commands/notify/showWindowsNotificationFromWsl.ts
 import { spawn } from "child_process";
-import fs12 from "fs";
+import fs13 from "fs";
 import { createRequire } from "module";
-import path13 from "path";
+import path14 from "path";
 var require2 = createRequire(import.meta.url);
 function getSnoreToastPath() {
-  const notifierPath = path13.dirname(require2.resolve("node-notifier"));
-  return path13.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
+  const notifierPath = path14.dirname(require2.resolve("node-notifier"));
+  return path14.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
 }
 function showWindowsNotificationFromWsl(options) {
   const { title, message, sound } = options;
   const snoreToastPath = getSnoreToastPath();
   try {
-    fs12.chmodSync(snoreToastPath, 493);
+    fs13.chmodSync(snoreToastPath, 493);
   } catch {
   }
   const args = ["-t", title, "-m", message];
@@ -2220,12 +2242,15 @@ async function notify() {
   console.log(`Notification sent: ${notification_type} for ${projectName}`);
 }
 
-// src/commands/prs/shared.ts
-import { execSync as execSync11 } from "child_process";
+// src/commands/prs/resolveCommentWithReply.ts
+import { execSync as execSync12 } from "child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync11, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "fs";
 import { tmpdir } from "os";
 import { join as join9 } from "path";
 import { parse } from "yaml";
+
+// src/commands/prs/shared.ts
+import { execSync as execSync11 } from "child_process";
 function isGhNotInstalled(error) {
   if (error instanceof Error) {
     const msg = error.message.toLowerCase();
@@ -2259,8 +2284,10 @@ function getCurrentPrNumber() {
     throw error;
   }
 }
+
+// src/commands/prs/resolveCommentWithReply.ts
 function replyToComment(org, repo, prNumber, commentId, message) {
-  execSync11(
+  execSync12(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message.replace(/"/g, '\\"')}" -F in_reply_to=${commentId}`,
     { stdio: "inherit" }
   );
@@ -2270,7 +2297,7 @@ function resolveThread(threadId) {
   const queryFile = join9(tmpdir(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync9(queryFile, mutation);
   try {
-    execSync11(
+    execSync12(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: "inherit" }
     );
@@ -2347,10 +2374,9 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments.ts
-import { execSync as execSync13 } from "child_process";
 import { existsSync as existsSync12, mkdirSync as mkdirSync3, writeFileSync as writeFileSync11 } from "fs";
 import { join as join11 } from "path";
-import chalk31 from "chalk";
+import chalk32 from "chalk";
 import { stringify } from "yaml";
 
 // src/lib/isClaudeCode.ts
@@ -2358,8 +2384,53 @@ function isClaudeCode() {
   return process.env.CLAUDECODE !== void 0;
 }
 
+// src/commands/prs/fetchReviewComments.ts
+import { execSync as execSync13 } from "child_process";
+function fetchReviewComments(org, repo, prNumber) {
+  const result = execSync13(
+    `gh api repos/${org}/${repo}/pulls/${prNumber}/reviews`,
+    { encoding: "utf-8" }
+  );
+  if (!result.trim()) return [];
+  const reviews = JSON.parse(result);
+  return reviews.filter((r) => r.body).map(
+    (r) => ({
+      type: "review",
+      id: r.id,
+      user: r.user.login,
+      state: r.state,
+      body: r.body
+    })
+  );
+}
+function fetchLineComments(org, repo, prNumber, threadInfo) {
+  const result = execSync13(
+    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments`,
+    { encoding: "utf-8" }
+  );
+  if (!result.trim()) return [];
+  const comments = JSON.parse(result);
+  return comments.map(
+    (c) => {
+      const threadId = threadInfo.threadMap.get(c.id) ?? "";
+      return {
+        type: "line",
+        id: c.id,
+        threadId,
+        user: c.user.login,
+        path: c.path,
+        line: c.line,
+        body: c.body,
+        diff_hunk: c.diff_hunk,
+        html_url: c.html_url,
+        resolved: threadInfo.resolvedThreadIds.has(threadId)
+      };
+    }
+  );
+}
+
 // src/commands/prs/fetchThreadIds.ts
-import { execSync as execSync12 } from "child_process";
+import { execSync as execSync14 } from "child_process";
 import { unlinkSync as unlinkSync3, writeFileSync as writeFileSync10 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join10 } from "path";
@@ -2368,7 +2439,7 @@ function fetchThreadIds(org, repo, prNumber) {
   const queryFile = join10(tmpdir2(), `gh-query-${Date.now()}.graphql`);
   writeFileSync10(queryFile, THREAD_QUERY);
   try {
-    const result = execSync12(
+    const result = execSync14(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf-8" }
     );
@@ -2392,17 +2463,17 @@ function fetchThreadIds(org, repo, prNumber) {
 // src/commands/prs/listComments.ts
 function formatForHuman(comment) {
   if (comment.type === "review") {
-    const stateColor = comment.state === "APPROVED" ? chalk31.green : comment.state === "CHANGES_REQUESTED" ? chalk31.red : chalk31.yellow;
+    const stateColor = comment.state === "APPROVED" ? chalk32.green : comment.state === "CHANGES_REQUESTED" ? chalk32.red : chalk32.yellow;
     return [
-      `${chalk31.cyan("Review")} by ${chalk31.bold(comment.user)} ${stateColor(`[${comment.state}]`)}`,
+      `${chalk32.cyan("Review")} by ${chalk32.bold(comment.user)} ${stateColor(`[${comment.state}]`)}`,
       comment.body,
       ""
     ].join("\n");
   }
   const location = comment.line ? `:${comment.line}` : "";
   return [
-    `${chalk31.cyan("Line comment")} by ${chalk31.bold(comment.user)} on ${chalk31.dim(`${comment.path}${location}`)}`,
-    chalk31.dim(comment.diff_hunk.split("\n").slice(-3).join("\n")),
+    `${chalk32.cyan("Line comment")} by ${chalk32.bold(comment.user)} on ${chalk32.dim(`${comment.path}${location}`)}`,
+    chalk32.dim(comment.diff_hunk.split("\n").slice(-3).join("\n")),
     comment.body,
     ""
   ].join("\n");
@@ -2439,48 +2510,6 @@ function writeCommentsCache(prNumber, comments) {
   const cachePath = join11(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync11(cachePath, stringify(cacheData));
 }
-function fetchReviewComments(org, repo, prNumber) {
-  const result = execSync13(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/reviews`,
-    { encoding: "utf-8" }
-  );
-  if (!result.trim()) return [];
-  const reviews = JSON.parse(result);
-  return reviews.filter((r) => r.body).map(
-    (r) => ({
-      type: "review",
-      id: r.id,
-      user: r.user.login,
-      state: r.state,
-      body: r.body
-    })
-  );
-}
-function fetchLineComments(org, repo, prNumber, threadInfo) {
-  const result = execSync13(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments`,
-    { encoding: "utf-8" }
-  );
-  if (!result.trim()) return [];
-  const comments = JSON.parse(result);
-  return comments.map(
-    (c) => {
-      const threadId = threadInfo.threadMap.get(c.id) ?? "";
-      return {
-        type: "line",
-        id: c.id,
-        threadId,
-        user: c.user.login,
-        path: c.path,
-        line: c.line,
-        body: c.body,
-        diff_hunk: c.diff_hunk,
-        html_url: c.html_url,
-        resolved: threadInfo.resolvedThreadIds.has(threadId)
-      };
-    }
-  );
-}
 async function listComments() {
   try {
     const prNumber = getCurrentPrNumber();
@@ -2511,67 +2540,45 @@ async function listComments() {
 }
 
 // src/commands/prs/prs.ts
-import { execSync as execSync14 } from "child_process";
-import chalk32 from "chalk";
+import { execSync as execSync15 } from "child_process";
+
+// src/commands/prs/displayPaginated.ts
+import chalk33 from "chalk";
 import enquirer4 from "enquirer";
 var PAGE_SIZE = 10;
-async function prs(options) {
-  const state = options.open ? "open" : options.closed ? "closed" : "all";
-  try {
-    const result = execSync14(
-      `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100`,
-      { encoding: "utf-8" }
+function getStatus(pr) {
+  if (pr.state === "MERGED" && pr.mergedAt) {
+    return { label: chalk33.magenta("merged"), date: pr.mergedAt };
+  }
+  if (pr.state === "CLOSED" && pr.closedAt) {
+    return { label: chalk33.red("closed"), date: pr.closedAt };
+  }
+  return { label: chalk33.green("opened"), date: pr.createdAt };
+}
+function displayPage(pullRequests, totalPages, page) {
+  const start = page * PAGE_SIZE;
+  const end = Math.min(start + PAGE_SIZE, pullRequests.length);
+  const pagePrs = pullRequests.slice(start, end);
+  console.log(
+    `
+Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
+`
+  );
+  for (const pr of pagePrs) {
+    const status = getStatus(pr);
+    const formattedDate = new Date(status.date).toISOString().split("T")[0];
+    const fileCount = pr.changedFiles.toLocaleString();
+    console.log(
+      `${chalk33.cyan(`#${pr.number}`)} ${pr.title} ${chalk33.dim(`(${pr.author.login},`)} ${status.label} ${chalk33.dim(`${formattedDate})`)}`
     );
-    const pullRequests = JSON.parse(result);
-    if (pullRequests.length === 0) {
-      console.log(
-        `No ${state === "all" ? "" : `${state} `}pull requests found.`
-      );
-      return;
-    }
-    await displayPaginated(pullRequests);
-  } catch (error) {
-    if (isGhNotInstalled(error)) {
-      console.error("Error: GitHub CLI (gh) is not installed.");
-      console.error("Install it from https://cli.github.com/");
-      return;
-    }
-    throw error;
+    console.log(chalk33.dim(`  ${fileCount} files | ${pr.url}`));
+    console.log();
   }
 }
 async function displayPaginated(pullRequests) {
   const totalPages = Math.ceil(pullRequests.length / PAGE_SIZE);
   let currentPage = 0;
-  const getStatus = (pr) => {
-    if (pr.state === "MERGED" && pr.mergedAt) {
-      return { label: chalk32.magenta("merged"), date: pr.mergedAt };
-    }
-    if (pr.state === "CLOSED" && pr.closedAt) {
-      return { label: chalk32.red("closed"), date: pr.closedAt };
-    }
-    return { label: chalk32.green("opened"), date: pr.createdAt };
-  };
-  const displayPage = (page) => {
-    const start = page * PAGE_SIZE;
-    const end = Math.min(start + PAGE_SIZE, pullRequests.length);
-    const pagePrs = pullRequests.slice(start, end);
-    console.log(
-      `
-Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
-`
-    );
-    for (const pr of pagePrs) {
-      const status = getStatus(pr);
-      const formattedDate = new Date(status.date).toISOString().split("T")[0];
-      const fileCount = pr.changedFiles.toLocaleString();
-      console.log(
-        `${chalk32.cyan(`#${pr.number}`)} ${pr.title} ${chalk32.dim(`(${pr.author.login},`)} ${status.label} ${chalk32.dim(`${formattedDate})`)}`
-      );
-      console.log(chalk32.dim(`  ${fileCount} files | ${pr.url}`));
-      console.log();
-    }
-  };
-  displayPage(currentPage);
+  displayPage(pullRequests, totalPages, currentPage);
   if (totalPages <= 1) {
     return;
   }
@@ -2590,18 +2597,44 @@ Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
     });
     if (action === "Next page") {
       currentPage++;
-      displayPage(currentPage);
+      displayPage(pullRequests, totalPages, currentPage);
     } else if (action === "Previous page") {
       currentPage--;
-      displayPage(currentPage);
+      displayPage(pullRequests, totalPages, currentPage);
     } else {
       break;
     }
   }
 }
 
+// src/commands/prs/prs.ts
+async function prs(options) {
+  const state = options.open ? "open" : options.closed ? "closed" : "all";
+  try {
+    const result = execSync15(
+      `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100`,
+      { encoding: "utf-8" }
+    );
+    const pullRequests = JSON.parse(result);
+    if (pullRequests.length === 0) {
+      console.log(
+        `No ${state === "all" ? "" : `${state} `}pull requests found.`
+      );
+      return;
+    }
+    await displayPaginated(pullRequests);
+  } catch (error) {
+    if (isGhNotInstalled(error)) {
+      console.error("Error: GitHub CLI (gh) is not installed.");
+      console.error("Install it from https://cli.github.com/");
+      return;
+    }
+    throw error;
+  }
+}
+
 // src/commands/prs/wontfix.ts
-import { execSync as execSync15 } from "child_process";
+import { execSync as execSync16 } from "child_process";
 function validateReason(reason) {
   const lowerReason = reason.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -2618,7 +2651,7 @@ function validateShaReferences(reason) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync15(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync16(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -2647,21 +2680,21 @@ function wontfix(commentId, reason) {
 
 // src/commands/refactor/check.ts
 import { spawn as spawn2 } from "child_process";
-import * as path14 from "path";
+import * as path15 from "path";
 
 // src/commands/refactor/getViolations.ts
-import { execSync as execSync16 } from "child_process";
-import fs14 from "fs";
+import { execSync as execSync17 } from "child_process";
+import fs15 from "fs";
 import { minimatch as minimatch2 } from "minimatch";
 
 // src/commands/refactor/getIgnoredFiles.ts
-import fs13 from "fs";
+import fs14 from "fs";
 var REFACTOR_YML_PATH = "refactor.yml";
 function parseRefactorYml() {
-  if (!fs13.existsSync(REFACTOR_YML_PATH)) {
+  if (!fs14.existsSync(REFACTOR_YML_PATH)) {
     return [];
   }
-  const content = fs13.readFileSync(REFACTOR_YML_PATH, "utf-8");
+  const content = fs14.readFileSync(REFACTOR_YML_PATH, "utf-8");
   const entries = [];
   const lines = content.split("\n");
   let currentEntry = {};
@@ -2690,7 +2723,7 @@ function getIgnoredFiles() {
 }
 
 // src/commands/refactor/logViolations.ts
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -2699,43 +2732,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk33.red(`
+  console.error(chalk34.red(`
 Refactor check failed:
 `));
-  console.error(chalk33.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk34.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk33.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk34.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk33.yellow(
+    chalk34.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk33.gray(`    assist refactor ignore <file>
+  console.error(chalk34.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk33.cyan(`
+    console.error(chalk34.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk33.cyan(
+      chalk34.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk33.cyan(
+      chalk34.cyan(
         `  1. Keep related logic together: If the extracted code is tightly coupled to the
      original file's domain, create a new folder containing both the original and extracted files.
 `
       )
     );
     console.error(
-      chalk33.cyan(
+      chalk34.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -2746,7 +2779,7 @@ Refactor check failed:
 
 // src/commands/refactor/getViolations.ts
 function countLines(filePath) {
-  const content = fs14.readFileSync(filePath, "utf-8");
+  const content = fs15.readFileSync(filePath, "utf-8");
   return content.split("\n").length;
 }
 function getGitFiles(options) {
@@ -2755,7 +2788,7 @@ function getGitFiles(options) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options.staged || options.modified) {
-    const staged = execSync16("git diff --cached --name-only", {
+    const staged = execSync17("git diff --cached --name-only", {
       encoding: "utf-8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -2763,7 +2796,7 @@ function getGitFiles(options) {
     }
   }
   if (options.unstaged || options.modified) {
-    const unstaged = execSync16("git diff --name-only", { encoding: "utf-8" });
+    const unstaged = execSync17("git diff --name-only", { encoding: "utf-8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -2771,7 +2804,7 @@ function getGitFiles(options) {
   return files;
 }
 function getViolations(pattern2, options = {}, maxLines = DEFAULT_MAX_LINES) {
-  let sourceFiles = findSourceFiles("src", { includeTests: false });
+  let sourceFiles = findSourceFiles2("src", { includeTests: false });
   const ignoredFiles = getIgnoredFiles();
   const gitFiles = getGitFiles(options);
   if (pattern2) {
@@ -2798,7 +2831,7 @@ async function runVerifyQuietly() {
     return true;
   }
   const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path14.dirname(packageJsonPath);
+  const packageDir = path15.dirname(packageJsonPath);
   const results = await Promise.all(
     verifyScripts.map(
       (script) => new Promise(
@@ -2851,33 +2884,451 @@ async function check(pattern2, options) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs15 from "fs";
-import chalk34 from "chalk";
+import fs16 from "fs";
+import chalk35 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
-  if (!fs15.existsSync(file)) {
-    console.error(chalk34.red(`Error: File does not exist: ${file}`));
+  if (!fs16.existsSync(file)) {
+    console.error(chalk35.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs15.readFileSync(file, "utf-8");
+  const content = fs16.readFileSync(file, "utf-8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs15.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs15.readFileSync(REFACTOR_YML_PATH2, "utf-8");
-    fs15.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs16.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs16.readFileSync(REFACTOR_YML_PATH2, "utf-8");
+    fs16.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs15.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs16.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk34.green(
+    chalk35.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
 }
 
+// src/commands/refactor/restructure/index.ts
+import path23 from "path";
+import chalk38 from "chalk";
+
+// src/commands/refactor/restructure/buildImportGraph.ts
+import path16 from "path";
+import ts5 from "typescript";
+function loadCompilerOptions(tsConfigPath) {
+  const configFile = ts5.readConfigFile(tsConfigPath, ts5.sys.readFile);
+  const parsed = ts5.parseJsonConfigFileContent(
+    configFile.config,
+    ts5.sys,
+    path16.dirname(tsConfigPath)
+  );
+  return parsed.options;
+}
+function getImportSpecifiers(sourceFile) {
+  const specifiers = [];
+  const visit = (node) => {
+    if (ts5.isImportDeclaration(node) && ts5.isStringLiteral(node.moduleSpecifier)) {
+      specifiers.push(node.moduleSpecifier.text);
+    } else if (ts5.isExportDeclaration(node) && node.moduleSpecifier && ts5.isStringLiteral(node.moduleSpecifier)) {
+      specifiers.push(node.moduleSpecifier.text);
+    } else if (ts5.isCallExpression(node) && node.expression.kind === ts5.SyntaxKind.ImportKeyword && node.arguments.length === 1 && ts5.isStringLiteral(node.arguments[0])) {
+      specifiers.push(node.arguments[0].text);
+    }
+    ts5.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return specifiers;
+}
+function buildImportGraph(candidateFiles, tsConfigPath) {
+  const options = loadCompilerOptions(tsConfigPath);
+  const configFile = ts5.readConfigFile(tsConfigPath, ts5.sys.readFile);
+  const parsed = ts5.parseJsonConfigFileContent(
+    configFile.config,
+    ts5.sys,
+    path16.dirname(tsConfigPath)
+  );
+  const program2 = ts5.createProgram(parsed.fileNames, options);
+  const allFiles = /* @__PURE__ */ new Set();
+  const edges = [];
+  const importedBy = /* @__PURE__ */ new Map();
+  const imports = /* @__PURE__ */ new Map();
+  for (const sourceFile of program2.getSourceFiles()) {
+    const filePath = path16.resolve(sourceFile.fileName);
+    if (filePath.includes("node_modules")) continue;
+    allFiles.add(filePath);
+    const specifiers = getImportSpecifiers(sourceFile);
+    for (const specifier of specifiers) {
+      if (!specifier.startsWith(".")) continue;
+      const resolved = ts5.resolveModuleName(
+        specifier,
+        filePath,
+        options,
+        ts5.sys
+      );
+      const resolvedPath = resolved.resolvedModule?.resolvedFileName;
+      if (!resolvedPath || resolvedPath.includes("node_modules")) continue;
+      const absTarget = path16.resolve(resolvedPath);
+      edges.push({ source: filePath, target: absTarget, specifier });
+      const targetSet = importedBy.get(absTarget) ?? /* @__PURE__ */ new Set();
+      if (!importedBy.has(absTarget)) importedBy.set(absTarget, targetSet);
+      targetSet.add(filePath);
+      const sourceSet = imports.get(filePath) ?? /* @__PURE__ */ new Set();
+      if (!imports.has(filePath)) imports.set(filePath, sourceSet);
+      sourceSet.add(absTarget);
+    }
+  }
+  return { files: candidateFiles, edges, importedBy, imports };
+}
+
+// src/commands/refactor/restructure/clusterDirectories.ts
+import path17 from "path";
+function clusterDirectories(graph) {
+  const dirImportedBy = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    const sourceDir = path17.dirname(edge.source);
+    const targetDir = path17.dirname(edge.target);
+    if (sourceDir === targetDir) continue;
+    if (!graph.files.has(edge.target)) continue;
+    const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
+    if (!dirImportedBy.has(targetDir)) dirImportedBy.set(targetDir, existing);
+    existing.add(sourceDir);
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  for (const [dir, importers] of dirImportedBy) {
+    if (importers.size !== 1) continue;
+    const parentDir = [...importers][0];
+    if (isAncestor(dir, parentDir)) continue;
+    if (isAncestor(parentDir, dir)) continue;
+    const cluster = clusters.get(parentDir) ?? [];
+    if (!clusters.has(parentDir)) clusters.set(parentDir, cluster);
+    cluster.push(dir);
+  }
+  for (const [parentDir, children] of clusters) {
+    const filtered = children.filter((child) => !clusters.has(child));
+    if (filtered.length === 0) {
+      clusters.delete(parentDir);
+    } else {
+      clusters.set(parentDir, filtered);
+    }
+  }
+  return clusters;
+}
+function isAncestor(ancestor, descendant) {
+  const rel = path17.relative(ancestor, descendant);
+  return !rel.startsWith("..") && rel !== "";
+}
+
+// src/commands/refactor/restructure/clusterFiles.ts
+import path18 from "path";
+function findRootParent(file, importedBy, visited) {
+  const importers = importedBy.get(file);
+  if (!importers || importers.size !== 1) return file;
+  const parent = [...importers][0];
+  const parentDir = path18.dirname(parent);
+  const fileDir = path18.dirname(file);
+  if (parentDir !== fileDir) return file;
+  if (path18.basename(parent, path18.extname(parent)) === "index") return file;
+  if (visited.has(parent)) return file;
+  visited.add(parent);
+  return findRootParent(parent, importedBy, visited);
+}
+function clusterFiles(graph) {
+  const clusters = /* @__PURE__ */ new Map();
+  for (const file of graph.files) {
+    const basename6 = path18.basename(file, path18.extname(file));
+    if (basename6 === "index") continue;
+    const importers = graph.importedBy.get(file);
+    if (!importers || importers.size !== 1) continue;
+    const parent = [...importers][0];
+    if (!graph.files.has(parent)) continue;
+    const parentDir = path18.dirname(parent);
+    const fileDir = path18.dirname(file);
+    if (parentDir !== fileDir) continue;
+    const parentBasename = path18.basename(parent, path18.extname(parent));
+    if (parentBasename === "index") continue;
+    const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
+    if (!root || root === file) continue;
+    const cluster = clusters.get(root) ?? [];
+    if (!clusters.has(root)) clusters.set(root, cluster);
+    cluster.push(file);
+  }
+  return clusters;
+}
+
+// src/commands/refactor/restructure/computeRewrites.ts
+import fs17 from "fs";
+import path19 from "path";
+function computeRewrites(moves, edges, allProjectFiles) {
+  const moveMap = /* @__PURE__ */ new Map();
+  for (const move of moves) {
+    moveMap.set(move.from, move.to);
+  }
+  const rewrites = [];
+  for (const file of allProjectFiles) {
+    const newFile = moveMap.get(file) ?? file;
+    const edgesFromFile = edges.filter((e) => e.source === file);
+    for (const edge of edgesFromFile) {
+      const newTarget = moveMap.get(edge.target);
+      if (!newTarget && !moveMap.has(file)) continue;
+      const targetPath = newTarget ?? edge.target;
+      const newSpecifier = computeSpecifier(newFile, targetPath);
+      if (newSpecifier === edge.specifier) continue;
+      rewrites.push({
+        file,
+        oldSpecifier: edge.specifier,
+        newSpecifier
+      });
+    }
+  }
+  return rewrites;
+}
+function computeSpecifier(fromFile, toFile) {
+  const fromDir = path19.dirname(fromFile);
+  let rel = path19.relative(fromDir, toFile);
+  rel = rel.replace(/\\/g, "/");
+  rel = rel.replace(/\.tsx?$/, "");
+  if (rel.endsWith("/index")) {
+    rel = rel.slice(0, -"/index".length);
+  }
+  if (!rel.startsWith(".")) {
+    rel = `./${rel}`;
+  }
+  return rel;
+}
+function applyRewrites(rewrites) {
+  const fileRewrites = /* @__PURE__ */ new Map();
+  for (const rewrite of rewrites) {
+    const existing = fileRewrites.get(rewrite.file) ?? [];
+    if (!fileRewrites.has(rewrite.file))
+      fileRewrites.set(rewrite.file, existing);
+    existing.push(rewrite);
+  }
+  const updatedContents = /* @__PURE__ */ new Map();
+  for (const [file, fileSpecificRewrites] of fileRewrites) {
+    let content = fs17.readFileSync(file, "utf-8");
+    for (const { oldSpecifier, newSpecifier } of fileSpecificRewrites) {
+      const escaped = oldSpecifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const pattern2 = new RegExp(`(from\\s+["'])${escaped}(["'])`, "g");
+      content = content.replace(pattern2, `$1${newSpecifier}$2`);
+    }
+    updatedContents.set(file, content);
+  }
+  return updatedContents;
+}
+
+// src/commands/refactor/restructure/displayPlan.ts
+import path20 from "path";
+import chalk36 from "chalk";
+function displayPlan(plan) {
+  if (plan.warnings.length > 0) {
+    console.log(chalk36.yellow("\nWarnings:"));
+    for (const warning of plan.warnings) {
+      console.log(chalk36.yellow(`  ${warning}`));
+    }
+  }
+  if (plan.newDirectories.length > 0) {
+    console.log(chalk36.bold("\nNew directories:"));
+    for (const dir of plan.newDirectories) {
+      console.log(chalk36.green(`  ${dir}/`));
+    }
+  }
+  if (plan.moves.length > 0) {
+    console.log(chalk36.bold("\nFile moves:"));
+    for (const move of plan.moves) {
+      const fromRel = path20.relative(process.cwd(), move.from);
+      const toRel = path20.relative(process.cwd(), move.to);
+      console.log(`  ${chalk36.red(fromRel)} \u2192 ${chalk36.green(toRel)}`);
+      console.log(chalk36.dim(`    ${move.reason}`));
+    }
+  }
+  if (plan.rewrites.length > 0) {
+    const affectedFiles = new Set(plan.rewrites.map((r) => r.file));
+    console.log(chalk36.bold(`
+Import rewrites (${affectedFiles.size} files):`));
+    for (const file of affectedFiles) {
+      const fileRewrites = plan.rewrites.filter((r) => r.file === file);
+      const rel = path20.relative(process.cwd(), file);
+      console.log(`  ${chalk36.cyan(rel)}:`);
+      for (const { oldSpecifier, newSpecifier } of fileRewrites) {
+        console.log(
+          `    ${chalk36.red(`"${oldSpecifier}"`)} \u2192 ${chalk36.green(`"${newSpecifier}"`)}`
+        );
+      }
+    }
+  }
+  console.log(
+    chalk36.dim(
+      `
+Summary: ${plan.moves.length} file(s) moved, ${plan.rewrites.length} imports rewritten`
+    )
+  );
+}
+
+// src/commands/refactor/restructure/executePlan.ts
+import fs18 from "fs";
+import path21 from "path";
+import chalk37 from "chalk";
+function executePlan(plan) {
+  const updatedContents = applyRewrites(plan.rewrites);
+  for (const [file, content] of updatedContents) {
+    fs18.writeFileSync(file, content, "utf-8");
+    console.log(
+      chalk37.cyan(`  Rewrote imports in ${path21.relative(process.cwd(), file)}`)
+    );
+  }
+  for (const dir of plan.newDirectories) {
+    fs18.mkdirSync(dir, { recursive: true });
+    console.log(chalk37.green(`  Created ${path21.relative(process.cwd(), dir)}/`));
+  }
+  for (const move of plan.moves) {
+    const targetDir = path21.dirname(move.to);
+    if (!fs18.existsSync(targetDir)) {
+      fs18.mkdirSync(targetDir, { recursive: true });
+    }
+    fs18.renameSync(move.from, move.to);
+    console.log(
+      chalk37.white(
+        `  Moved ${path21.relative(process.cwd(), move.from)} \u2192 ${path21.relative(process.cwd(), move.to)}`
+      )
+    );
+  }
+  removeEmptyDirectories(plan.moves.map((m) => path21.dirname(m.from)));
+}
+function removeEmptyDirectories(dirs) {
+  const unique = [...new Set(dirs)];
+  for (const dir of unique) {
+    if (!fs18.existsSync(dir)) continue;
+    const entries = fs18.readdirSync(dir);
+    if (entries.length === 0) {
+      fs18.rmdirSync(dir);
+      console.log(
+        chalk37.dim(
+          `  Removed empty directory ${path21.relative(process.cwd(), dir)}`
+        )
+      );
+    }
+  }
+}
+
+// src/commands/refactor/restructure/planFileMoves.ts
+import fs19 from "fs";
+import path22 from "path";
+function emptyResult() {
+  return { moves: [], directories: [], warnings: [] };
+}
+function planFileMoves(clusters) {
+  const result = emptyResult();
+  for (const [parent, children] of clusters) {
+    const parentBase = path22.basename(parent, path22.extname(parent));
+    const newDirName = parentBase;
+    const newDir = path22.join(path22.dirname(parent), newDirName);
+    if (fs19.existsSync(newDir)) {
+      result.warnings.push(
+        `Skipping ${parent}: directory ${newDir} already exists`
+      );
+      continue;
+    }
+    result.directories.push(newDir);
+    result.moves.push({
+      from: parent,
+      to: path22.join(newDir, `index${path22.extname(parent)}`),
+      reason: `Main module of new ${newDirName}/ directory`
+    });
+    for (const child of children) {
+      result.moves.push({
+        from: child,
+        to: path22.join(newDir, path22.basename(child)),
+        reason: `Only imported by ${parentBase}`
+      });
+    }
+  }
+  return result;
+}
+function planDirectoryMoves(clusters) {
+  const result = emptyResult();
+  for (const [parentDir, childDirs] of clusters) {
+    for (const childDir of childDirs) {
+      const childName = path22.basename(childDir);
+      const newLocation = path22.join(parentDir, childName);
+      if (fs19.existsSync(newLocation)) {
+        result.warnings.push(
+          `Skipping ${childDir}: ${newLocation} already exists`
+        );
+        continue;
+      }
+      result.directories.push(newLocation);
+      const files = listFilesRecursive(childDir);
+      for (const file of files) {
+        const rel = path22.relative(childDir, file);
+        result.moves.push({
+          from: file,
+          to: path22.join(newLocation, rel),
+          reason: `Directory only imported from ${path22.basename(parentDir)}/`
+        });
+      }
+    }
+  }
+  return result;
+}
+function listFilesRecursive(dir) {
+  const results = [];
+  if (!fs19.existsSync(dir)) return results;
+  const entries = fs19.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path22.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...listFilesRecursive(full));
+    } else {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+// src/commands/refactor/restructure/index.ts
+function buildPlan(candidateFiles, tsConfigPath) {
+  const candidates = new Set(candidateFiles.map((f) => path23.resolve(f)));
+  const graph = buildImportGraph(candidates, tsConfigPath);
+  const allProjectFiles = /* @__PURE__ */ new Set([
+    ...graph.importedBy.keys(),
+    ...graph.imports.keys()
+  ]);
+  const fileClusters = clusterFiles(graph);
+  const dirClusters = clusterDirectories(graph);
+  const fileResult = planFileMoves(fileClusters);
+  const dirResult = planDirectoryMoves(dirClusters);
+  const moves = [...fileResult.moves, ...dirResult.moves];
+  const directories = [...fileResult.directories, ...dirResult.directories];
+  const warnings = [...fileResult.warnings, ...dirResult.warnings];
+  const rewrites = computeRewrites(moves, graph.edges, allProjectFiles);
+  return { moves, rewrites, newDirectories: directories, warnings };
+}
+async function restructure(pattern2, options = {}) {
+  const targetPattern = pattern2 ?? "src";
+  const files = findSourceFiles(targetPattern);
+  if (files.length === 0) {
+    console.log(chalk38.yellow("No files found matching pattern"));
+    return;
+  }
+  const tsConfigPath = path23.resolve("tsconfig.json");
+  const plan = buildPlan(files, tsConfigPath);
+  if (plan.moves.length === 0) {
+    console.log(chalk38.green("No restructuring needed"));
+    return;
+  }
+  displayPlan(plan);
+  if (options.apply) {
+    console.log(chalk38.bold("\nApplying changes..."));
+    executePlan(plan);
+    console.log(chalk38.green("\nRestructuring complete"));
+  } else {
+    console.log(chalk38.dim("\nDry run. Use --apply to execute."));
+  }
+}
+
 // src/commands/run.ts
 import { spawn as spawn3 } from "child_process";
 function run(name, args) {
@@ -2963,29 +3414,29 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs18 from "fs";
+import * as fs22 from "fs";
 import * as os from "os";
-import * as path17 from "path";
+import * as path26 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
-import chalk35 from "chalk";
+import * as fs20 from "fs";
+import * as path24 from "path";
+import chalk39 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase) {
-  const source = path15.join(claudeDir, "CLAUDE.md");
-  const target = path15.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs16.readFileSync(source, "utf-8");
-  if (fs16.existsSync(target)) {
-    const targetContent = fs16.readFileSync(target, "utf-8");
+  const source = path24.join(claudeDir, "CLAUDE.md");
+  const target = path24.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs20.readFileSync(source, "utf-8");
+  if (fs20.existsSync(target)) {
+    const targetContent = fs20.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk35.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk39.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk35.red("Overwrite existing CLAUDE.md?"),
+        chalk39.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -2994,30 +3445,30 @@ async function syncClaudeMd(claudeDir, targetBase) {
       }
     }
   }
-  fs16.copyFileSync(source, target);
+  fs20.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
-import chalk36 from "chalk";
+import * as fs21 from "fs";
+import * as path25 from "path";
+import chalk40 from "chalk";
 async function syncSettings(claudeDir, targetBase) {
-  const source = path16.join(claudeDir, "settings.json");
-  const target = path16.join(targetBase, "settings.json");
-  const sourceContent = fs17.readFileSync(source, "utf-8");
+  const source = path25.join(claudeDir, "settings.json");
+  const target = path25.join(targetBase, "settings.json");
+  const sourceContent = fs21.readFileSync(source, "utf-8");
   const normalizedSource = JSON.stringify(JSON.parse(sourceContent), null, 2);
-  if (fs17.existsSync(target)) {
-    const targetContent = fs17.readFileSync(target, "utf-8");
+  if (fs21.existsSync(target)) {
+    const targetContent = fs21.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(JSON.parse(targetContent), null, 2);
     if (normalizedSource !== normalizedTarget) {
       console.log(
-        chalk36.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
+        chalk40.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk36.red("Overwrite existing settings.json?"),
+        chalk40.red("Overwrite existing settings.json?"),
         false
       );
       if (!confirm) {
@@ -3026,27 +3477,27 @@ async function syncSettings(claudeDir, targetBase) {
       }
     }
   }
-  fs17.copyFileSync(source, target);
+  fs21.copyFileSync(source, target);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname4 = path17.dirname(__filename2);
+var __dirname4 = path26.dirname(__filename2);
 async function sync() {
-  const claudeDir = path17.join(__dirname4, "..", "claude");
-  const targetBase = path17.join(os.homedir(), ".claude");
+  const claudeDir = path26.join(__dirname4, "..", "claude");
+  const targetBase = path26.join(os.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase);
   await syncClaudeMd(claudeDir, targetBase);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path17.join(claudeDir, "commands");
-  const targetDir = path17.join(targetBase, "commands");
-  fs18.mkdirSync(targetDir, { recursive: true });
-  const files = fs18.readdirSync(sourceDir);
+  const sourceDir = path26.join(claudeDir, "commands");
+  const targetDir = path26.join(targetBase, "commands");
+  fs22.mkdirSync(targetDir, { recursive: true });
+  const files = fs22.readdirSync(sourceDir);
   for (const file of files) {
-    fs18.copyFileSync(path17.join(sourceDir, file), path17.join(targetDir, file));
+    fs22.copyFileSync(path26.join(sourceDir, file), path26.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -3168,58 +3619,28 @@ async function configure() {
 import { existsSync as existsSync16, mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
 import { basename as basename4, dirname as dirname11, join as join17 } from "path";
 
-// src/commands/transcript/parseVtt.ts
-function parseTimestamp(ts4) {
-  const parts = ts4.split(":");
-  let hours = 0;
-  let minutes = 0;
-  let seconds = 0;
-  if (parts.length === 3) {
-    hours = Number.parseInt(parts[0], 10);
-    minutes = Number.parseInt(parts[1], 10);
-    seconds = Number.parseFloat(parts[2]);
-  } else if (parts.length === 2) {
-    minutes = Number.parseInt(parts[0], 10);
-    seconds = Number.parseFloat(parts[1]);
-  }
-  return Math.round((hours * 3600 + minutes * 60 + seconds) * 1e3);
-}
-function parseVtt(content) {
-  const cues = [];
-  const lines = content.split(/\r?\n/);
-  let i = 0;
-  while (i < lines.length && !lines[i].includes("-->")) {
-    i++;
-  }
-  while (i < lines.length) {
-    const line = lines[i].trim();
-    if (line.includes("-->")) {
-      const [startStr, endStr] = line.split("-->").map((s) => s.trim());
-      const startMs = parseTimestamp(startStr);
-      const endMs = parseTimestamp(endStr);
-      const textLines = [];
-      i++;
-      while (i < lines.length && lines[i].trim() && !lines[i].includes("-->")) {
-        textLines.push(lines[i].trim());
-        i++;
-      }
-      const fullText = textLines.join(" ");
-      const speakerMatch = fullText.match(/^<v\s+([^>]+)>/);
-      let speaker = null;
-      let text = fullText;
-      if (speakerMatch) {
-        speaker = speakerMatch[1];
-        text = fullText.replace(/<v\s+[^>]+>/, "").trim();
-      }
-      if (text) {
-        cues.push({ startMs, endMs, speaker, text });
+// src/commands/transcript/cleanText.ts
+function cleanText(text) {
+  const words = text.split(/\s+/);
+  const cleaned = [];
+  for (let i = 0; i < words.length; i++) {
+    let isRepeat = false;
+    for (let len = 3; len <= 8 && i + len <= words.length; len++) {
+      const phrase = words.slice(i, i + len).join(" ").toLowerCase();
+      const remaining = words.slice(i + len).join(" ").toLowerCase();
+      if (remaining.startsWith(phrase)) {
+        isRepeat = true;
+        break;
       }
-    } else {
-      i++;
+    }
+    if (!isRepeat) {
+      cleaned.push(words[i]);
     }
   }
-  return cues;
+  return cleaned.join(" ").replace(/\s+/g, " ").trim();
 }
+
+// src/commands/transcript/deduplicateCues.ts
 function removeSubstringDuplicates(cues) {
   const toRemove = /* @__PURE__ */ new Set();
   for (let i = 0; i < cues.length; i++) {
@@ -3240,6 +3661,16 @@ function removeSubstringDuplicates(cues) {
   }
   return cues.filter((_, i) => !toRemove.has(i));
 }
+function findWordOverlap(currentWords, nextWords) {
+  for (let j = Math.min(5, currentWords.length); j >= 1; j--) {
+    const suffix = currentWords.slice(-j).join(" ");
+    const prefix = nextWords.slice(0, j).join(" ");
+    if (suffix === prefix) {
+      return j;
+    }
+  }
+  return 0;
+}
 function mergeOverlappingCues(cues) {
   if (cues.length === 0) return [];
   const result = [];
@@ -3251,15 +3682,7 @@ function mergeOverlappingCues(cues) {
     if (sameSpeaker && overlaps) {
       const currentWords = current.text.toLowerCase().split(/\s+/);
       const nextWords = next2.text.toLowerCase().split(/\s+/);
-      let overlapIndex = -1;
-      for (let j = Math.min(5, currentWords.length); j >= 1; j--) {
-        const suffix = currentWords.slice(-j).join(" ");
-        const prefix = nextWords.slice(0, j).join(" ");
-        if (suffix === prefix) {
-          overlapIndex = j;
-          break;
-        }
-      }
+      const overlapIndex = findWordOverlap(currentWords, nextWords);
       if (overlapIndex > 0) {
         const nextOriginalWords = next2.text.split(/\s+/);
         current.text = `${current.text} ${nextOriginalWords.slice(overlapIndex).join(" ")}`;
@@ -3275,25 +3698,6 @@ function mergeOverlappingCues(cues) {
   result.push(current);
   return result;
 }
-function cleanText(text) {
-  const words = text.split(/\s+/);
-  const cleaned = [];
-  for (let i = 0; i < words.length; i++) {
-    let isRepeat = false;
-    for (let len = 3; len <= 8 && i + len <= words.length; len++) {
-      const phrase = words.slice(i, i + len).join(" ").toLowerCase();
-      const remaining = words.slice(i + len).join(" ").toLowerCase();
-      if (remaining.startsWith(phrase)) {
-        isRepeat = true;
-        break;
-      }
-    }
-    if (!isRepeat) {
-      cleaned.push(words[i]);
-    }
-  }
-  return cleaned.join(" ").replace(/\s+/g, " ").trim();
-}
 function deduplicateCues(cues) {
   if (cues.length === 0) return [];
   const sorted = [...cues].sort((a, b) => a.startMs - b.startMs);
@@ -3305,6 +3709,59 @@ function deduplicateCues(cues) {
   }));
 }
 
+// src/commands/transcript/parseVtt.ts
+function parseTimestamp(ts6) {
+  const parts = ts6.split(":");
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  if (parts.length === 3) {
+    hours = Number.parseInt(parts[0], 10);
+    minutes = Number.parseInt(parts[1], 10);
+    seconds = Number.parseFloat(parts[2]);
+  } else if (parts.length === 2) {
+    minutes = Number.parseInt(parts[0], 10);
+    seconds = Number.parseFloat(parts[1]);
+  }
+  return Math.round((hours * 3600 + minutes * 60 + seconds) * 1e3);
+}
+function parseVtt(content) {
+  const cues = [];
+  const lines = content.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length && !lines[i].includes("-->")) {
+    i++;
+  }
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (line.includes("-->")) {
+      const [startStr, endStr] = line.split("-->").map((s) => s.trim());
+      const startMs = parseTimestamp(startStr);
+      const endMs = parseTimestamp(endStr);
+      const textLines = [];
+      i++;
+      while (i < lines.length && lines[i].trim() && !lines[i].includes("-->")) {
+        textLines.push(lines[i].trim());
+        i++;
+      }
+      const fullText = textLines.join(" ");
+      const speakerMatch = fullText.match(/^<v\s+([^>]+)>/);
+      let speaker = null;
+      let text = fullText;
+      if (speakerMatch) {
+        speaker = speakerMatch[1];
+        text = fullText.replace(/<v\s+[^>]+>/, "").trim();
+      }
+      if (text) {
+        cues.push({ startMs, endMs, speaker, text });
+      }
+    } else {
+      i++;
+    }
+  }
+  return cues;
+}
+
 // src/commands/transcript/formatChatLog.ts
 function cuesToChatMessages(cues) {
   const messages = [];
@@ -3400,23 +3857,7 @@ function processFile(inputPath, outputPath) {
 `
   );
 }
-async function format() {
-  const { vttDir, transcriptsDir } = getTranscriptConfig();
-  if (!existsSync16(vttDir)) {
-    console.error(`VTT directory not found: ${vttDir}`);
-    process.exit(1);
-  }
-  if (!existsSync16(transcriptsDir)) {
-    mkdirSync5(transcriptsDir, { recursive: true });
-    console.log(`Created output directory: ${transcriptsDir}`);
-  }
-  let vttFiles = findVttFilesRecursive(vttDir);
-  if (vttFiles.length === 0) {
-    console.log("No VTT files found in vtt directory.");
-    return;
-  }
-  console.log(`Found ${vttFiles.length} VTT file(s) in ${vttDir}
-`);
+async function fixInvalidDatePrefixes(vttFiles) {
   for (let i = 0; i < vttFiles.length; i++) {
     const vttFile = vttFiles[i];
     if (!isValidDatePrefix(vttFile.filename)) {
@@ -3437,7 +3878,26 @@ async function format() {
       }
     }
   }
-  vttFiles = vttFiles.filter((f) => f.absolutePath !== "");
+  return vttFiles.filter((f) => f.absolutePath !== "");
+}
+async function format() {
+  const { vttDir, transcriptsDir } = getTranscriptConfig();
+  if (!existsSync16(vttDir)) {
+    console.error(`VTT directory not found: ${vttDir}`);
+    process.exit(1);
+  }
+  if (!existsSync16(transcriptsDir)) {
+    mkdirSync5(transcriptsDir, { recursive: true });
+    console.log(`Created output directory: ${transcriptsDir}`);
+  }
+  let vttFiles = findVttFilesRecursive(vttDir);
+  if (vttFiles.length === 0) {
+    console.log("No VTT files found in vtt directory.");
+    return;
+  }
+  console.log(`Found ${vttFiles.length} VTT file(s) in ${vttDir}
+`);
+  vttFiles = await fixInvalidDatePrefixes(vttFiles);
   let processed = 0;
   let skipped = 0;
   for (const vttFile of vttFiles) {
@@ -3464,6 +3924,10 @@ Summary: ${processed} processed, ${skipped} skipped`);
 }
 
 // src/commands/transcript/summarise.ts
+import { existsSync as existsSync18 } from "fs";
+import { basename as basename5, dirname as dirname13, join as join19, relative as relative2 } from "path";
+
+// src/commands/transcript/processStagedFile.ts
 import {
   existsSync as existsSync17,
   mkdirSync as mkdirSync6,
@@ -3471,8 +3935,8 @@ import {
   renameSync as renameSync2,
   rmSync
 } from "fs";
-import { basename as basename5, dirname as dirname12, join as join18, relative as relative2 } from "path";
-import chalk37 from "chalk";
+import { dirname as dirname12, join as join18 } from "path";
+import chalk41 from "chalk";
 var STAGING_DIR = join18(process.cwd(), ".assist", "transcript");
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function processStagedFile() {
@@ -3490,7 +3954,7 @@ function processStagedFile() {
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk37.red(
+      chalk41.red(
         `Staged file ${stagedFile.filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -3499,7 +3963,7 @@ function processStagedFile() {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk37.red(
+      chalk41.red(
         `Staged file ${stagedFile.filename} has no summary content after the transcript link.`
       )
     );
@@ -3512,7 +3976,7 @@ function processStagedFile() {
   );
   if (!matchingTranscript) {
     console.error(
-      chalk37.red(
+      chalk41.red(
         `No transcript found matching staged file: ${stagedFile.filename}`
       )
     );
@@ -3531,10 +3995,12 @@ function processStagedFile() {
   }
   return true;
 }
+
+// src/commands/transcript/summarise.ts
 function summarise() {
   processStagedFile();
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
-  if (!existsSync17(transcriptsDir)) {
+  if (!existsSync18(transcriptsDir)) {
     console.log("No transcripts directory found.");
     return;
   }
@@ -3546,16 +4012,16 @@ function summarise() {
   const summaryFiles = findMdFilesRecursive(summaryDir);
   const summaryRelativePaths = new Set(
     summaryFiles.map((f) => {
-      const relDir = dirname12(f.relativePath);
+      const relDir = dirname13(f.relativePath);
       const baseName = basename5(f.filename, ".md");
-      return relDir === "." ? baseName : join18(relDir, baseName);
+      return relDir === "." ? baseName : join19(relDir, baseName);
     })
   );
   const missing = [];
   for (const transcript of transcriptFiles) {
     const transcriptBaseName = getTranscriptBaseName(transcript.filename);
-    const relDir = dirname12(transcript.relativePath);
-    const fullKey = relDir === "." ? transcriptBaseName : join18(relDir, transcriptBaseName);
+    const relDir = dirname13(transcript.relativePath);
+    const fullKey = relDir === "." ? transcriptBaseName : join19(relDir, transcriptBaseName);
     if (!summaryRelativePaths.has(fullKey)) {
       missing.push(transcript);
     }
@@ -3566,8 +4032,8 @@ function summarise() {
   }
   const next2 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next2.filename)}.md`;
-  const outputPath = join18(STAGING_DIR, outputFilename);
-  const summaryFileDir = join18(summaryDir, dirname12(next2.relativePath));
+  const outputPath = join19(STAGING_DIR, outputFilename);
+  const summaryFileDir = join19(summaryDir, dirname13(next2.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative2(summaryFileDir, next2.absolutePath).replace(/\\/g, "/")
   );
@@ -3584,11 +4050,11 @@ function summarise() {
 }
 
 // src/commands/verify/hardcodedColors.ts
-import { execSync as execSync17 } from "child_process";
+import { execSync as execSync18 } from "child_process";
 var pattern = "0x[0-9a-fA-F]{6}|#[0-9a-fA-F]{3,6}";
 function hardcodedColors() {
   try {
-    const output = execSync17(`grep -rEnH '${pattern}' src/`, {
+    const output = execSync18(`grep -rEnH '${pattern}' src/`, {
       encoding: "utf-8"
     });
     const lines = output.trim().split("\n");
@@ -3618,7 +4084,7 @@ Total: ${lines.length} hardcoded color(s)`);
 
 // src/commands/verify/run.ts
 import { spawn as spawn4 } from "child_process";
-import * as path18 from "path";
+import * as path27 from "path";
 function formatDuration(ms) {
   if (ms < 1e3) {
     return `${ms}ms`;
@@ -3648,7 +4114,7 @@ async function run2(options = {}) {
     return;
   }
   const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path18.dirname(packageJsonPath);
+  const packageDir = path27.dirname(packageJsonPath);
   console.log(`Running ${verifyScripts.length} verify script(s) in parallel:`);
   for (const script of verifyScripts) {
     console.log(`  - ${script}`);
@@ -3698,7 +4164,7 @@ program.command("init").description("Initialize VS Code and verify configuration
 program.command("commit <message>").description("Create a git commit with validation").action(commit);
 program.command("update").description("Update claude-code to the latest version").action(() => {
   console.log("Updating claude-code...");
-  execSync18("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
+  execSync19("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
 });
 var configCommand = program.command("config").description("View and modify assist.yml configuration");
 configCommand.command("set <key> <value>").description("Set a config value (e.g. commit.push true)").action(configSet);
@@ -3731,6 +4197,13 @@ refactorCommand.command("check [pattern]").description("Check for files that exc
   Number.parseInt
 ).action(check);
 refactorCommand.command("ignore <file>").description("Add a file to the refactor ignore list").action(ignore);
+refactorCommand.command("restructure [pattern]").description(
+  "Analyze import graph and restructure tightly-coupled files into nested directories"
+).option("--apply", "Execute the restructuring (default: dry-run)").option(
+  "--max-depth <number>",
+  "Maximum nesting iterations (default: 3)",
+  Number.parseInt
+).action(restructure);
 var devlogCommand = program.command("devlog").description("Development log utilities");
 devlogCommand.command("list").description("Group git commits by date").option(
   "--days <number>",