@staff0rd/assist 0.45.0 → 0.47.0

package/dist/index.js

@@ -7,7 +7,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.45.0",
+  version: "0.47.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 65",
+    "verify:maintainability": "assist complexity maintainability ./src --threshold 70",
     "verify:custom-lint": "assist lint"
   },
   keywords: [],
@@ -214,65 +214,96 @@ function commit(message) {
 // src/commands/config/index.ts
 import chalk2 from "chalk";
 import { stringify as stringifyYaml2 } from "yaml";
-function getNestedValue(obj, path28) {
-  const keys = path28.split(".");
+
+// src/commands/config/getNestedValue.ts
+function isTraversable(value) {
+  return value !== null && value !== void 0 && typeof value === "object";
+}
+function stepInto(current, key) {
+  return isTraversable(current) ? current[key] : void 0;
+}
+function getNestedValue(obj, path29) {
   let current = obj;
-  for (const key of keys) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[key];
-  }
+  for (const key of path29.split(".")) current = stepInto(current, key);
   return current;
 }
-function setNestedValue(obj, path28, value) {
-  const keys = path28.split(".");
-  const result = { ...obj };
-  let current = result;
+function isPlainObject(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function ensureNestedObject(current, key) {
+  current[key] = isPlainObject(current[key]) ? { ...current[key] } : {};
+  return current[key];
+}
+function buildNestedPath(root, keys) {
+  let current = root;
   for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    current[key] = current[key] !== null && current[key] !== void 0 && typeof current[key] === "object" && !Array.isArray(current[key]) ? { ...current[key] } : {};
-    current = current[key];
+    current = ensureNestedObject(current, keys[i]);
   }
-  current[keys[keys.length - 1]] = value;
+  return current;
+}
+function setNestedValue(obj, path29, value) {
+  const keys = path29.split(".");
+  const result = { ...obj };
+  buildNestedPath(result, keys)[keys[keys.length - 1]] = value;
   return result;
 }
+
+// src/commands/config/index.ts
 function coerceValue(value) {
   if (value === "true") return true;
   if (value === "false") return false;
   return value;
 }
-function configSet(key, value) {
-  const config = loadConfig();
-  const coerced = coerceValue(value);
+function formatIssuePath(issue, key) {
+  return issue.path.length > 0 ? issue.path.join(".") : key;
+}
+function printValidationErrors(issues, key) {
+  for (const issue of issues) {
+    console.error(
+      chalk2.red(`${formatIssuePath(issue, key)}: ${issue.message}`)
+    );
+  }
+}
+function exitValidationFailed(issues, key) {
+  printValidationErrors(issues, key);
+  process.exit(1);
+}
+function validateConfig(updated, key) {
+  const result = assistConfigSchema.safeParse(updated);
+  if (!result.success) return exitValidationFailed(result.error.issues, key);
+  return result.data;
+}
+function applyConfigSet(key, coerced) {
   const updated = setNestedValue(
-    config,
+    loadConfig(),
     key,
     coerced
   );
-  const result = assistConfigSchema.safeParse(updated);
-  if (!result.success) {
-    for (const issue of result.error.issues) {
-      const path28 = issue.path.length > 0 ? issue.path.join(".") : key;
-      console.error(chalk2.red(`${path28}: ${issue.message}`));
-    }
-    process.exit(1);
-  }
-  saveConfig(result.data);
+  saveConfig(validateConfig(updated, key));
+}
+function configSet(key, value) {
+  const coerced = coerceValue(value);
+  applyConfigSet(key, coerced);
   console.log(chalk2.green(`Set ${key} = ${JSON.stringify(coerced)}`));
 }
-function configGet(key) {
-  const config = loadConfig();
+function formatOutput(value) {
+  return typeof value === "object" && value !== null ? JSON.stringify(value, null, 2) : String(value);
+}
+function exitKeyNotSet(key) {
+  console.error(chalk2.red(`Key "${key}" is not set`));
+  process.exit(1);
+}
+function requireNestedValue(config, key) {
   const value = getNestedValue(config, key);
-  if (value === void 0) {
-    console.error(chalk2.red(`Key "${key}" is not set`));
-    process.exit(1);
-  }
-  if (typeof value === "object" && value !== null) {
-    console.log(JSON.stringify(value, null, 2));
-  } else {
-    console.log(String(value));
-  }
+  if (value === void 0) return exitKeyNotSet(key);
+  return value;
+}
+function configGet(key) {
+  console.log(
+    formatOutput(
+      requireNestedValue(loadConfig(), key)
+    )
+  );
 }
 function configList() {
   const config = loadConfig();
@@ -750,55 +781,95 @@ function detectExistingSetup(pkg) {
 }
 
 // src/commands/verify/init/getAvailableOptions.ts
-function getAvailableOptions(setup) {
-  const options = [];
-  if (needsSetup(setup.knip)) {
-    options.push({
-      name: `knip${getStatusLabel(setup.knip)}`,
-      value: "knip",
-      description: "Dead code and unused dependency detection"
-    });
-  }
-  if (needsSetup(setup.biome)) {
-    options.push({
-      name: `lint${getStatusLabel(setup.biome)}`,
-      value: "lint",
-      description: "Code linting and formatting with Biome"
-    });
-  }
-  if (needsSetup(setup.jscpd)) {
-    options.push({
-      name: `duplicate-code${getStatusLabel(setup.jscpd)}`,
-      value: "duplicate-code",
-      description: "Duplicate code detection with jscpd"
-    });
+function getBuildDescription(setup) {
+  if (setup.hasVite && setup.hasTypescript)
+    return "TypeScript + Vite build verification";
+  if (setup.hasVite) return "Vite build verification";
+  return "TypeScript type checking";
+}
+function shouldInclude(setup, def) {
+  return needsSetup(setup[def.toolKey]) && (def.extraCondition ?? true);
+}
+function toVerifyOption(setup, def) {
+  return {
+    name: `${def.label}${getStatusLabel(setup[def.toolKey])}`,
+    value: def.value,
+    description: def.description
+  };
+}
+var STATIC_OPTIONS = [
+  {
+    toolKey: "knip",
+    value: "knip",
+    label: "knip",
+    description: "Dead code and unused dependency detection"
+  },
+  {
+    toolKey: "biome",
+    value: "lint",
+    label: "lint",
+    description: "Code linting and formatting with Biome"
+  },
+  {
+    toolKey: "jscpd",
+    value: "duplicate-code",
+    label: "duplicate-code",
+    description: "Duplicate code detection with jscpd"
+  },
+  {
+    toolKey: "hardcodedColors",
+    value: "hardcoded-colors",
+    label: "hardcoded-colors",
+    description: "Detect hardcoded hex colors (use open-color instead)"
   }
-  if (needsSetup(setup.test) && setup.test.hasPackage) {
-    options.push({
-      name: `test${getStatusLabel(setup.test)}`,
+];
+function getConditionalOptions(setup) {
+  return [
+    {
+      toolKey: "test",
       value: "test",
-      description: "Run tests with vitest"
-    });
-  }
-  if (needsSetup(setup.build) && (setup.hasTypescript || setup.hasVite)) {
-    const description = setup.hasVite ? setup.hasTypescript ? "TypeScript + Vite build verification" : "Vite build verification" : "TypeScript type checking";
-    options.push({
-      name: `build${getStatusLabel(setup.build)}`,
+      label: "test",
+      description: "Run tests with vitest",
+      extraCondition: setup.test.hasPackage
+    },
+    {
+      toolKey: "build",
       value: "build",
-      description
-    });
-  }
-  if (needsSetup(setup.hardcodedColors)) {
-    options.push({
-      name: `hardcoded-colors${getStatusLabel(setup.hardcodedColors)}`,
-      value: "hardcoded-colors",
-      description: "Detect hardcoded hex colors (use open-color instead)"
-    });
-  }
-  return options;
+      label: "build",
+      description: getBuildDescription(setup),
+      extraCondition: setup.hasTypescript || setup.hasVite
+    }
+  ];
+}
+function getAllOptionDefs(setup) {
+  return [...STATIC_OPTIONS, ...getConditionalOptions(setup)];
+}
+function getAvailableOptions(setup) {
+  return getAllOptionDefs(setup).filter((def) => shouldInclude(setup, def)).map((def) => toVerifyOption(setup, def));
 }
 
 // src/commands/verify/init/index.ts
+function getSetupHandlers(hasVite, hasTypescript, hasOpenColor) {
+  return {
+    knip: (p) => setupKnip(p),
+    lint: (p) => setupLint(p),
+    "duplicate-code": (p) => setupDuplicateCode(p),
+    test: (p) => setupTest(p),
+    build: (p) => setupBuild(p, hasVite, hasTypescript),
+    "hardcoded-colors": (p) => setupHardcodedColors(p, hasOpenColor)
+  };
+}
+async function runSelectedSetups(selected, packageJsonPath, handlers) {
+  for (const choice of selected) {
+    await handlers[choice]?.(packageJsonPath);
+  }
+  console.log(chalk14.green(`
+Added ${selected.length} verify script(s):`));
+  for (const choice of selected) {
+    console.log(chalk14.green(`  - verify:${choice}`));
+  }
+  console.log(chalk14.dim("\nRun 'assist verify' to run all verify scripts"));
+}
 async function init2() {
   const { packageJsonPath, pkg } = requirePackageJson();
   const setup = detectExistingSetup(pkg);
@@ -816,34 +887,12 @@ async function init2() {
     console.log(chalk14.yellow("No scripts selected"));
     return;
   }
-  for (const choice of selected) {
-    switch (choice) {
-      case "knip":
-        await setupKnip(packageJsonPath);
-        break;
-      case "lint":
-        await setupLint(packageJsonPath);
-        break;
-      case "duplicate-code":
-        await setupDuplicateCode(packageJsonPath);
-        break;
-      case "test":
-        await setupTest(packageJsonPath);
-        break;
-      case "build":
-        await setupBuild(packageJsonPath, setup.hasVite, setup.hasTypescript);
-        break;
-      case "hardcoded-colors":
-        await setupHardcodedColors(packageJsonPath, setup.hasOpenColor);
-        break;
-    }
-  }
-  console.log(chalk14.green(`
-Added ${selected.length} verify script(s):`));
-  for (const choice of selected) {
-    console.log(chalk14.green(`  - verify:${choice}`));
-  }
-  console.log(chalk14.dim("\nRun 'assist verify' to run all verify scripts"));
+  const handlers = getSetupHandlers(
+    setup.hasVite,
+    setup.hasTypescript,
+    setup.hasOpenColor
+  );
+  await runSelectedSetups(selected, packageJsonPath, handlers);
 }
 
 // src/commands/vscode/init/index.ts
@@ -932,24 +981,33 @@ function detectVscodeSetup(pkg) {
 }
 
 // src/commands/vscode/init/index.ts
-async function init3() {
-  const { pkg } = requirePackageJson();
-  const setup = detectVscodeSetup(pkg);
-  const availableOptions = [];
-  if (!setup.hasLaunchJson && setup.hasVite) {
-    availableOptions.push({
+var SETUP_HANDLERS = {
+  launch: () => createLaunchJson(),
+  settings: () => {
+    createSettingsJson();
+    createExtensionsJson();
+  }
+};
+function getAvailableOptions2(setup) {
+  const options = [];
+  if (!setup.hasLaunchJson && setup.hasVite)
+    options.push({
       name: "launch",
       value: "launch",
       description: "Debug configuration for Vite dev server"
     });
-  }
-  if (!setup.hasSettingsJson) {
-    availableOptions.push({
+  if (!setup.hasSettingsJson)
+    options.push({
       name: "settings",
       value: "settings",
       description: "Biome formatter configuration"
     });
-  }
+  return options;
+}
+async function init3() {
+  const { pkg } = requirePackageJson();
+  const setup = detectVscodeSetup(pkg);
+  const availableOptions = getAvailableOptions2(setup);
   if (availableOptions.length === 0) {
     console.log(chalk16.green("VS Code configuration already exists!"));
     return;
@@ -965,17 +1023,7 @@ async function init3() {
   }
   removeVscodeFromGitignore();
   ensureVscodeFolder();
-  for (const choice of selected) {
-    switch (choice) {
-      case "launch":
-        createLaunchJson();
-        break;
-      case "settings":
-        createSettingsJson();
-        createExtensionsJson();
-        break;
-    }
-  }
+  for (const choice of selected) SETUP_HANDLERS[choice]?.();
   console.log(
     chalk16.green(`
 Added ${selected.length} VS Code configuration(s)`)
@@ -1231,50 +1279,29 @@ Created ${WORKFLOW_PATH}`));
 }
 
 // src/commands/deploy/init/index.ts
-async function init5() {
-  console.log(chalk20.bold("Initializing Netlify deployment...\n"));
-  const existingSiteId = getExistingSiteId();
-  if (existingSiteId) {
-    console.log(chalk20.dim(`Using existing site ID: ${existingSiteId}
-`));
-    await updateWorkflow(existingSiteId);
-    return;
-  }
-  console.log("Creating Netlify site...\n");
+async function ensureNetlifyCli() {
   try {
-    execSync5("netlify sites:create --disable-linking", {
-      stdio: "inherit"
-    });
+    execSync5("netlify sites:create --disable-linking", { stdio: "inherit" });
   } catch (error) {
-    if (error instanceof Error && error.message.includes("command not found")) {
-      console.error(chalk20.red("\nNetlify CLI is not installed.\n"));
-      const install = await promptConfirm("Would you like to install it now?");
-      if (install) {
-        console.log(chalk20.dim("\nInstalling netlify-cli...\n"));
-        execSync5("npm install -g netlify-cli", { stdio: "inherit" });
-        console.log();
-        execSync5("netlify sites:create --disable-linking", {
-          stdio: "inherit"
-        });
-      } else {
-        console.log(
-          chalk20.yellow(
-            "\nInstall it manually with: npm install -g netlify-cli\n"
-          )
-        );
-        process.exit(1);
-      }
-    } else {
+    if (!(error instanceof Error) || !error.message.includes("command not found"))
       throw error;
+    console.error(chalk20.red("\nNetlify CLI is not installed.\n"));
+    const install = await promptConfirm("Would you like to install it now?");
+    if (!install) {
+      console.log(
+        chalk20.yellow(
+          "\nInstall it manually with: npm install -g netlify-cli\n"
+        )
+      );
+      process.exit(1);
     }
+    console.log(chalk20.dim("\nInstalling netlify-cli...\n"));
+    execSync5("npm install -g netlify-cli", { stdio: "inherit" });
+    console.log();
+    execSync5("netlify sites:create --disable-linking", { stdio: "inherit" });
   }
-  const { siteId } = await enquirer3.prompt({
-    type: "input",
-    name: "siteId",
-    message: "Enter the Site ID from above:",
-    validate: (value) => /^[a-f0-9-]+$/i.test(value) || "Invalid site ID format"
-  });
-  await updateWorkflow(siteId);
+}
+function printSetupInstructions() {
   console.log(chalk20.bold("\nDeployment initialized successfully!"));
   console.log(
     chalk20.yellow("\nTo complete setup, create a personal access token at:")
@@ -1290,6 +1317,26 @@ async function init5() {
     )
   );
 }
+async function init5() {
+  console.log(chalk20.bold("Initializing Netlify deployment...\n"));
+  const existingSiteId = getExistingSiteId();
+  if (existingSiteId) {
+    console.log(chalk20.dim(`Using existing site ID: ${existingSiteId}
+`));
+    await updateWorkflow(existingSiteId);
+    return;
+  }
+  console.log("Creating Netlify site...\n");
+  await ensureNetlifyCli();
+  const { siteId } = await enquirer3.prompt({
+    type: "input",
+    name: "siteId",
+    message: "Enter the Site ID from above:",
+    validate: (value) => /^[a-f0-9-]+$/i.test(value) || "Invalid site ID format"
+  });
+  await updateWorkflow(siteId);
+  printSetupInstructions();
+}
 
 // src/commands/new/newProject.ts
 async function newProject() {
@@ -1445,6 +1492,9 @@ async function notify() {
   console.log(`Notification sent: ${notification_type} for ${projectName}`);
 }
 
+// src/commands/complexity/analyze.ts
+import chalk26 from "chalk";
+
 // src/commands/complexity/cyclomatic.ts
 import chalk22 from "chalk";
 
@@ -1500,46 +1550,43 @@ function findSourceFiles2(pattern2, baseDir = ".") {
 
 // src/commands/complexity/shared/getNodeName.ts
 import ts from "typescript";
+var FUNCTION_TYPE_CHECKS = [
+  ts.isFunctionDeclaration,
+  ts.isFunctionExpression,
+  ts.isArrowFunction,
+  ts.isMethodDeclaration,
+  ts.isGetAccessor,
+  ts.isSetAccessor,
+  ts.isConstructorDeclaration
+];
+function getIdentifierText(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+  return "<computed>";
+}
+function getArrowFunctionName(node) {
+  const { parent } = node;
+  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>";
+}
 function getNodeName(node) {
-  if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(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.isMethodDeclaration(node) || ts.isMethodSignature(node))
+    return getIdentifierText(node.name);
+  if (ts.isArrowFunction(node)) return getArrowFunctionName(node);
   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 `${prefix}${getIdentifierText(node.name)}`;
   }
+  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;
+  if (!FUNCTION_TYPE_CHECKS.some((check2) => check2(node))) return false;
+  return node.body !== void 0;
 }
 
 // src/commands/complexity/shared/calculateCyclomaticComplexity.ts
@@ -1891,9 +1938,41 @@ Total: ${total} lines across ${files.length} files`)
   });
 }
 
+// src/commands/complexity/analyze.ts
+async function analyze(pattern2) {
+  const searchPattern = pattern2.includes("*") || pattern2.includes("/") ? pattern2 : `**/${pattern2}`;
+  const files = findSourceFiles2(searchPattern);
+  if (files.length === 0) {
+    console.log(chalk26.yellow("No files found matching pattern"));
+    return;
+  }
+  if (files.length === 1) {
+    const file = files[0];
+    console.log(chalk26.bold.underline("SLOC"));
+    await sloc(file);
+    console.log();
+    console.log(chalk26.bold.underline("Cyclomatic Complexity"));
+    await cyclomatic(file);
+    console.log();
+    console.log(chalk26.bold.underline("Halstead Metrics"));
+    await halstead(file);
+    console.log();
+    console.log(chalk26.bold.underline("Maintainability Index"));
+    await maintainability(file);
+    return;
+  }
+  await maintainability(searchPattern);
+}
+
 // src/commands/registerComplexity.ts
 function registerComplexity(program2) {
-  const complexityCommand = program2.command("complexity").description("Analyze TypeScript code complexity metrics");
+  const complexityCommand = program2.command("complexity").description("Analyze TypeScript code complexity metrics").argument("[pattern]").action((pattern2) => {
+    if (!pattern2) {
+      complexityCommand.help();
+      return;
+    }
+    return analyze(pattern2);
+  });
   complexityCommand.command("cyclomatic [pattern]").description("Calculate cyclomatic complexity per function").option("--threshold <number>", "Max complexity threshold", Number.parseInt).action(cyclomatic);
   complexityCommand.command("halstead [pattern]").description("Calculate Halstead metrics per function").option("--threshold <number>", "Max volume threshold", Number.parseInt).action(halstead);
   complexityCommand.command("maintainability [pattern]").description("Calculate maintainability index per file").option(
@@ -1906,7 +1985,7 @@ function registerComplexity(program2) {
 
 // src/commands/deploy/redirect.ts
 import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
         window.location.href = \`\${window.location.pathname}/\${window.location.search}\${window.location.hash}\`;
@@ -1915,22 +1994,22 @@ var TRAILING_SLASH_SCRIPT = `    <script>
 function redirect() {
   const indexPath = "index.html";
   if (!existsSync11(indexPath)) {
-    console.log(chalk26.yellow("No index.html found"));
+    console.log(chalk27.yellow("No index.html found"));
     return;
   }
   const content = readFileSync9(indexPath, "utf-8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
-    console.log(chalk26.dim("Trailing slash script already present"));
+    console.log(chalk27.dim("Trailing slash script already present"));
     return;
   }
   const headCloseIndex = content.indexOf("</head>");
   if (headCloseIndex === -1) {
-    console.log(chalk26.red("Could not find </head> tag in index.html"));
+    console.log(chalk27.red("Could not find </head> tag in index.html"));
     return;
   }
   const newContent = content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT + "\n  " + content.slice(headCloseIndex);
   writeFileSync8(indexPath, newContent);
-  console.log(chalk26.green("Added trailing slash redirect to index.html"));
+  console.log(chalk27.green("Added trailing slash redirect to index.html"));
 }
 
 // src/commands/registerDeploy.ts
@@ -1946,7 +2025,7 @@ import { basename as basename2 } from "path";
 
 // src/commands/devlog/shared.ts
 import { execSync as execSync7 } from "child_process";
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 
 // src/commands/devlog/loadDevlogEntries.ts
 import { readdirSync, readFileSync as readFileSync10 } from "fs";
@@ -2007,13 +2086,13 @@ function shouldIgnoreCommit(files, ignorePaths) {
 }
 function printCommitsWithFiles(commits, ignore2, verbose) {
   for (const commit2 of commits) {
-    console.log(`  ${chalk27.yellow(commit2.hash)} ${commit2.message}`);
+    console.log(`  ${chalk28.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(`    ${chalk27.dim(file)}`);
+        console.log(`    ${chalk28.dim(file)}`);
       }
     }
   }
@@ -2038,15 +2117,15 @@ function parseGitLogCommits(output, ignore2, afterDate) {
 }
 
 // src/commands/devlog/list/printDateHeader.ts
-import chalk28 from "chalk";
+import chalk29 from "chalk";
 function printDateHeader(date, isSkipped, entries) {
   if (isSkipped) {
-    console.log(`${chalk28.bold.blue(date)} ${chalk28.dim("skipped")}`);
+    console.log(`${chalk29.bold.blue(date)} ${chalk29.dim("skipped")}`);
   } else if (entries && entries.length > 0) {
-    const entryInfo = entries.map((e) => `${chalk28.green(e.version)} ${e.title}`).join(" | ");
-    console.log(`${chalk28.bold.blue(date)} ${entryInfo}`);
+    const entryInfo = entries.map((e) => `${chalk29.green(e.version)} ${e.title}`).join(" | ");
+    console.log(`${chalk29.bold.blue(date)} ${entryInfo}`);
   } else {
-    console.log(`${chalk28.bold.blue(date)} ${chalk28.red("\u26A0 devlog missing")}`);
+    console.log(`${chalk29.bold.blue(date)} ${chalk29.red("\u26A0 devlog missing")}`);
   }
 }
 
@@ -2085,10 +2164,6 @@ function list(options) {
   }
 }
 
-// src/commands/devlog/next/index.ts
-import { execSync as execSync10 } from "child_process";
-import chalk30 from "chalk";
-
 // src/commands/devlog/getLastVersionInfo.ts
 import { execSync as execSync9 } from "child_process";
 import semver from "semver";
@@ -2124,112 +2199,153 @@ function getLastVersionInfoFromGit() {
     return null;
   }
 }
+function findLastDate(entries) {
+  const dates = Array.from(entries.keys()).sort().reverse();
+  return dates[0] ?? null;
+}
 function getLastVersionInfo(repoName, config) {
   const entries = loadDevlogEntries(repoName);
-  if (entries.size === 0) {
-    return null;
-  }
-  const dates = Array.from(entries.keys()).sort().reverse();
-  const lastDate = dates[0];
-  if (!lastDate) {
-    return null;
-  }
+  const lastDate = findLastDate(entries);
+  if (!lastDate) return null;
   if (config?.commit?.conventional) {
     const gitInfo = getLastVersionInfoFromGit();
-    if (gitInfo) {
-      return { date: lastDate, version: gitInfo.version };
-    }
-  }
-  const lastEntries = entries.get(lastDate);
-  const lastVersion = lastEntries?.[0]?.version;
-  if (!lastVersion) {
-    return null;
+    if (gitInfo) return { date: lastDate, version: gitInfo.version };
   }
-  return { date: lastDate, version: lastVersion };
+  const lastVersion = entries.get(lastDate)?.[0]?.version;
+  return lastVersion ? { date: lastDate, version: lastVersion } : null;
+}
+function cleanVersion(version2) {
+  return semver.clean(version2) ?? semver.coerce(version2)?.version ?? null;
 }
 function bumpVersion(version2, type) {
-  const cleaned = semver.clean(version2) ?? semver.coerce(version2)?.version;
-  if (!cleaned) {
-    return version2;
-  }
+  const cleaned = cleanVersion(version2);
+  if (!cleaned) return version2;
   const bumped = semver.inc(cleaned, type);
-  if (!bumped) {
-    return version2;
-  }
-  if (type === "minor") {
-    const parsed = semver.parse(bumped);
-    return parsed ? `v${parsed.major}.${parsed.minor}` : `v${bumped}`;
-  }
+  if (!bumped) return version2;
+  if (type === "minor") return stripToMinor(bumped);
   return `v${bumped}`;
 }
 
-// src/commands/devlog/next/displayVersion.ts
-import chalk29 from "chalk";
+// src/commands/devlog/next/displayNextEntry/index.ts
+import { execSync as execSync10 } from "child_process";
+import chalk31 from "chalk";
+
+// src/commands/devlog/next/displayNextEntry/displayVersion.ts
+import chalk30 from "chalk";
 function displayVersion(conventional, firstHash, patchVersion, minorVersion) {
   if (conventional && firstHash) {
     const version2 = getVersionAtCommit(firstHash);
     if (version2) {
-      console.log(`${chalk29.bold("version:")} ${stripToMinor(version2)}`);
+      console.log(`${chalk30.bold("version:")} ${stripToMinor(version2)}`);
     } else {
-      console.log(`${chalk29.bold("version:")} ${chalk29.red("unknown")}`);
+      console.log(`${chalk30.bold("version:")} ${chalk30.red("unknown")}`);
     }
   } else if (patchVersion && minorVersion) {
     console.log(
-      `${chalk29.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
+      `${chalk30.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
     );
   } else {
-    console.log(`${chalk29.bold("version:")} v0.1 (initial)`);
+    console.log(`${chalk30.bold("version:")} v0.1 (initial)`);
   }
 }
 
-// src/commands/devlog/next/index.ts
-function next(options) {
-  const config = loadConfig();
-  const ignore2 = options.ignore ?? config.devlog?.ignore ?? [];
-  const skipDays = new Set(config.devlog?.skip?.days ?? []);
-  const repoName = getRepoName();
-  const lastInfo = getLastVersionInfo(repoName, config);
-  const lastDate = lastInfo?.date ?? null;
-  const patchVersion = lastInfo ? bumpVersion(lastInfo.version, "patch") : null;
-  const minorVersion = lastInfo ? bumpVersion(lastInfo.version, "minor") : null;
+// src/commands/devlog/next/displayNextEntry/index.ts
+function computeVersions(lastInfo) {
+  if (!lastInfo) return { patch: null, minor: null };
+  return {
+    patch: bumpVersion(lastInfo.version, "patch"),
+    minor: bumpVersion(lastInfo.version, "minor")
+  };
+}
+function findTargetDate(commitsByDate, skipDays) {
+  return Array.from(commitsByDate.keys()).filter((d) => !skipDays.has(d)).sort()[0];
+}
+function fetchCommitsByDate(ignore2, lastDate) {
   const output = execSync10(
     "git log --pretty=format:'%ad|%h|%s' --date=short -n 500",
     { encoding: "utf-8" }
   );
-  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(chalk30.dim("No commits after last versioned entry"));
-    } else {
-      console.log(chalk30.dim("No commits found"));
-    }
-    return;
-  }
-  const commits = commitsByDate.get(targetDate) ?? [];
-  console.log(`${chalk30.bold("name:")} ${repoName}`);
+  return parseGitLogCommits(output, ignore2, lastDate);
+}
+function printVersionInfo(config, lastInfo, firstHash) {
+  const versions = computeVersions(lastInfo);
   displayVersion(
     !!config.commit?.conventional,
-    commits[0]?.hash,
-    patchVersion,
-    minorVersion
+    firstHash,
+    versions.patch,
+    versions.minor
   );
-  console.log(`${chalk30.bold.blue(targetDate)}`);
-  printCommitsWithFiles(commits, ignore2, options.verbose ?? false);
+}
+function resolveIgnoreList(options, config) {
+  return options.ignore ?? config.devlog?.ignore ?? [];
+}
+function resolveSkipDays(config) {
+  return new Set(config.devlog?.skip?.days ?? []);
+}
+function getLastDate(lastInfo) {
+  return lastInfo?.date ?? null;
+}
+function getCommitsForDate(commitsByDate, date) {
+  return commitsByDate.get(date) ?? [];
+}
+function noCommitsMessage(hasLastInfo) {
+  return hasLastInfo ? "No commits after last versioned entry" : "No commits found";
+}
+function logName(repoName) {
+  console.log(`${chalk31.bold("name:")} ${repoName}`);
+}
+function displayNextEntry(ctx, targetDate, commits) {
+  logName(ctx.repoName);
+  printVersionInfo(ctx.config, ctx.lastInfo, commits[0]?.hash);
+  console.log(chalk31.bold.blue(targetDate));
+  printCommitsWithFiles(commits, ctx.ignore, ctx.verbose);
+}
+function logNoCommits(lastInfo) {
+  console.log(chalk31.dim(noCommitsMessage(!!lastInfo)));
+}
+
+// src/commands/devlog/next/index.ts
+function resolveContextData(config, options) {
+  const repoName = getRepoName();
+  const lastInfo = getLastVersionInfo(repoName, config);
+  return { repoName, lastInfo, ignore: resolveIgnoreList(options, config) };
+}
+function buildContext(options) {
+  const config = loadConfig();
+  const data = resolveContextData(config, options);
+  return { config, ...data, verbose: options.verbose ?? false };
+}
+function fetchNextCommits(ctx) {
+  const commitsByDate = fetchCommitsByDate(
+    ctx.ignore,
+    getLastDate(ctx.lastInfo)
+  );
+  const targetDate = findTargetDate(commitsByDate, resolveSkipDays(ctx.config));
+  return targetDate ? { targetDate, commits: getCommitsForDate(commitsByDate, targetDate) } : null;
+}
+function showResult(ctx, found) {
+  if (!found) {
+    logNoCommits(ctx.lastInfo);
+    return;
+  }
+  displayNextEntry(ctx, found.targetDate, found.commits);
+}
+function next(options) {
+  const ctx = buildContext(options);
+  showResult(ctx, fetchNextCommits(ctx));
 }
 
 // src/commands/devlog/skip.ts
-import chalk31 from "chalk";
+import chalk32 from "chalk";
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
-    console.log(chalk31.red("Invalid date format. Use YYYY-MM-DD"));
+    console.log(chalk32.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(chalk31.yellow(`${date} is already in skip list`));
+    console.log(chalk32.yellow(`${date} is already in skip list`));
     return;
   }
   skipDays.push(date);
@@ -2242,20 +2358,20 @@ function skip(date) {
     }
   };
   saveConfig(config);
-  console.log(chalk31.green(`Added ${date} to skip list`));
+  console.log(chalk32.green(`Added ${date} to skip list`));
 }
 
 // src/commands/devlog/version.ts
-import chalk32 from "chalk";
+import chalk33 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(`${chalk32.bold("name:")} ${name}`);
-  console.log(`${chalk32.bold("last:")} ${lastVersion ?? chalk32.dim("none")}`);
-  console.log(`${chalk32.bold("next:")} ${nextVersion ?? chalk32.dim("none")}`);
+  console.log(`${chalk33.bold("name:")} ${name}`);
+  console.log(`${chalk33.bold("last:")} ${lastVersion ?? chalk33.dim("none")}`);
+  console.log(`${chalk33.bold("next:")} ${nextVersion ?? chalk33.dim("none")}`);
 }
 
 // src/commands/registerDevlog.ts
@@ -2356,9 +2472,7 @@ function resolveThread(threadId) {
     unlinkSync3(queryFile);
   }
 }
-function resolveCommentWithReply(commentId, message) {
-  const prNumber = getCurrentPrNumber();
-  const { org, repo } = getRepoInfo();
+function requireCache(prNumber) {
   const cache = loadCommentsCache(prNumber);
   if (!cache) {
     console.error(
@@ -2366,27 +2480,37 @@ function resolveCommentWithReply(commentId, message) {
     );
     process.exit(1);
   }
-  const comment = cache.comments.find(
-    (c) => c.type === "line" && c.id === commentId
-  );
-  if (!comment || comment.type !== "line") {
-    console.error(`Error: Comment #${commentId} not found in cached data.`);
-    process.exit(1);
-  }
-  if (!comment.threadId) {
-    console.error(`Error: Comment #${commentId} has no associated thread ID.`);
+  return cache;
+}
+function findLineComment(comments, commentId) {
+  return comments.find((c) => c.type === "line" && c.id === commentId);
+}
+function requireLineComment(cache, commentId) {
+  const comment = findLineComment(cache.comments, commentId);
+  if (!comment || comment.type !== "line" || !comment.threadId) {
+    console.error(
+      `Error: Comment #${commentId} not found or has no thread ID.`
+    );
     process.exit(1);
   }
+  return comment;
+}
+function cleanupCacheIfDone(cache, prNumber, commentId) {
+  const hasRemaining = cache.comments.some(
+    (c) => c.type === "line" && c.id !== commentId
+  );
+  if (!hasRemaining) deleteCommentsCache(prNumber);
+}
+function resolveCommentWithReply(commentId, message) {
+  const prNumber = getCurrentPrNumber();
+  const { org, repo } = getRepoInfo();
+  const cache = requireCache(prNumber);
+  const comment = requireLineComment(cache, commentId);
   replyToComment(org, repo, prNumber, commentId, message);
   console.log("Reply posted successfully.");
   resolveThread(comment.threadId);
   console.log("Thread resolved successfully.");
-  const remainingLineComments = cache.comments.filter(
-    (c) => c.type === "line" && c.id !== commentId
-  );
-  if (remainingLineComments.length === 0) {
-    deleteCommentsCache(prNumber);
-  }
+  cleanupCacheIfDone(cache, prNumber, commentId);
 }
 
 // src/commands/prs/fixed.ts
@@ -2449,86 +2573,79 @@ function fetchThreadIds(org, repo, prNumber) {
 
 // src/commands/prs/listComments/fetchReviewComments.ts
 import { execSync as execSync14 } from "child_process";
-function fetchReviewComments(org, repo, prNumber) {
-  const result = execSync14(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/reviews`,
-    { encoding: "utf-8" }
-  );
+function fetchJson(endpoint) {
+  const result = execSync14(`gh api ${endpoint}`, { 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
-    })
-  );
+  return JSON.parse(result);
+}
+function mapReview(r) {
+  return {
+    type: "review",
+    id: r.id,
+    user: r.user.login,
+    state: r.state,
+    body: r.body
+  };
+}
+function fetchReviewComments(org, repo, prNumber) {
+  const reviews = fetchJson(`repos/${org}/${repo}/pulls/${prNumber}/reviews`);
+  return reviews.filter((r) => r.body).map(mapReview);
+}
+function mapLineComment(c, threadInfo) {
+  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)
+  };
 }
 function fetchLineComments(org, repo, prNumber, threadInfo) {
-  const result = execSync14(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments`,
-    { encoding: "utf-8" }
-  );
-  if (!result.trim()) return [];
-  const comments = JSON.parse(result);
+  const comments = fetchJson(`repos/${org}/${repo}/pulls/${prNumber}/comments`);
   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)
-      };
-    }
+    (c) => mapLineComment(c, threadInfo)
   );
 }
 
 // src/commands/prs/listComments/formatForHuman.ts
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 function formatForHuman(comment) {
   if (comment.type === "review") {
-    const stateColor = comment.state === "APPROVED" ? chalk33.green : comment.state === "CHANGES_REQUESTED" ? chalk33.red : chalk33.yellow;
+    const stateColor = comment.state === "APPROVED" ? chalk34.green : comment.state === "CHANGES_REQUESTED" ? chalk34.red : chalk34.yellow;
     return [
-      `${chalk33.cyan("Review")} by ${chalk33.bold(comment.user)} ${stateColor(`[${comment.state}]`)}`,
+      `${chalk34.cyan("Review")} by ${chalk34.bold(comment.user)} ${stateColor(`[${comment.state}]`)}`,
       comment.body,
       ""
     ].join("\n");
   }
   const location = comment.line ? `:${comment.line}` : "";
   return [
-    `${chalk33.cyan("Line comment")} by ${chalk33.bold(comment.user)} on ${chalk33.dim(`${comment.path}${location}`)}`,
-    chalk33.dim(comment.diff_hunk.split("\n").slice(-3).join("\n")),
+    `${chalk34.cyan("Line comment")} by ${chalk34.bold(comment.user)} on ${chalk34.dim(`${comment.path}${location}`)}`,
+    chalk34.dim(comment.diff_hunk.split("\n").slice(-3).join("\n")),
     comment.body,
     ""
   ].join("\n");
 }
 
 // src/commands/prs/listComments/index.ts
+function formatComment(comment) {
+  return isClaudeCode() ? JSON.stringify(comment) : formatForHuman(comment);
+}
 function printComments(comments) {
   if (comments.length === 0) {
     console.log("No comments found.");
     return;
   }
-  if (isClaudeCode()) {
-    for (const comment of comments) {
-      console.log(JSON.stringify(comment));
-    }
-  } else {
-    for (const comment of comments) {
-      console.log(formatForHuman(comment));
-    }
+  for (const comment of comments) {
+    console.log(formatComment(comment));
   }
-  const lineComments = comments.filter((c) => c.type === "line");
-  if (lineComments.length === 0) {
+  if (!comments.some((c) => c.type === "line")) {
     console.log("No line comments to process.");
   }
 }
@@ -2545,6 +2662,25 @@ function writeCommentsCache(prNumber, comments) {
   const cachePath = join12(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync11(cachePath, stringify(cacheData));
 }
+function handleKnownErrors(error) {
+  if (isGhNotInstalled(error)) {
+    console.error("Error: GitHub CLI (gh) is not installed.");
+    console.error("Install it from https://cli.github.com/");
+    return [];
+  }
+  if (isNotFound(error)) {
+    console.error("Error: Pull request not found.");
+    return [];
+  }
+  return null;
+}
+function updateCache(prNumber, comments) {
+  if (comments.some((c) => c.type === "line")) {
+    writeCommentsCache(prNumber, comments);
+  } else {
+    deleteCommentsCache(prNumber);
+  }
+}
 async function listComments() {
   try {
     const prNumber = getCurrentPrNumber();
@@ -2554,22 +2690,11 @@ async function listComments() {
       ...fetchReviewComments(org, repo, prNumber),
       ...fetchLineComments(org, repo, prNumber, threadInfo)
     ];
-    if (allComments.some((c) => c.type === "line")) {
-      writeCommentsCache(prNumber, allComments);
-    } else {
-      deleteCommentsCache(prNumber);
-    }
+    updateCache(prNumber, allComments);
     return allComments;
   } catch (error) {
-    if (isGhNotInstalled(error)) {
-      console.error("Error: GitHub CLI (gh) is not installed.");
-      console.error("Install it from https://cli.github.com/");
-      return [];
-    }
-    if (isNotFound(error)) {
-      console.error("Error: Pull request not found.");
-      return [];
-    }
+    const handled = handleKnownErrors(error);
+    if (handled !== null) return handled;
     throw error;
   }
 }
@@ -2577,69 +2702,104 @@ async function listComments() {
 // src/commands/prs/prs/index.ts
 import { execSync as execSync15 } from "child_process";
 
-// src/commands/prs/prs/displayPaginated.ts
-import chalk34 from "chalk";
+// src/commands/prs/prs/displayPaginated/index.ts
 import enquirer4 from "enquirer";
-var PAGE_SIZE = 10;
+
+// src/commands/prs/prs/displayPaginated/printPr.ts
+import chalk35 from "chalk";
+var STATUS_MAP = {
+  MERGED: (pr) => pr.mergedAt ? { label: chalk35.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk35.red("closed"), date: pr.closedAt } : null
+};
+function defaultStatus(pr) {
+  return { label: chalk35.green("opened"), date: pr.createdAt };
+}
 function getStatus(pr) {
-  if (pr.state === "MERGED" && pr.mergedAt) {
-    return { label: chalk34.magenta("merged"), date: pr.mergedAt };
-  }
-  if (pr.state === "CLOSED" && pr.closedAt) {
-    return { label: chalk34.red("closed"), date: pr.closedAt };
-  }
-  return { label: chalk34.green("opened"), date: pr.createdAt };
+  return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
 }
-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);
+function formatDate(dateStr) {
+  return new Date(dateStr).toISOString().split("T")[0];
+}
+function formatPrHeader(pr, status) {
+  return `${chalk35.cyan(`#${pr.number}`)} ${pr.title} ${chalk35.dim(`(${pr.author.login},`)} ${status.label} ${chalk35.dim(`${formatDate(status.date)})`)}`;
+}
+function logPrDetails(pr) {
   console.log(
-    `
-Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
-`
+    chalk35.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
-  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(
-      `${chalk34.cyan(`#${pr.number}`)} ${pr.title} ${chalk34.dim(`(${pr.author.login},`)} ${status.label} ${chalk34.dim(`${formattedDate})`)}`
-    );
-    console.log(chalk34.dim(`  ${fileCount} files | ${pr.url}`));
-    console.log();
+  console.log();
+}
+function printPr(pr) {
+  console.log(formatPrHeader(pr, getStatus(pr)));
+  logPrDetails(pr);
+}
+
+// src/commands/prs/prs/displayPaginated/index.ts
+var PAGE_SIZE = 10;
+function getPageSlice(pullRequests, page) {
+  const start = page * PAGE_SIZE;
+  return pullRequests.slice(start, start + PAGE_SIZE);
+}
+function pageHeader(page, totalPages, total) {
+  return `
+Page ${page + 1} of ${totalPages} (${total} total)
+`;
+}
+function displayPage(pullRequests, totalPages, page) {
+  console.log(pageHeader(page, totalPages, pullRequests.length));
+  for (const pr of getPageSlice(pullRequests, page)) printPr(pr);
+}
+function hasNextPage(page, total) {
+  return page < total - 1;
+}
+var NEXT_CHOICE = { name: "Next page", value: "next" };
+var PREV_CHOICE = { name: "Previous page", value: "prev" };
+function getOptionalChoices(currentPage, totalPages) {
+  const choices = [];
+  if (hasNextPage(currentPage, totalPages)) choices.push(NEXT_CHOICE);
+  if (currentPage > 0) choices.push(PREV_CHOICE);
+  return choices;
+}
+function buildNavChoices(currentPage, totalPages) {
+  return [
+    ...getOptionalChoices(currentPage, totalPages),
+    { name: "Quit", value: "quit" }
+  ];
+}
+function parseAction(action) {
+  if (action === "Next page") return 1;
+  if (action === "Previous page") return -1;
+  return 0;
+}
+async function promptNavigation(currentPage, totalPages) {
+  const choices = buildNavChoices(currentPage, totalPages);
+  const { action } = await enquirer4.prompt({
+    type: "select",
+    name: "action",
+    message: "Navigate",
+    choices
+  });
+  return parseAction(action);
+}
+function computeTotalPages(count) {
+  return Math.ceil(count / PAGE_SIZE);
+}
+async function navigateAndDisplay(pullRequests, totalPages, currentPage) {
+  const delta = await promptNavigation(currentPage, totalPages);
+  if (delta === 0) return null;
+  const next2 = currentPage + delta;
+  displayPage(pullRequests, totalPages, next2);
+  return next2;
+}
+async function paginationLoop(pullRequests, totalPages) {
+  let page = 0;
+  displayPage(pullRequests, totalPages, page);
+  while (totalPages > 1 && page !== null) {
+    page = await navigateAndDisplay(pullRequests, totalPages, page);
   }
 }
 async function displayPaginated(pullRequests) {
-  const totalPages = Math.ceil(pullRequests.length / PAGE_SIZE);
-  let currentPage = 0;
-  displayPage(pullRequests, totalPages, currentPage);
-  if (totalPages <= 1) {
-    return;
-  }
-  while (true) {
-    const hasNext = currentPage < totalPages - 1;
-    const hasPrev = currentPage > 0;
-    const choices = [];
-    if (hasNext) choices.push({ name: "Next page", value: "next" });
-    if (hasPrev) choices.push({ name: "Previous page", value: "prev" });
-    choices.push({ name: "Quit", value: "quit" });
-    const { action } = await enquirer4.prompt({
-      type: "select",
-      name: "action",
-      message: "Navigate",
-      choices
-    });
-    if (action === "Next page") {
-      currentPage++;
-      displayPage(pullRequests, totalPages, currentPage);
-    } else if (action === "Previous page") {
-      currentPage--;
-      displayPage(pullRequests, totalPages, currentPage);
-    } else {
-      break;
-    }
-  }
+  await paginationLoop(pullRequests, computeTotalPages(pullRequests.length));
 }
 
 // src/commands/prs/prs/index.ts
@@ -2732,7 +2892,7 @@ import { spawn as spawn2 } from "child_process";
 import * as path15 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk35 from "chalk";
+import chalk36 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -2741,43 +2901,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk35.red(`
+  console.error(chalk36.red(`
 Refactor check failed:
 `));
-  console.error(chalk35.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk36.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk35.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk36.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk35.yellow(
+    chalk36.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk35.gray(`    assist refactor ignore <file>
+  console.error(chalk36.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk35.cyan(`
+    console.error(chalk36.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk35.cyan(
+      chalk36.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk35.cyan(
+      chalk36.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(
-      chalk35.cyan(
+      chalk36.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -2874,46 +3034,45 @@ function getViolations(pattern2, options = {}, maxLines = DEFAULT_MAX_LINES) {
 }
 
 // src/commands/refactor/check/index.ts
+function runScript(script, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn2("npm", ["run", script], {
+      stdio: "pipe",
+      shell: true,
+      cwd
+    });
+    let output = "";
+    child.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve({ script, code: code ?? 1, output });
+    });
+  });
+}
+function logFailures(failed) {
+  for (const f of failed) {
+    console.error(f.output);
+  }
+  console.error(`
+${failed.length} verify script(s) failed:`);
+  for (const f of failed) {
+    console.error(`  - ${f.script} (exit code ${f.code})`);
+  }
+}
 async function runVerifyQuietly() {
   const result = findPackageJsonWithVerifyScripts(process.cwd());
-  if (!result) {
-    return true;
-  }
-  const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path15.dirname(packageJsonPath);
+  if (!result) return true;
+  const packageDir = path15.dirname(result.packageJsonPath);
   const results = await Promise.all(
-    verifyScripts.map(
-      (script) => new Promise(
-        (resolve) => {
-          const child = spawn2("npm", ["run", script], {
-            stdio: "pipe",
-            shell: true,
-            cwd: packageDir
-          });
-          let output = "";
-          child.stdout?.on("data", (data) => {
-            output += data.toString();
-          });
-          child.stderr?.on("data", (data) => {
-            output += data.toString();
-          });
-          child.on("close", (code) => {
-            resolve({ script, code: code ?? 1, output });
-          });
-        }
-      )
-    )
+    result.verifyScripts.map((script) => runScript(script, packageDir))
   );
   const failed = results.filter((r) => r.code !== 0);
   if (failed.length > 0) {
-    for (const f of failed) {
-      console.error(f.output);
-    }
-    console.error(`
-${failed.length} verify script(s) failed:`);
-    for (const f of failed) {
-      console.error(`  - ${f.script} (exit code ${f.code})`);
-    }
+    logFailures(failed);
     return false;
   }
   return true;
@@ -2934,11 +3093,11 @@ async function check(pattern2, options) {
 
 // src/commands/refactor/ignore.ts
 import fs16 from "fs";
-import chalk36 from "chalk";
+import chalk37 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
   if (!fs16.existsSync(file)) {
-    console.error(chalk36.red(`Error: File does not exist: ${file}`));
+    console.error(chalk37.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs16.readFileSync(file, "utf-8");
@@ -2954,15 +3113,15 @@ function ignore(file) {
     fs16.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk36.green(
+    chalk37.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
 }
 
 // src/commands/refactor/restructure/index.ts
-import path23 from "path";
-import chalk39 from "chalk";
+import path24 from "path";
+import chalk40 from "chalk";
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
 import path16 from "path";
@@ -2987,24 +3146,32 @@ function getImportSpecifiers(sourceFile) {
 }
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-function loadCompilerOptions(tsConfigPath) {
+function loadParsedConfig(tsConfigPath) {
   const configFile = ts7.readConfigFile(tsConfigPath, ts7.sys.readFile);
-  const parsed = ts7.parseJsonConfigFileContent(
+  return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
     path16.dirname(tsConfigPath)
   );
-  return parsed.options;
+}
+function addToSetMap(map, key, value) {
+  let set = map.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key, set);
+  }
+  set.add(value);
+}
+function resolveImport(specifier, filePath, options) {
+  if (!specifier.startsWith(".")) return null;
+  const resolved = ts7.resolveModuleName(specifier, filePath, options, ts7.sys);
+  const resolvedPath = resolved.resolvedModule?.resolvedFileName;
+  if (!resolvedPath || resolvedPath.includes("node_modules")) return null;
+  return path16.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
-  const options = loadCompilerOptions(tsConfigPath);
-  const configFile = ts7.readConfigFile(tsConfigPath, ts7.sys.readFile);
-  const parsed = ts7.parseJsonConfigFileContent(
-    configFile.config,
-    ts7.sys,
-    path16.dirname(tsConfigPath)
-  );
-  const program2 = ts7.createProgram(parsed.fileNames, options);
+  const parsed = loadParsedConfig(tsConfigPath);
+  const program2 = ts7.createProgram(parsed.fileNames, parsed.options);
   const edges = [];
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
@@ -3012,23 +3179,11 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
     const filePath = path16.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
-      if (!specifier.startsWith(".")) continue;
-      const resolved = ts7.resolveModuleName(
-        specifier,
-        filePath,
-        options,
-        ts7.sys
-      );
-      const resolvedPath = resolved.resolvedModule?.resolvedFileName;
-      if (!resolvedPath || resolvedPath.includes("node_modules")) continue;
-      const absTarget = path16.resolve(resolvedPath);
+      const absTarget = resolveImport(specifier, filePath, parsed.options);
+      if (!absTarget) continue;
       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);
+      addToSetMap(importedBy, absTarget, filePath);
+      addToSetMap(imports, filePath, absTarget);
     }
   }
   return { files: candidateFiles, edges, importedBy, imports };
@@ -3109,109 +3264,150 @@ function clusterFiles(graph) {
   return clusters;
 }
 
-// src/commands/refactor/restructure/computeRewrites.ts
-import fs17 from "fs";
+// src/commands/refactor/restructure/computeRewrites/index.ts
 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;
+
+// src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
+import fs17 from "fs";
+function getOrCreateList(map, key) {
+  const list2 = map.get(key) ?? [];
+  if (!map.has(key)) map.set(key, list2);
+  return list2;
 }
-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);
+function groupByFile(rewrites) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const rewrite of rewrites) {
+    getOrCreateList(grouped, rewrite.file).push(rewrite);
   }
-  if (!rel.startsWith(".")) {
-    rel = `./${rel}`;
+  return grouped;
+}
+function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
+  const escaped = oldSpecifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern2 = new RegExp(`(from\\s+["'])${escaped}(["'])`, "g");
+  return content.replace(pattern2, `$1${newSpecifier}$2`);
+}
+function applyFileRewrites(file, fileRewrites) {
+  let content = fs17.readFileSync(file, "utf-8");
+  for (const { oldSpecifier, newSpecifier } of fileRewrites) {
+    content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
   }
-  return rel;
+  return content;
 }
 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);
+  for (const [file, fileRewrites] of groupByFile(rewrites)) {
+    updatedContents.set(file, applyFileRewrites(file, fileRewrites));
   }
   return updatedContents;
 }
 
+// src/commands/refactor/restructure/computeRewrites/index.ts
+function buildMoveMap(moves) {
+  const map = /* @__PURE__ */ new Map();
+  for (const move of moves) map.set(move.from, move.to);
+  return map;
+}
+function stripTrailingIndex(specifier) {
+  return specifier.endsWith("/index") ? specifier.slice(0, -"/index".length) : specifier;
+}
+function ensureRelative(specifier) {
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function normalizeSpecifier(rel) {
+  return ensureRelative(
+    stripTrailingIndex(rel.replace(/\\/g, "/").replace(/\.tsx?$/, ""))
+  );
+}
+function computeSpecifier(fromFile, toFile) {
+  return normalizeSpecifier(path19.relative(path19.dirname(fromFile), toFile));
+}
+function isAffected(edge, moveMap) {
+  return moveMap.has(edge.target) || moveMap.has(edge.source);
+}
+function resolveTarget(edge, moveMap) {
+  return moveMap.get(edge.target) ?? edge.target;
+}
+function createRewrite(edge, newSpecifier) {
+  return { file: edge.source, oldSpecifier: edge.specifier, newSpecifier };
+}
+function rewriteIfChanged(edge, newSpecifier) {
+  return newSpecifier === edge.specifier ? null : createRewrite(edge, newSpecifier);
+}
+function rewriteEdge(edge, newFile, moveMap) {
+  if (!isAffected(edge, moveMap)) return null;
+  return rewriteIfChanged(
+    edge,
+    computeSpecifier(newFile, resolveTarget(edge, moveMap))
+  );
+}
+function fileEdges(edges, file) {
+  return edges.filter((e) => e.source === file);
+}
+function collectRewrites(edges, newFile, moveMap) {
+  const rewrites = [];
+  for (const edge of edges) {
+    const rewrite = rewriteEdge(edge, newFile, moveMap);
+    if (rewrite) rewrites.push(rewrite);
+  }
+  return rewrites;
+}
+function rewriteEdgesForFile(file, edges, moveMap) {
+  const newFile = moveMap.get(file) ?? file;
+  return collectRewrites(fileEdges(edges, file), newFile, moveMap);
+}
+function computeRewrites(moves, edges, allProjectFiles) {
+  const moveMap = buildMoveMap(moves);
+  return [...allProjectFiles].flatMap(
+    (file) => rewriteEdgesForFile(file, edges, moveMap)
+  );
+}
+
 // src/commands/refactor/restructure/displayPlan.ts
 import path20 from "path";
-import chalk37 from "chalk";
-function displayPlan(plan) {
-  if (plan.warnings.length > 0) {
-    console.log(chalk37.yellow("\nWarnings:"));
-    for (const warning of plan.warnings) {
-      console.log(chalk37.yellow(`  ${warning}`));
-    }
+import chalk38 from "chalk";
+function relPath(filePath) {
+  return path20.relative(process.cwd(), filePath);
+}
+function displayMoves(plan) {
+  if (plan.moves.length === 0) return;
+  console.log(chalk38.bold("\nFile moves:"));
+  for (const move of plan.moves) {
+    console.log(
+      `  ${chalk38.red(relPath(move.from))} \u2192 ${chalk38.green(relPath(move.to))}`
+    );
+    console.log(chalk38.dim(`    ${move.reason}`));
   }
-  if (plan.newDirectories.length > 0) {
-    console.log(chalk37.bold("\nNew directories:"));
-    for (const dir of plan.newDirectories) {
-      console.log(chalk37.green(`  ${dir}/`));
+}
+function displayRewrites(rewrites) {
+  if (rewrites.length === 0) return;
+  const affectedFiles = new Set(rewrites.map((r) => r.file));
+  console.log(chalk38.bold(`
+Import rewrites (${affectedFiles.size} files):`));
+  for (const file of affectedFiles) {
+    console.log(`  ${chalk38.cyan(relPath(file))}:`);
+    for (const { oldSpecifier, newSpecifier } of rewrites.filter(
+      (r) => r.file === file
+    )) {
+      console.log(
+        `    ${chalk38.red(`"${oldSpecifier}"`)} \u2192 ${chalk38.green(`"${newSpecifier}"`)}`
+      );
     }
   }
-  if (plan.moves.length > 0) {
-    console.log(chalk37.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(`  ${chalk37.red(fromRel)} \u2192 ${chalk37.green(toRel)}`);
-      console.log(chalk37.dim(`    ${move.reason}`));
-    }
+}
+function displayPlan(plan) {
+  if (plan.warnings.length > 0) {
+    console.log(chalk38.yellow("\nWarnings:"));
+    for (const w of plan.warnings) console.log(chalk38.yellow(`  ${w}`));
   }
-  if (plan.rewrites.length > 0) {
-    const affectedFiles = new Set(plan.rewrites.map((r) => r.file));
-    console.log(chalk37.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(`  ${chalk37.cyan(rel)}:`);
-      for (const { oldSpecifier, newSpecifier } of fileRewrites) {
-        console.log(
-          `    ${chalk37.red(`"${oldSpecifier}"`)} \u2192 ${chalk37.green(`"${newSpecifier}"`)}`
-        );
-      }
-    }
+  if (plan.newDirectories.length > 0) {
+    console.log(chalk38.bold("\nNew directories:"));
+    for (const dir of plan.newDirectories)
+      console.log(chalk38.green(`  ${dir}/`));
   }
+  displayMoves(plan);
+  displayRewrites(plan.rewrites);
   console.log(
-    chalk37.dim(
+    chalk38.dim(
       `
 Summary: ${plan.moves.length} file(s) moved, ${plan.rewrites.length} imports rewritten`
     )
@@ -3221,18 +3417,18 @@ Summary: ${plan.moves.length} file(s) moved, ${plan.rewrites.length} imports rew
 // src/commands/refactor/restructure/executePlan.ts
 import fs18 from "fs";
 import path21 from "path";
-import chalk38 from "chalk";
+import chalk39 from "chalk";
 function executePlan(plan) {
   const updatedContents = applyRewrites(plan.rewrites);
   for (const [file, content] of updatedContents) {
     fs18.writeFileSync(file, content, "utf-8");
     console.log(
-      chalk38.cyan(`  Rewrote imports in ${path21.relative(process.cwd(), file)}`)
+      chalk39.cyan(`  Rewrote imports in ${path21.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan.newDirectories) {
     fs18.mkdirSync(dir, { recursive: true });
-    console.log(chalk38.green(`  Created ${path21.relative(process.cwd(), dir)}/`));
+    console.log(chalk39.green(`  Created ${path21.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan.moves) {
     const targetDir = path21.dirname(move.to);
@@ -3241,7 +3437,7 @@ function executePlan(plan) {
     }
     fs18.renameSync(move.from, move.to);
     console.log(
-      chalk38.white(
+      chalk39.white(
         `  Moved ${path21.relative(process.cwd(), move.from)} \u2192 ${path21.relative(process.cwd(), move.to)}`
       )
     );
@@ -3256,7 +3452,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs18.rmdirSync(dir);
       console.log(
-        chalk38.dim(
+        chalk39.dim(
           `  Removed empty directory ${path21.relative(process.cwd(), dir)}`
         )
       );
@@ -3264,84 +3460,110 @@ function removeEmptyDirectories(dirs) {
   }
 }
 
-// src/commands/refactor/restructure/planFileMoves.ts
+// src/commands/refactor/restructure/planFileMoves/index.ts
+import fs20 from "fs";
+import path23 from "path";
+
+// src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
 import fs19 from "fs";
 import path22 from "path";
-function emptyResult() {
-  return { moves: [], directories: [], warnings: [] };
+function collectEntry(results, dir, entry) {
+  const full = path22.join(dir, entry.name);
+  const items = entry.isDirectory() ? listFilesRecursive(full) : [full];
+  results.push(...items);
 }
-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}`
-      });
-    }
+function listFilesRecursive(dir) {
+  if (!fs19.existsSync(dir)) return [];
+  const results = [];
+  for (const entry of fs19.readdirSync(dir, { withFileTypes: true })) {
+    collectEntry(results, dir, entry);
   }
-  return result;
+  return results;
 }
-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)}/`
-        });
-      }
-    }
+function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
+  for (const file of listFilesRecursive(childDir)) {
+    const rel = path22.relative(childDir, file);
+    moves.push({ from: file, to: path22.join(newLocation, rel), reason });
   }
-  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);
-    }
+function resolveChildDest(parentDir, childDir) {
+  return path22.join(parentDir, path22.basename(childDir));
+}
+function childMoveReason(parentDir) {
+  return `Directory only imported from ${path22.basename(parentDir)}/`;
+}
+function registerDirectoryMove(result, childDir, dest, parentDir) {
+  result.directories.push(dest);
+  const reason = childMoveReason(parentDir);
+  addDirectoryFileMoves(result.moves, childDir, dest, reason);
+}
+function planChildDirectoryMove(result, parentDir, childDir) {
+  const dest = resolveChildDest(parentDir, childDir);
+  if (checkDirConflict(result, childDir, dest)) return;
+  registerDirectoryMove(result, childDir, dest, parentDir);
+}
+function processDirectoryCluster(result, parentDir, childDirs) {
+  for (const childDir of childDirs)
+    planChildDirectoryMove(result, parentDir, childDir);
+}
+function planDirectoryMoves(clusters) {
+  const result = emptyResult();
+  for (const [parentDir, childDirs] of clusters)
+    processDirectoryCluster(result, parentDir, childDirs);
+  return result;
+}
+
+// src/commands/refactor/restructure/planFileMoves/index.ts
+function emptyResult() {
+  return { moves: [], directories: [], warnings: [] };
+}
+function childMoveData(child, newDir, parentBase) {
+  const to = path23.join(newDir, path23.basename(child));
+  return { from: child, to, reason: `Only imported by ${parentBase}` };
+}
+function addChildMoves(moves, children, newDir, parentBase) {
+  for (const child of children)
+    moves.push(childMoveData(child, newDir, parentBase));
+}
+function checkDirConflict(result, label, dir) {
+  if (!fs20.existsSync(dir)) return false;
+  result.warnings.push(`Skipping ${label}: directory ${dir} already exists`);
+  return true;
+}
+function getBaseName(filePath) {
+  return path23.basename(filePath, path23.extname(filePath));
+}
+function resolveClusterDir(parent) {
+  return path23.join(path23.dirname(parent), getBaseName(parent));
+}
+function createParentMove(parent, newDir) {
+  return {
+    from: parent,
+    to: path23.join(newDir, `index${path23.extname(parent)}`),
+    reason: `Main module of new ${getBaseName(parent)}/ directory`
+  };
+}
+function registerClusterMoves(result, parent, newDir, children) {
+  result.directories.push(newDir);
+  result.moves.push(createParentMove(parent, newDir));
+  addChildMoves(result.moves, children, newDir, getBaseName(parent));
+}
+function planClusterMoves(result, parent, children) {
+  const newDir = resolveClusterDir(parent);
+  if (checkDirConflict(result, parent, newDir)) return;
+  registerClusterMoves(result, parent, newDir, children);
+}
+function planFileMoves(clusters) {
+  const result = emptyResult();
+  for (const [parent, children] of clusters) {
+    planClusterMoves(result, parent, children);
   }
-  return results;
+  return result;
 }
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path23.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path24.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -3361,22 +3583,22 @@ async function restructure(pattern2, options = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk39.yellow("No files found matching pattern"));
+    console.log(chalk40.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path23.resolve("tsconfig.json");
+  const tsConfigPath = path24.resolve("tsconfig.json");
   const plan = buildPlan(files, tsConfigPath);
   if (plan.moves.length === 0) {
-    console.log(chalk39.green("No restructuring needed"));
+    console.log(chalk40.green("No restructuring needed"));
     return;
   }
   displayPlan(plan);
   if (options.apply) {
-    console.log(chalk39.bold("\nApplying changes..."));
+    console.log(chalk40.bold("\nApplying changes..."));
     executePlan(plan);
-    console.log(chalk39.green("\nRestructuring complete"));
+    console.log(chalk40.green("\nRestructuring complete"));
   } else {
-    console.log(chalk39.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk40.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -3414,38 +3636,31 @@ function getDatePrefix(daysOffset = 0) {
 function isValidDatePrefix(filename) {
   return DATE_PREFIX_REGEX.test(filename);
 }
-function findFilesRecursive(dir, baseDir, extension, createEntry) {
-  if (!existsSync14(dir)) {
-    return [];
-  }
+function collectFiles(dir, extension) {
+  if (!existsSync14(dir)) return [];
   const results = [];
-  const entries = readdirSync2(dir);
-  for (const entry of entries) {
+  for (const entry of readdirSync2(dir)) {
     const fullPath = join13(dir, entry);
-    const stat = statSync(fullPath);
-    if (stat.isDirectory()) {
-      results.push(
-        ...findFilesRecursive(fullPath, baseDir, extension, createEntry)
-      );
+    if (statSync(fullPath).isDirectory()) {
+      results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
-      results.push(createEntry(fullPath, relative(baseDir, fullPath), entry));
+      results.push(fullPath);
     }
   }
   return results;
 }
+function toFileInfo(baseDir, fullPath) {
+  return {
+    absolutePath: fullPath,
+    relativePath: relative(baseDir, fullPath),
+    filename: basename3(fullPath)
+  };
+}
 function findVttFilesRecursive(dir, baseDir = dir) {
-  return findFilesRecursive(dir, baseDir, ".vtt", (abs, rel, name) => ({
-    absolutePath: abs,
-    relativePath: rel,
-    filename: name
-  }));
+  return collectFiles(dir, ".vtt").map((f) => toFileInfo(baseDir, f));
 }
 function findMdFilesRecursive(dir, baseDir = dir) {
-  return findFilesRecursive(dir, baseDir, ".md", (abs, rel, name) => ({
-    absolutePath: abs,
-    relativePath: rel,
-    filename: name
-  }));
+  return collectFiles(dir, ".md").map((f) => toFileInfo(baseDir, f));
 }
 function getTranscriptBaseName(transcriptFile) {
   return basename3(transcriptFile, ".md").replace(/ Transcription$/, "");
@@ -3465,44 +3680,52 @@ function askQuestion(rl, question) {
 }
 
 // src/commands/transcript/configure.ts
+function buildPrompt(label, current) {
+  return current ? `${label} [${current}]: ` : `${label}: `;
+}
+function printExisting(existing) {
+  console.log("Current configuration:");
+  console.log(`  VTT directory:         ${existing.vttDir}`);
+  console.log(`  Transcripts directory: ${existing.transcriptsDir}`);
+  console.log(`  Summary directory:     ${existing.summaryDir}`);
+  console.log();
+}
+async function promptDirectories(rl, existing) {
+  const vttDir = await askQuestion(
+    rl,
+    buildPrompt("VTT directory", existing?.vttDir)
+  );
+  const transcriptsDir = await askQuestion(
+    rl,
+    buildPrompt("Transcripts directory", existing?.transcriptsDir)
+  );
+  const summaryDir = await askQuestion(
+    rl,
+    buildPrompt("Summary directory", existing?.summaryDir)
+  );
+  return {
+    vttDir: vttDir || existing?.vttDir || "",
+    transcriptsDir: transcriptsDir || existing?.transcriptsDir || "",
+    summaryDir: summaryDir || existing?.summaryDir || ""
+  };
+}
+function validateDirectories(transcript) {
+  if (!transcript.vttDir || !transcript.transcriptsDir || !transcript.summaryDir) {
+    console.error("\nError: All directories must be specified.");
+    process.exit(1);
+  }
+}
 async function configure() {
   const rl = createReadlineInterface();
   const config = loadConfig();
+  const existing = config.transcript;
   console.log("Configure transcript directories\n");
-  if (config.transcript) {
-    console.log("Current configuration:");
-    console.log(`  VTT directory:         ${config.transcript.vttDir}`);
-    console.log(`  Transcripts directory: ${config.transcript.transcriptsDir}`);
-    console.log(`  Summary directory:     ${config.transcript.summaryDir}`);
-    console.log();
-  }
+  if (existing) printExisting(existing);
   try {
-    const vttDir = await askQuestion(
-      rl,
-      `VTT directory${config.transcript?.vttDir ? ` [${config.transcript.vttDir}]` : ""}: `
-    );
-    const transcriptsDir = await askQuestion(
-      rl,
-      `Transcripts directory${config.transcript?.transcriptsDir ? ` [${config.transcript.transcriptsDir}]` : ""}: `
-    );
-    const summaryDir = await askQuestion(
-      rl,
-      `Summary directory${config.transcript?.summaryDir ? ` [${config.transcript.summaryDir}]` : ""}: `
-    );
+    const transcript = await promptDirectories(rl, existing);
     rl.close();
-    const newConfig = {
-      ...config,
-      transcript: {
-        vttDir: vttDir || config.transcript?.vttDir || "",
-        transcriptsDir: transcriptsDir || config.transcript?.transcriptsDir || "",
-        summaryDir: summaryDir || config.transcript?.summaryDir || ""
-      }
-    };
-    if (!newConfig.transcript.vttDir || !newConfig.transcript.transcriptsDir || !newConfig.transcript.summaryDir) {
-      console.error("\nError: All directories must be specified.");
-      process.exit(1);
-    }
-    saveConfig(newConfig);
+    validateDirectories(transcript);
+    saveConfig({ ...config, transcript });
     console.log("\nConfiguration saved.");
   } catch (error) {
     rl.close();
@@ -3511,8 +3734,7 @@ async function configure() {
 }
 
 // src/commands/transcript/format/index.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
-import { basename as basename4, dirname as dirname11, join as join16 } from "path";
+import { existsSync as existsSync16 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
 import { dirname as dirname10, join as join15 } from "path";
@@ -3520,6 +3742,24 @@ import { dirname as dirname10, join as join15 } from "path";
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
 import { renameSync } from "fs";
 import { join as join14 } from "path";
+async function resolveDate(rl, choice) {
+  if (choice === "1") return getDatePrefix(0);
+  if (choice === "2") return getDatePrefix(-1);
+  if (choice === "3") {
+    const customDate = await askQuestion(rl, "Enter date (YYYY-MM-DD): ");
+    if (/^\d{4}-\d{2}-\d{2}$/.test(customDate)) return customDate;
+    console.log("Invalid date format. Cancelling.");
+    return null;
+  }
+  console.log("Cancelled.");
+  return null;
+}
+function renameWithPrefix(vttDir, vttFile, prefix) {
+  const newFilename = `${prefix}.${vttFile}`;
+  renameSync(join14(vttDir, vttFile), join14(vttDir, newFilename));
+  console.log(`Renamed to: ${newFilename}`);
+  return newFilename;
+}
 async function promptForDateFix(vttFile, vttDir) {
   const rl = createReadlineInterface();
   console.log(
@@ -3533,40 +3773,9 @@ Error: File "${vttFile}" does not start with YYYY-MM-DD format.`
   console.log("  4. Cancel");
   try {
     const choice = await askQuestion(rl, "\nSelect an option (1/2/3/4): ");
-    let newPrefix = null;
-    switch (choice) {
-      case "1":
-        newPrefix = getDatePrefix(0);
-        break;
-      case "2":
-        newPrefix = getDatePrefix(-1);
-        break;
-      case "3": {
-        const customDate = await askQuestion(rl, "Enter date (YYYY-MM-DD): ");
-        if (/^\d{4}-\d{2}-\d{2}$/.test(customDate)) {
-          newPrefix = customDate;
-        } else {
-          console.log("Invalid date format. Cancelling.");
-          rl.close();
-          return null;
-        }
-        break;
-      }
-      default:
-        console.log("Cancelled.");
-        rl.close();
-        return null;
-    }
+    const prefix = await resolveDate(rl, choice);
     rl.close();
-    if (newPrefix) {
-      const newFilename = `${newPrefix}.${vttFile}`;
-      const oldPath = join14(vttDir, vttFile);
-      const newPath = join14(vttDir, newFilename);
-      renameSync(oldPath, newPath);
-      console.log(`Renamed to: ${newFilename}`);
-      return newFilename;
-    }
-    return null;
+    return prefix ? renameWithPrefix(vttDir, vttFile, prefix) : null;
   } catch (error) {
     rl.close();
     throw error;
@@ -3598,6 +3807,10 @@ async function fixInvalidDatePrefixes(vttFiles) {
   return vttFiles.filter((f) => f.absolutePath !== "");
 }
 
+// src/commands/transcript/format/processVttFile/index.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { basename as basename4, dirname as dirname11, join as join16 } from "path";
+
 // src/commands/transcript/cleanText.ts
 function cleanText(text) {
   const words = text.split(/\s+/);
@@ -3619,59 +3832,81 @@ function cleanText(text) {
   return cleaned.join(" ").replace(/\s+/g, " ").trim();
 }
 
-// src/commands/transcript/format/parseVtt/deduplicateCues.ts
+// src/commands/transcript/format/parseVtt/deduplicateCues/removeSubstringDuplicates.ts
+function normalizeText(text) {
+  return text.toLowerCase().trim();
+}
+function checkSubstringRelation(textI, textJ) {
+  if (textI.includes(textJ) && textI.length > textJ.length)
+    return "i-contains-j";
+  if (textJ.includes(textI) && textJ.length > textI.length)
+    return "j-contains-i";
+  return null;
+}
+function isNearby(a, b) {
+  return b.startMs - a.endMs <= 1e4;
+}
+function comparePair(cueI, cueJ) {
+  if (cueI.speaker !== cueJ.speaker) return null;
+  const relation = checkSubstringRelation(
+    normalizeText(cueI.text),
+    normalizeText(cueJ.text)
+  );
+  if (relation === "i-contains-j") return "remove-j";
+  if (relation === "j-contains-i") return "remove-i";
+  return null;
+}
+function scanForward(cues, i, toRemove) {
+  for (let j = i + 1; j < cues.length; j++) {
+    if (toRemove.has(j)) continue;
+    if (!isNearby(cues[i], cues[j])) break;
+    const action = comparePair(cues[i], cues[j]);
+    if (action === "remove-j") toRemove.add(j);
+    else if (action === "remove-i") return true;
+  }
+  return false;
+}
 function removeSubstringDuplicates(cues) {
   const toRemove = /* @__PURE__ */ new Set();
   for (let i = 0; i < cues.length; i++) {
     if (toRemove.has(i)) continue;
-    for (let j = i + 1; j < cues.length; j++) {
-      if (toRemove.has(j)) continue;
-      if (cues[j].startMs - cues[i].endMs > 1e4) break;
-      if (cues[i].speaker !== cues[j].speaker) continue;
-      const textI = cues[i].text.toLowerCase().trim();
-      const textJ = cues[j].text.toLowerCase().trim();
-      if (textI.includes(textJ) && textI.length > textJ.length) {
-        toRemove.add(j);
-      } else if (textJ.includes(textI) && textJ.length > textI.length) {
-        toRemove.add(i);
-        break;
-      }
-    }
+    if (scanForward(cues, i, toRemove)) toRemove.add(i);
   }
   return cues.filter((_, i) => !toRemove.has(i));
 }
+
+// src/commands/transcript/format/parseVtt/deduplicateCues/index.ts
 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;
-    }
+    if (suffix === prefix) return j;
   }
   return 0;
 }
+function joinWithOverlap(currentText, nextText) {
+  const currentWords = currentText.toLowerCase().split(/\s+/);
+  const nextWords = nextText.toLowerCase().split(/\s+/);
+  const overlapIndex = findWordOverlap(currentWords, nextWords);
+  if (overlapIndex > 0) {
+    return `${currentText} ${nextText.split(/\s+/).slice(overlapIndex).join(" ")}`;
+  }
+  return currentText.includes(nextText) ? currentText : `${currentText} ${nextText}`;
+}
+function canMergeCues(current, next2) {
+  return current.speaker === next2.speaker && next2.startMs <= current.endMs + 500;
+}
 function mergeOverlappingCues(cues) {
   if (cues.length === 0) return [];
   const result = [];
   let current = { ...cues[0] };
   for (let i = 1; i < cues.length; i++) {
-    const next2 = cues[i];
-    const overlaps = next2.startMs <= current.endMs + 500;
-    const sameSpeaker = current.speaker === next2.speaker;
-    if (sameSpeaker && overlaps) {
-      const currentWords = current.text.toLowerCase().split(/\s+/);
-      const nextWords = next2.text.toLowerCase().split(/\s+/);
-      const overlapIndex = findWordOverlap(currentWords, nextWords);
-      if (overlapIndex > 0) {
-        const nextOriginalWords = next2.text.split(/\s+/);
-        current.text = `${current.text} ${nextOriginalWords.slice(overlapIndex).join(" ")}`;
-      } else if (!current.text.includes(next2.text)) {
-        current.text = `${current.text} ${next2.text}`;
-      }
-      current.endMs = Math.max(current.endMs, next2.endMs);
+    if (canMergeCues(current, cues[i])) {
+      current.text = joinWithOverlap(current.text, cues[i].text);
+      current.endMs = Math.max(current.endMs, cues[i].endMs);
     } else {
       result.push(current);
-      current = { ...next2 };
+      current = { ...cues[i] };
     }
   }
   result.push(current);
@@ -3689,59 +3924,76 @@ function deduplicateCues(cues) {
 }
 
 // src/commands/transcript/format/parseVtt/index.ts
+function parseHMS(h, m, s) {
+  return Number.parseInt(h, 10) * 3600 + Number.parseInt(m, 10) * 60 + Number.parseFloat(s);
+}
+function parseMS(m, s) {
+  return Number.parseInt(m, 10) * 60 + Number.parseFloat(s);
+}
+function toSeconds(parts) {
+  if (parts.length === 3) return parseHMS(parts[0], parts[1], parts[2]);
+  if (parts.length === 2) return parseMS(parts[0], parts[1]);
+  return 0;
+}
 function parseTimestamp(ts8) {
-  const parts = ts8.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);
+  return Math.round(toSeconds(ts8.split(":")) * 1e3);
+}
+function extractSpeaker(fullText) {
+  const match = fullText.match(/^<v\s+([^>]+)>/);
+  if (!match) return { speaker: null, text: fullText };
+  return {
+    speaker: match[1],
+    text: fullText.replace(/<v\s+[^>]+>/, "").trim()
+  };
+}
+function isTextLine(line) {
+  return !!line.trim() && !line.includes("-->");
+}
+function scanTextLines(lines, start) {
+  let i = start;
+  while (i < lines.length && isTextLine(lines[i])) i++;
+  return { texts: lines.slice(start, i).map((l) => l.trim()), end: i };
+}
+function collectTextLines(lines, startIndex) {
+  const { texts, end } = scanTextLines(lines, startIndex);
+  return { text: texts.join(" "), nextIndex: end };
+}
+function parseTimestampLine(line) {
+  const [startStr, endStr] = line.trim().split("-->").map((s) => s.trim());
+  return { startMs: parseTimestamp(startStr), endMs: parseTimestamp(endStr) };
+}
+function buildCue(startMs, endMs, fullText) {
+  const { speaker, text } = extractSpeaker(fullText);
+  return text ? { startMs, endMs, speaker, text } : null;
+}
+function parseCueLine(lines, i) {
+  const { startMs, endMs } = parseTimestampLine(lines[i]);
+  const { text, nextIndex } = collectTextLines(lines, i + 1);
+  return { cue: buildCue(startMs, endMs, text), nextIndex };
+}
+function isCueSeparator(line) {
+  return line.trim().includes("-->");
+}
+function skipHeader(lines) {
+  let i = 0;
+  while (i < lines.length && !isCueSeparator(lines[i])) i++;
+  return i;
+}
+function processLine(cues, lines, i) {
+  if (!isCueSeparator(lines[i])) return i + 1;
+  const { cue, nextIndex } = parseCueLine(lines, i);
+  if (cue) cues.push(cue);
+  return nextIndex;
 }
 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++;
-    }
-  }
+  let i = skipHeader(lines);
+  while (i < lines.length) i = processLine(cues, lines, i);
   return cues;
 }
 
-// src/commands/transcript/format/formatChatLog.ts
+// src/commands/transcript/format/processVttFile/formatChatLog.ts
 function cuesToChatMessages(cues) {
   const messages = [];
   for (const cue of cues) {
@@ -3762,74 +4014,125 @@ function formatChatLog(messages) {
   return messages.map((msg) => `${msg.speaker}: ${msg.text}`).join("\n\n");
 }
 
-// src/commands/transcript/format/index.ts
-function processFile(inputPath, outputPath) {
-  console.log(`Reading: ${inputPath}`);
-  const content = readFileSync12(inputPath, "utf-8");
+// src/commands/transcript/format/processVttFile/index.ts
+function toMdFilename(vttFilename) {
+  return `${basename4(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
+}
+function resolveOutputDir(relativeDir, transcriptsDir) {
+  return relativeDir === "." ? transcriptsDir : join16(transcriptsDir, relativeDir);
+}
+function buildOutputPaths(vttFile, transcriptsDir) {
+  const mdFile = toMdFilename(vttFile.filename);
+  const relativeDir = dirname11(vttFile.relativePath);
+  const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
+  const outputPath = join16(outputDir, mdFile);
+  return { outputDir, outputPath, mdFile, relativeDir };
+}
+function logSkipped(relativeDir, mdFile) {
+  console.log(`Skipping (already exists): ${join16(relativeDir, mdFile)}`);
+  return "skipped";
+}
+function ensureDirectory(dir, label) {
+  if (!existsSync15(dir)) {
+    mkdirSync4(dir, { recursive: true });
+    console.log(`Created ${label}: ${dir}`);
+  }
+}
+function processCues(content) {
   const cues = parseVtt(content);
   console.log(`Parsed ${cues.length} cues`);
   const dedupedCues = deduplicateCues(cues);
   console.log(`After deduplication: ${dedupedCues.length} cues`);
+  return { cues, dedupedCues };
+}
+function convertToMessages(dedupedCues) {
   const chatMessages = cuesToChatMessages(dedupedCues);
   console.log(`Consolidated to ${chatMessages.length} chat messages`);
-  const output = formatChatLog(chatMessages);
-  writeFileSync12(outputPath, output, "utf-8");
+  return chatMessages;
+}
+function logReduction(cueCount, messageCount) {
+  console.log(`Reduction: ${cueCount} cues -> ${messageCount} messages
+`);
+}
+function readAndParseCues(inputPath) {
+  console.log(`Reading: ${inputPath}`);
+  return processCues(readFileSync12(inputPath, "utf-8"));
+}
+function writeFormatted(outputPath, content) {
+  writeFileSync12(outputPath, content, "utf-8");
   console.log(`Written: ${outputPath}`);
+}
+function convertVttToMarkdown(inputPath, outputPath) {
+  const { cues, dedupedCues } = readAndParseCues(inputPath);
+  const chatMessages = convertToMessages(dedupedCues);
+  writeFormatted(outputPath, formatChatLog(chatMessages));
+  logReduction(cues.length, chatMessages.length);
+}
+function tryProcessVtt(vttFile, paths) {
+  if (existsSync15(paths.outputPath))
+    return logSkipped(paths.relativeDir, paths.mdFile);
+  convertVttToMarkdown(vttFile.absolutePath, paths.outputPath);
+  return "processed";
+}
+function processVttFile(vttFile, transcriptsDir) {
+  const paths = buildOutputPaths(vttFile, transcriptsDir);
+  ensureDirectory(paths.outputDir, "output directory");
+  return tryProcessVtt(vttFile, paths);
+}
+
+// src/commands/transcript/format/index.ts
+function logSummary(counts) {
   console.log(
-    `Reduction: ${cues.length} cues -> ${chatMessages.length} messages
-`
+    `
+Summary: ${counts.processed} processed, ${counts.skipped} skipped`
   );
 }
-async function format() {
-  const { vttDir, transcriptsDir } = getTranscriptConfig();
-  if (!existsSync15(vttDir)) {
+function processAllFiles(vttFiles, transcriptsDir) {
+  const counts = { processed: 0, skipped: 0 };
+  for (const vttFile of vttFiles) {
+    counts[processVttFile(vttFile, transcriptsDir)]++;
+  }
+  logSummary(counts);
+}
+function requireVttDir(vttDir) {
+  if (!existsSync16(vttDir)) {
     console.error(`VTT directory not found: ${vttDir}`);
     process.exit(1);
   }
-  if (!existsSync15(transcriptsDir)) {
-    mkdirSync4(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}
+}
+function logFoundFiles(files, vttDir) {
+  console.log(`Found ${files.length} VTT file(s) in ${vttDir}
 `);
-  vttFiles = await fixInvalidDatePrefixes(vttFiles);
-  let processed = 0;
-  let skipped = 0;
-  for (const vttFile of vttFiles) {
-    let baseName = basename4(vttFile.filename, ".vtt");
-    baseName = baseName.replace(/\s*Transcription\s*/g, " ").trim();
-    const mdFile = `${baseName}.md`;
-    const relativeDir = dirname11(vttFile.relativePath);
-    const outputDir = relativeDir === "." ? transcriptsDir : join16(transcriptsDir, relativeDir);
-    const outputPath = join16(outputDir, mdFile);
-    if (!existsSync15(outputDir)) {
-      mkdirSync4(outputDir, { recursive: true });
-      console.log(`Created output directory: ${outputDir}`);
-    }
-    if (existsSync15(outputPath)) {
-      console.log(`Skipping (already exists): ${join16(relativeDir, mdFile)}`);
-      skipped++;
-      continue;
-    }
-    processFile(vttFile.absolutePath, outputPath);
-    processed++;
-  }
-  console.log(`
-Summary: ${processed} processed, ${skipped} skipped`);
+}
+function logNoVttFiles() {
+  console.log("No VTT files found in vtt directory.");
+  return null;
+}
+function loadVttFiles(vttDir) {
+  const files = findVttFilesRecursive(vttDir);
+  if (files.length === 0) return logNoVttFiles();
+  logFoundFiles(files, vttDir);
+  return files;
+}
+async function formatLoadedFiles(vttFiles, transcriptsDir) {
+  const fixed2 = await fixInvalidDatePrefixes(vttFiles);
+  processAllFiles(fixed2, transcriptsDir);
+}
+async function format() {
+  const { vttDir, transcriptsDir } = getTranscriptConfig();
+  requireVttDir(vttDir);
+  ensureDirectory(transcriptsDir, "output directory");
+  const vttFiles = loadVttFiles(vttDir);
+  if (vttFiles) await formatLoadedFiles(vttFiles, transcriptsDir);
 }
 
 // src/commands/transcript/summarise/index.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { basename as basename5, dirname as dirname13, join as join18, relative as relative2 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync13,
   renameSync as renameSync2,
@@ -3838,14 +4141,14 @@ import {
 import { dirname as dirname12, join as join17 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk40 from "chalk";
+import chalk41 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk40.red(
+      chalk41.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -3854,7 +4157,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk40.red(
+      chalk41.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -3866,7 +4169,7 @@ function validateStagedContent(filename, content) {
 // src/commands/transcript/summarise/processStagedFile/index.ts
 var STAGING_DIR = join17(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
-  if (!existsSync16(STAGING_DIR)) {
+  if (!existsSync17(STAGING_DIR)) {
     return false;
   }
   const stagedFiles = findMdFilesRecursive(STAGING_DIR);
@@ -3890,7 +4193,7 @@ function processStagedFile() {
   }
   const destPath = join17(summaryDir, matchingTranscript.relativePath);
   const destDir = dirname12(destPath);
-  if (!existsSync16(destDir)) {
+  if (!existsSync17(destDir)) {
     mkdirSync5(destDir, { recursive: true });
   }
   renameSync2(stagedFile.absolutePath, destPath);
@@ -3902,10 +4205,22 @@ function processStagedFile() {
 }
 
 // src/commands/transcript/summarise/index.ts
+function buildRelativeKey(relativePath, baseName) {
+  const relDir = dirname13(relativePath);
+  return relDir === "." ? baseName : join18(relDir, baseName);
+}
+function buildSummaryIndex(summaryDir) {
+  const summaryFiles = findMdFilesRecursive(summaryDir);
+  return new Set(
+    summaryFiles.map(
+      (f) => buildRelativeKey(f.relativePath, basename5(f.filename, ".md"))
+    )
+  );
+}
 function summarise() {
   processStagedFile();
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
-  if (!existsSync17(transcriptsDir)) {
+  if (!existsSync18(transcriptsDir)) {
     console.log("No transcripts directory found.");
     return;
   }
@@ -3914,23 +4229,12 @@ function summarise() {
     console.log("No transcript files found.");
     return;
   }
-  const summaryFiles = findMdFilesRecursive(summaryDir);
-  const summaryRelativePaths = new Set(
-    summaryFiles.map((f) => {
-      const relDir = dirname13(f.relativePath);
-      const baseName = basename5(f.filename, ".md");
-      return relDir === "." ? baseName : join18(relDir, baseName);
-    })
+  const summaryIndex = buildSummaryIndex(summaryDir);
+  const missing = transcriptFiles.filter(
+    (t) => !summaryIndex.has(
+      buildRelativeKey(t.relativePath, getTranscriptBaseName(t.filename))
+    )
   );
-  const missing = [];
-  for (const transcript of transcriptFiles) {
-    const transcriptBaseName = getTranscriptBaseName(transcript.filename);
-    const relDir = dirname13(transcript.relativePath);
-    const fullKey = relDir === "." ? transcriptBaseName : join18(relDir, transcriptBaseName);
-    if (!summaryRelativePaths.has(fullKey)) {
-      missing.push(transcript);
-    }
-  }
   if (missing.length === 0) {
     console.log("All transcripts have summaries.");
     return;
@@ -3997,9 +4301,9 @@ Total: ${lines.length} hardcoded color(s)`);
 
 // src/commands/verify/run/index.ts
 import { spawn as spawn3 } from "child_process";
-import * as path24 from "path";
+import * as path25 from "path";
 
-// src/commands/verify/run/printTaskStatuses.ts
+// src/commands/verify/run/createTimerCallback/printTaskStatuses.ts
 function formatDuration(ms) {
   if (ms < 1e3) {
     return `${ms}ms`;
@@ -4022,55 +4326,96 @@ function printTaskStatuses(tasks) {
   console.log("-------------------\n");
 }
 
-// src/commands/verify/run/index.ts
-async function run(options = {}) {
-  const { timer = false } = options;
-  const result = findPackageJsonWithVerifyScripts(process.cwd());
-  if (!result) {
-    console.log("No package.json with verify:* scripts found");
-    return;
-  }
-  const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path24.dirname(packageJsonPath);
-  console.log(`Running ${verifyScripts.length} verify script(s) in parallel:`);
-  for (const script of verifyScripts) {
-    console.log(`  - ${script}`);
+// src/commands/verify/run/createTimerCallback/index.ts
+function logFailedScripts(failed) {
+  console.error(`
+${failed.length} script(s) failed:`);
+  for (const f of failed) {
+    console.error(`  - ${f.script} (exit code ${f.code})`);
   }
-  const taskStatuses = verifyScripts.map((script) => ({
-    script,
-    startTime: Date.now()
-  }));
-  const results = await Promise.all(
+}
+function createTimerCallback(taskStatuses, index) {
+  return (exitCode) => {
+    taskStatuses[index].endTime = Date.now();
+    taskStatuses[index].code = exitCode;
+    printTaskStatuses(taskStatuses);
+  };
+}
+function initTaskStatuses(scripts) {
+  return scripts.map((script) => ({ script, startTime: Date.now() }));
+}
+
+// src/commands/verify/run/index.ts
+function spawnScript(script, cwd) {
+  return spawn3("npm", ["run", script], { stdio: "inherit", shell: true, cwd });
+}
+function onScriptClose(script, onComplete, resolve) {
+  return (code) => {
+    const exitCode = code ?? 1;
+    onComplete?.(exitCode);
+    resolve({ script, code: exitCode });
+  };
+}
+function runScript2(script, cwd, onComplete) {
+  return new Promise((resolve) => {
+    spawnScript(script, cwd).on(
+      "close",
+      onScriptClose(script, onComplete, resolve)
+    );
+  });
+}
+function runAllScripts(verifyScripts, packageDir, timer) {
+  const taskStatuses = initTaskStatuses(verifyScripts);
+  return Promise.all(
     verifyScripts.map(
-      (script, index) => new Promise((resolve) => {
-        const child = spawn3("npm", ["run", script], {
-          stdio: "inherit",
-          shell: true,
-          cwd: packageDir
-        });
-        child.on("close", (code) => {
-          const exitCode = code ?? 1;
-          if (timer) {
-            taskStatuses[index].endTime = Date.now();
-            taskStatuses[index].code = exitCode;
-            printTaskStatuses(taskStatuses);
-          }
-          resolve({ script, code: exitCode });
-        });
-      })
+      (script, index) => runScript2(
+        script,
+        packageDir,
+        timer ? createTimerCallback(taskStatuses, index) : void 0
+      )
     )
   );
-  const failed = results.filter((r) => r.code !== 0);
-  if (failed.length > 0) {
-    console.error(`
-${failed.length} script(s) failed:`);
-    for (const f of failed) {
-      console.error(`  - ${f.script} (exit code ${f.code})`);
-    }
-    process.exit(1);
+}
+function printScriptList(scripts) {
+  console.log(`Running ${scripts.length} verify script(s) in parallel:`);
+  for (const script of scripts) {
+    console.log(`  - ${script}`);
   }
+}
+function exitIfFailed(failed) {
+  if (failed.length === 0) return;
+  logFailedScripts(failed);
+  process.exit(1);
+}
+function handleResults(results, totalCount) {
+  exitIfFailed(results.filter((r) => r.code !== 0));
   console.log(`
-All ${verifyScripts.length} verify script(s) passed`);
+All ${totalCount} verify script(s) passed`);
+}
+function resolveVerifyScripts() {
+  const result = findPackageJsonWithVerifyScripts(process.cwd());
+  if (!result) {
+    console.log("No package.json with verify:* scripts found");
+    return null;
+  }
+  return result;
+}
+function getPackageDir(found) {
+  return path25.dirname(found.packageJsonPath);
+}
+async function executeVerifyScripts(found, timer) {
+  printScriptList(found.verifyScripts);
+  const results = await runAllScripts(
+    found.verifyScripts,
+    getPackageDir(found),
+    timer
+  );
+  handleResults(results, found.verifyScripts.length);
+}
+async function run(options = {}) {
+  const found = resolveVerifyScripts();
+  if (!found) return;
+  await executeVerifyScripts(found, options.timer ?? false);
 }
 
 // src/commands/registerVerify.ts
@@ -4080,70 +4425,114 @@ function registerVerify(program2) {
   verifyCommand.command("hardcoded-colors").description("Check for hardcoded hex colors in src/").action(hardcodedColors);
 }
 
-// src/commands/run.ts
+// src/commands/run/index.ts
 import { spawn as spawn4 } from "child_process";
-function run2(name, args) {
-  const config = loadConfig();
-  if (!config.run || config.run.length === 0) {
-    console.error("No run configurations found in assist.yml");
-    process.exit(1);
-  }
-  const runConfig = config.run.find((r) => r.name === name);
-  if (!runConfig) {
-    console.error(`No run configuration found with name: ${name}`);
-    console.error("Available configurations:");
-    for (const r of config.run) {
-      console.error(`  - ${r.name}`);
-    }
+
+// src/commands/run/add.ts
+function findAddIndex() {
+  const addIndex = process.argv.indexOf("add");
+  if (addIndex === -1 || addIndex + 2 >= process.argv.length) return -1;
+  return addIndex;
+}
+function extractAddArgs(addIndex) {
+  return {
+    name: process.argv[addIndex + 1],
+    command: process.argv[addIndex + 2],
+    args: process.argv.slice(addIndex + 3)
+  };
+}
+function parseAddArguments() {
+  const addIndex = findAddIndex();
+  return addIndex === -1 ? null : extractAddArgs(addIndex);
+}
+function buildRunEntry(name, command, args) {
+  const entry = {
+    name,
+    command
+  };
+  if (args.length > 0) entry.args = args;
+  return entry;
+}
+function ensureNoDuplicate(configs, name) {
+  if (configs.find((r) => r.name === name)) {
+    console.error(`Run configuration with name "${name}" already exists`);
     process.exit(1);
   }
-  const command = runConfig.command.includes(" ") ? `"${runConfig.command}"` : runConfig.command;
-  const allArgs = [...runConfig.args ?? [], ...args];
-  const quotedArgs = allArgs.map(
-    (arg) => arg.includes(" ") ? `"${arg}"` : arg
-  );
-  const fullCommand = [command, ...quotedArgs].join(" ");
-  const child = spawn4(fullCommand, [], {
-    stdio: "inherit",
-    shell: true
-  });
-  child.on("close", (code) => {
-    process.exit(code ?? 0);
-  });
-  child.on("error", (err) => {
-    console.error(`Failed to execute command: ${err.message}`);
-    process.exit(1);
-  });
 }
-function add() {
-  const addIndex = process.argv.indexOf("add");
-  if (addIndex === -1 || addIndex + 2 >= process.argv.length) {
+function formatDisplay(command, args) {
+  return args.length > 0 ? `${command} ${args.join(" ")}` : command;
+}
+function requireParsedArgs() {
+  const parsed = parseAddArguments();
+  if (!parsed) {
     console.error("Usage: assist run add <name> <command> [args...]");
     process.exit(1);
   }
-  const name = process.argv[addIndex + 1];
-  const command = process.argv[addIndex + 2];
-  const args = process.argv.slice(addIndex + 3);
+  return parsed;
+}
+function getOrInitRunList() {
   const config = loadConfig();
-  if (!config.run) {
-    config.run = [];
-  }
-  const existing = config.run.find((r) => r.name === name);
-  if (existing) {
-    console.error(`Run configuration with name "${name}" already exists`);
-    process.exit(1);
-  }
-  const entry = {
-    name,
-    command
-  };
-  if (args.length > 0) {
-    entry.args = args;
-  }
-  config.run.push(entry);
+  if (!config.run) config.run = [];
+  return { config, runList: config.run };
+}
+function saveNewRunConfig(name, command, args) {
+  const { config, runList } = getOrInitRunList();
+  ensureNoDuplicate(runList, name);
+  runList.push(buildRunEntry(name, command, args));
   saveConfig(config);
-  const display = args.length > 0 ? `${command} ${args.join(" ")}` : command;
-  console.log(`Added run configuration: ${name} -> ${display}`);
+}
+function add() {
+  const { name, command, args } = requireParsedArgs();
+  saveNewRunConfig(name, command, args);
+  console.log(
+    `Added run configuration: ${name} -> ${formatDisplay(command, args)}`
+  );
+}
+
+// src/commands/run/index.ts
+function quoteIfNeeded(arg) {
+  return arg.includes(" ") ? `"${arg}"` : arg;
+}
+function buildCommand(command, configArgs, extraArgs) {
+  const allArgs = [...configArgs, ...extraArgs];
+  return [quoteIfNeeded(command), ...allArgs.map(quoteIfNeeded)].join(" ");
+}
+function printAvailableConfigs(configs) {
+  console.error("Available configurations:");
+  for (const r of configs) {
+    console.error(`  - ${r.name}`);
+  }
+}
+function exitNoRunConfigs() {
+  console.error("No run configurations found in assist.yml");
+  process.exit(1);
+}
+function requireRunConfigs() {
+  const { run: run3 } = loadConfig();
+  if (!run3 || run3.length === 0) return exitNoRunConfigs();
+  return run3;
+}
+function exitWithConfigNotFound(name, configs) {
+  console.error(`No run configuration found with name: ${name}`);
+  printAvailableConfigs(configs);
+  process.exit(1);
+}
+function findRunConfig(name) {
+  const configs = requireRunConfigs();
+  return configs.find((r) => r.name === name) ?? exitWithConfigNotFound(name, configs);
+}
+function onSpawnError(err) {
+  console.error(`Failed to execute command: ${err.message}`);
+  process.exit(1);
+}
+function spawnCommand(fullCommand) {
+  const child = spawn4(fullCommand, [], { stdio: "inherit", shell: true });
+  child.on("close", (code) => process.exit(code ?? 0));
+  child.on("error", onSpawnError);
+}
+function run2(name, args) {
+  const runConfig = findRunConfig(name);
+  spawnCommand(buildCommand(runConfig.command, runConfig.args ?? [], args));
 }
 
 // src/commands/statusLine.ts
@@ -4165,29 +4554,29 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import * as os from "os";
-import * as path27 from "path";
+import * as path28 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs20 from "fs";
-import * as path25 from "path";
-import chalk41 from "chalk";
+import * as fs21 from "fs";
+import * as path26 from "path";
+import chalk42 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase) {
-  const source = path25.join(claudeDir, "CLAUDE.md");
-  const target = path25.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs20.readFileSync(source, "utf-8");
-  if (fs20.existsSync(target)) {
-    const targetContent = fs20.readFileSync(target, "utf-8");
+  const source = path26.join(claudeDir, "CLAUDE.md");
+  const target = path26.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs21.readFileSync(source, "utf-8");
+  if (fs21.existsSync(target)) {
+    const targetContent = fs21.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk41.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk42.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk41.red("Overwrite existing CLAUDE.md?"),
+        chalk42.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -4196,30 +4585,30 @@ async function syncClaudeMd(claudeDir, targetBase) {
       }
     }
   }
-  fs20.copyFileSync(source, target);
+  fs21.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs21 from "fs";
-import * as path26 from "path";
-import chalk42 from "chalk";
+import * as fs22 from "fs";
+import * as path27 from "path";
+import chalk43 from "chalk";
 async function syncSettings(claudeDir, targetBase) {
-  const source = path26.join(claudeDir, "settings.json");
-  const target = path26.join(targetBase, "settings.json");
-  const sourceContent = fs21.readFileSync(source, "utf-8");
+  const source = path27.join(claudeDir, "settings.json");
+  const target = path27.join(targetBase, "settings.json");
+  const sourceContent = fs22.readFileSync(source, "utf-8");
   const normalizedSource = JSON.stringify(JSON.parse(sourceContent), null, 2);
-  if (fs21.existsSync(target)) {
-    const targetContent = fs21.readFileSync(target, "utf-8");
+  if (fs22.existsSync(target)) {
+    const targetContent = fs22.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(JSON.parse(targetContent), null, 2);
     if (normalizedSource !== normalizedTarget) {
       console.log(
-        chalk42.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
+        chalk43.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk42.red("Overwrite existing settings.json?"),
+        chalk43.red("Overwrite existing settings.json?"),
         false
       );
       if (!confirm) {
@@ -4228,27 +4617,27 @@ async function syncSettings(claudeDir, targetBase) {
       }
     }
   }
-  fs21.copyFileSync(source, target);
+  fs22.copyFileSync(source, target);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname4 = path27.dirname(__filename2);
+var __dirname4 = path28.dirname(__filename2);
 async function sync() {
-  const claudeDir = path27.join(__dirname4, "..", "claude");
-  const targetBase = path27.join(os.homedir(), ".claude");
+  const claudeDir = path28.join(__dirname4, "..", "claude");
+  const targetBase = path28.join(os.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase);
   await syncClaudeMd(claudeDir, targetBase);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path27.join(claudeDir, "commands");
-  const targetDir = path27.join(targetBase, "commands");
-  fs22.mkdirSync(targetDir, { recursive: true });
-  const files = fs22.readdirSync(sourceDir);
+  const sourceDir = path28.join(claudeDir, "commands");
+  const targetDir = path28.join(targetBase, "commands");
+  fs23.mkdirSync(targetDir, { recursive: true });
+  const files = fs23.readdirSync(sourceDir);
   for (const file of files) {
-    fs22.copyFileSync(path27.join(sourceDir, file), path27.join(targetDir, file));
+    fs23.copyFileSync(path28.join(sourceDir, file), path28.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);