@staff0rd/assist 0.19.0 → 0.20.0

package/dist/index.js

@@ -91,12 +91,427 @@ function commit(message) {
   }
 }
 
+// src/commands/complexity/cyclomatic.ts
+import chalk2 from "chalk";
+
+// src/commands/complexity/shared.ts
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { minimatch } from "minimatch";
+import ts from "typescript";
+function getNodeName(node) {
+  if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+    return node.name?.text ?? "<anonymous>";
+  }
+  if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) {
+    if (ts.isIdentifier(node.name)) {
+      return node.name.text;
+    }
+    if (ts.isStringLiteral(node.name)) {
+      return node.name.text;
+    }
+    return "<computed>";
+  }
+  if (ts.isArrowFunction(node)) {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+      return parent.name.text;
+    }
+    if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
+      return parent.name.text;
+    }
+    return "<arrow>";
+  }
+  if (ts.isGetAccessor(node) || ts.isSetAccessor(node)) {
+    const prefix = ts.isGetAccessor(node) ? "get " : "set ";
+    if (ts.isIdentifier(node.name)) {
+      return `${prefix}${node.name.text}`;
+    }
+    return `${prefix}<computed>`;
+  }
+  if (ts.isConstructorDeclaration(node)) {
+    return "constructor";
+  }
+  return "<unknown>";
+}
+function createSourceFromFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  return ts.createSourceFile(
+    path.basename(filePath),
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+    filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+}
+function withSourceFiles(pattern2, callback) {
+  const files = findSourceFilesWithPattern(pattern2);
+  if (files.length === 0) {
+    console.log(chalk.yellow("No files found matching pattern"));
+    return void 0;
+  }
+  return callback(files);
+}
+function forEachFunction(files, callback) {
+  for (const file of files) {
+    const sourceFile = createSourceFromFile(file);
+    const visit = (node) => {
+      if (hasFunctionBody(node)) {
+        callback(file, getNodeName(node), node);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+  }
+}
+function findSourceFilesWithPattern(pattern2, baseDir = ".") {
+  const results = [];
+  const extensions = [".ts", ".tsx"];
+  function walk(dir) {
+    if (!fs.existsSync(dir)) {
+      return;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules" && entry.name !== ".git") {
+          walk(fullPath);
+        }
+      } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
+        results.push(fullPath);
+      }
+    }
+  }
+  if (pattern2.includes("*")) {
+    walk(baseDir);
+    return results.filter((f) => minimatch(f, pattern2));
+  }
+  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isFile()) {
+    return [pattern2];
+  }
+  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isDirectory()) {
+    walk(pattern2);
+    return results;
+  }
+  walk(baseDir);
+  return results.filter((f) => minimatch(f, pattern2));
+}
+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;
+}
+function countSloc(content) {
+  let inMultiLineComment = false;
+  let count = 0;
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (inMultiLineComment) {
+      if (trimmed.includes("*/")) {
+        inMultiLineComment = false;
+        const afterComment = trimmed.substring(trimmed.indexOf("*/") + 2);
+        if (afterComment.trim().length > 0) {
+          count++;
+        }
+      }
+      continue;
+    }
+    if (trimmed.startsWith("//")) {
+      continue;
+    }
+    if (trimmed.startsWith("/*")) {
+      if (trimmed.includes("*/")) {
+        const afterComment = trimmed.substring(trimmed.indexOf("*/") + 2);
+        if (afterComment.trim().length > 0) {
+          count++;
+        }
+      } else {
+        inMultiLineComment = true;
+      }
+      continue;
+    }
+    if (trimmed.length > 0) {
+      count++;
+    }
+  }
+  return count;
+}
+function calculateCyclomaticComplexity(node) {
+  let complexity = 1;
+  function visit(n) {
+    switch (n.kind) {
+      case ts.SyntaxKind.IfStatement:
+      case ts.SyntaxKind.ForStatement:
+      case ts.SyntaxKind.ForInStatement:
+      case ts.SyntaxKind.ForOfStatement:
+      case ts.SyntaxKind.WhileStatement:
+      case ts.SyntaxKind.DoStatement:
+      case ts.SyntaxKind.CaseClause:
+      case ts.SyntaxKind.CatchClause:
+      case ts.SyntaxKind.ConditionalExpression:
+        complexity++;
+        break;
+      case ts.SyntaxKind.BinaryExpression: {
+        const binary = n;
+        if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || binary.operatorToken.kind === ts.SyntaxKind.BarBarToken || binary.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+          complexity++;
+        }
+        break;
+      }
+    }
+    ts.forEachChild(n, visit);
+  }
+  ts.forEachChild(node, visit);
+  return complexity;
+}
+function calculateHalstead(node) {
+  const operators = /* @__PURE__ */ new Map();
+  const operands = /* @__PURE__ */ new Map();
+  function addOperator(op) {
+    operators.set(op, (operators.get(op) ?? 0) + 1);
+  }
+  function addOperand(op) {
+    operands.set(op, (operands.get(op) ?? 0) + 1);
+  }
+  function visit(n) {
+    if (ts.isIdentifier(n)) {
+      addOperand(n.text);
+    } else if (ts.isNumericLiteral(n)) {
+      addOperand(n.text);
+    } else if (ts.isStringLiteral(n)) {
+      addOperand(n.text);
+    } else if (ts.isBinaryExpression(n)) {
+      addOperator(n.operatorToken.getText());
+    } else if (ts.isPrefixUnaryExpression(n) || ts.isPostfixUnaryExpression(n)) {
+      addOperator(ts.tokenToString(n.operator) ?? "");
+    } else if (ts.isCallExpression(n)) {
+      addOperator("()");
+    } else if (ts.isPropertyAccessExpression(n)) {
+      addOperator(".");
+    } else if (ts.isElementAccessExpression(n)) {
+      addOperator("[]");
+    } else if (ts.isConditionalExpression(n)) {
+      addOperator("?:");
+    } else if (ts.isReturnStatement(n)) {
+      addOperator("return");
+    } else if (ts.isIfStatement(n)) {
+      addOperator("if");
+    } else if (ts.isForStatement(n) || ts.isForInStatement(n) || ts.isForOfStatement(n)) {
+      addOperator("for");
+    } else if (ts.isWhileStatement(n)) {
+      addOperator("while");
+    } else if (ts.isDoStatement(n)) {
+      addOperator("do");
+    } else if (ts.isSwitchStatement(n)) {
+      addOperator("switch");
+    } else if (ts.isCaseClause(n)) {
+      addOperator("case");
+    } else if (ts.isDefaultClause(n)) {
+      addOperator("default");
+    } else if (ts.isBreakStatement(n)) {
+      addOperator("break");
+    } else if (ts.isContinueStatement(n)) {
+      addOperator("continue");
+    } else if (ts.isThrowStatement(n)) {
+      addOperator("throw");
+    } else if (ts.isTryStatement(n)) {
+      addOperator("try");
+    } else if (ts.isCatchClause(n)) {
+      addOperator("catch");
+    } else if (ts.isNewExpression(n)) {
+      addOperator("new");
+    } else if (ts.isTypeOfExpression(n)) {
+      addOperator("typeof");
+    } else if (ts.isAwaitExpression(n)) {
+      addOperator("await");
+    }
+    ts.forEachChild(n, visit);
+  }
+  ts.forEachChild(node, visit);
+  const n1 = operators.size;
+  const n2 = operands.size;
+  const N1 = Array.from(operators.values()).reduce((a, b) => a + b, 0);
+  const N2 = Array.from(operands.values()).reduce((a, b) => a + b, 0);
+  const vocabulary = n1 + n2;
+  const length = N1 + N2;
+  const volume = length > 0 && vocabulary > 0 ? length * Math.log2(vocabulary) : 0;
+  const difficulty = n2 > 0 ? n1 / 2 * (N2 / n2) : 0;
+  const effort = volume * difficulty;
+  const time = effort / 18;
+  const bugsDelivered = volume / 3e3;
+  return {
+    length,
+    vocabulary,
+    volume,
+    difficulty,
+    effort,
+    time,
+    bugsDelivered
+  };
+}
+
+// src/commands/complexity/cyclomatic.ts
+async function cyclomatic(pattern2 = "**/*.ts", options = {}) {
+  withSourceFiles(pattern2, (files) => {
+    const results = [];
+    let hasViolation = false;
+    forEachFunction(files, (file, name, node) => {
+      const complexity = calculateCyclomaticComplexity(node);
+      results.push({ file, name, complexity });
+      if (options.threshold !== void 0 && complexity > options.threshold) {
+        hasViolation = true;
+      }
+    });
+    results.sort((a, b) => b.complexity - a.complexity);
+    for (const { file, name, complexity } of results) {
+      const exceedsThreshold = options.threshold !== void 0 && complexity > options.threshold;
+      const color = exceedsThreshold ? chalk2.red : chalk2.white;
+      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk2.cyan(complexity)}`);
+    }
+    console.log(
+      chalk2.dim(
+        `
+Analyzed ${results.length} functions across ${files.length} files`
+      )
+    );
+    if (hasViolation) {
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/complexity/halstead.ts
+import chalk3 from "chalk";
+async function halstead(pattern2 = "**/*.ts", options = {}) {
+  withSourceFiles(pattern2, (files) => {
+    const results = [];
+    let hasViolation = false;
+    forEachFunction(files, (file, name, node) => {
+      const metrics = calculateHalstead(node);
+      results.push({ file, name, metrics });
+      if (options.threshold !== void 0 && metrics.volume > options.threshold) {
+        hasViolation = true;
+      }
+    });
+    results.sort((a, b) => b.metrics.effort - a.metrics.effort);
+    for (const { file, name, metrics } of results) {
+      const exceedsThreshold = options.threshold !== void 0 && metrics.volume > options.threshold;
+      const color = exceedsThreshold ? chalk3.red : chalk3.white;
+      console.log(
+        `${color(`${file}:${name}`)} \u2192 volume: ${chalk3.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk3.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk3.magenta(metrics.effort.toFixed(1))}`
+      );
+    }
+    console.log(
+      chalk3.dim(
+        `
+Analyzed ${results.length} functions across ${files.length} files`
+      )
+    );
+    if (hasViolation) {
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/complexity/maintainability.ts
+import fs2 from "fs";
+import chalk4 from "chalk";
+function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, sloc2) {
+  if (halsteadVolume === 0 || sloc2 === 0) {
+    return 100;
+  }
+  const mi = 171 - 5.2 * Math.log(halsteadVolume) - 0.23 * cyclomaticComplexity - 16.2 * Math.log(sloc2);
+  return Math.max(0, Math.min(100, mi));
+}
+async function maintainability(pattern2 = "**/*.ts", options = {}) {
+  withSourceFiles(pattern2, (files) => {
+    const fileMetrics = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const content = fs2.readFileSync(file, "utf-8");
+      fileMetrics.set(file, { sloc: countSloc(content), functions: [] });
+    }
+    forEachFunction(files, (file, _name, node) => {
+      const metrics = fileMetrics.get(file);
+      if (metrics) {
+        const complexity = calculateCyclomaticComplexity(node);
+        const halstead2 = calculateHalstead(node);
+        const mi = calculateMaintainabilityIndex(
+          halstead2.volume,
+          complexity,
+          metrics.sloc
+        );
+        metrics.functions.push(mi);
+      }
+    });
+    const results = [];
+    let hasViolation = false;
+    for (const [file, metrics] of fileMetrics) {
+      if (metrics.functions.length === 0) continue;
+      const avgMaintainability = metrics.functions.reduce((a, b) => a + b, 0) / metrics.functions.length;
+      const minMaintainability = Math.min(...metrics.functions);
+      results.push({ file, avgMaintainability, minMaintainability });
+      if (options.threshold !== void 0 && minMaintainability < options.threshold) {
+        hasViolation = true;
+      }
+    }
+    results.sort((a, b) => a.minMaintainability - b.minMaintainability);
+    for (const { file, avgMaintainability, minMaintainability } of results) {
+      const exceedsThreshold = options.threshold !== void 0 && minMaintainability < options.threshold;
+      const color = exceedsThreshold ? chalk4.red : chalk4.white;
+      console.log(
+        `${color(file)} \u2192 avg: ${chalk4.cyan(avgMaintainability.toFixed(1))}, min: ${chalk4.yellow(minMaintainability.toFixed(1))}`
+      );
+    }
+    console.log(chalk4.dim(`
+Analyzed ${results.length} files`));
+    if (hasViolation) {
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/complexity/sloc.ts
+import fs3 from "fs";
+import chalk5 from "chalk";
+async function sloc(pattern2 = "**/*.ts", options = {}) {
+  withSourceFiles(pattern2, (files) => {
+    const results = [];
+    let hasViolation = false;
+    for (const file of files) {
+      const content = fs3.readFileSync(file, "utf-8");
+      const lines = countSloc(content);
+      results.push({ file, lines });
+      if (options.threshold !== void 0 && lines > options.threshold) {
+        hasViolation = true;
+      }
+    }
+    results.sort((a, b) => b.lines - a.lines);
+    for (const { file, lines } of results) {
+      const exceedsThreshold = options.threshold !== void 0 && lines > options.threshold;
+      const color = exceedsThreshold ? chalk5.red : chalk5.white;
+      console.log(`${color(file)} \u2192 ${chalk5.cyan(lines)} lines`);
+    }
+    const total = results.reduce((sum, r) => sum + r.lines, 0);
+    console.log(
+      chalk5.dim(`
+Total: ${total} lines across ${files.length} files`)
+    );
+    if (hasViolation) {
+      process.exit(1);
+    }
+  });
+}
+
 // src/commands/deploy/init.ts
 import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
-import chalk2 from "chalk";
+import chalk7 from "chalk";
 import enquirer2 from "enquirer";
 
 // src/shared/promptConfirm.ts
@@ -117,7 +532,7 @@ async function promptConfirm(message, initial = true) {
 }
 
 // src/utils/printDiff.ts
-import chalk from "chalk";
+import chalk6 from "chalk";
 import * as diff from "diff";
 function normalizeJson(content) {
   try {
@@ -135,11 +550,11 @@ function printDiff(oldContent, newContent) {
     const lines = change.value.replace(/\n$/, "").split("\n");
     for (const line of lines) {
       if (change.added) {
-        console.log(chalk.green(`+ ${line}`));
+        console.log(chalk6.green(`+ ${line}`));
       } else if (change.removed) {
-        console.log(chalk.red(`- ${line}`));
+        console.log(chalk6.red(`- ${line}`));
       } else {
-        console.log(chalk.dim(`  ${line}`));
+        console.log(chalk6.dim(`  ${line}`));
       }
     }
   }
@@ -170,27 +585,27 @@ async function updateWorkflow(siteId) {
   if (existsSync2(WORKFLOW_PATH)) {
     const oldContent = readFileSync2(WORKFLOW_PATH, "utf-8");
     if (oldContent === newContent) {
-      console.log(chalk2.green("build.yml is already up to date"));
+      console.log(chalk7.green("build.yml is already up to date"));
       return;
     }
-    console.log(chalk2.yellow("\nbuild.yml will be updated:"));
+    console.log(chalk7.yellow("\nbuild.yml will be updated:"));
     console.log();
     printDiff(oldContent, newContent);
-    const confirm = await promptConfirm(chalk2.red("Update build.yml?"));
+    const confirm = await promptConfirm(chalk7.red("Update build.yml?"));
     if (!confirm) {
       console.log("Skipped build.yml update");
       return;
     }
   }
   writeFileSync2(WORKFLOW_PATH, newContent);
-  console.log(chalk2.green(`
+  console.log(chalk7.green(`
 Created ${WORKFLOW_PATH}`));
 }
 async function init() {
-  console.log(chalk2.bold("Initializing Netlify deployment...\n"));
+  console.log(chalk7.bold("Initializing Netlify deployment...\n"));
   const existingSiteId = getExistingSiteId();
   if (existingSiteId) {
-    console.log(chalk2.dim(`Using existing site ID: ${existingSiteId}
+    console.log(chalk7.dim(`Using existing site ID: ${existingSiteId}
 `));
     await updateWorkflow(existingSiteId);
     return;
@@ -202,10 +617,10 @@ async function init() {
     });
   } catch (error) {
     if (error instanceof Error && error.message.includes("command not found")) {
-      console.error(chalk2.red("\nNetlify CLI is not installed.\n"));
+      console.error(chalk7.red("\nNetlify CLI is not installed.\n"));
       const install = await promptConfirm("Would you like to install it now?");
       if (install) {
-        console.log(chalk2.dim("\nInstalling netlify-cli...\n"));
+        console.log(chalk7.dim("\nInstalling netlify-cli...\n"));
         execSync2("npm install -g netlify-cli", { stdio: "inherit" });
         console.log();
         execSync2("netlify sites:create --disable-linking", {
@@ -213,7 +628,7 @@ async function init() {
         });
       } else {
         console.log(
-          chalk2.yellow(
+          chalk7.yellow(
             "\nInstall it manually with: npm install -g netlify-cli\n"
           )
         );
@@ -230,17 +645,17 @@ async function init() {
     validate: (value) => /^[a-f0-9-]+$/i.test(value) || "Invalid site ID format"
   });
   await updateWorkflow(siteId);
-  console.log(chalk2.bold("\nDeployment initialized successfully!"));
+  console.log(chalk7.bold("\nDeployment initialized successfully!"));
   console.log(
-    chalk2.yellow("\nTo complete setup, create a personal access token at:")
+    chalk7.yellow("\nTo complete setup, create a personal access token at:")
   );
   console.log(
-    chalk2.cyan(
+    chalk7.cyan(
       "https://app.netlify.com/user/applications#personal-access-tokens"
     )
   );
   console.log(
-    chalk2.yellow(
+    chalk7.yellow(
       "\nThen add it as NETLIFY_AUTH_TOKEN in your GitHub repository secrets."
     )
   );
@@ -248,7 +663,7 @@ async function init() {
 
 // src/commands/deploy/redirect.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import chalk3 from "chalk";
+import chalk8 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
         window.location.href = \`\${window.location.pathname}/\${window.location.search}\${window.location.hash}\`;
@@ -257,32 +672,32 @@ var TRAILING_SLASH_SCRIPT = `    <script>
 function redirect() {
   const indexPath = "index.html";
   if (!existsSync3(indexPath)) {
-    console.log(chalk3.yellow("No index.html found"));
+    console.log(chalk8.yellow("No index.html found"));
     return;
   }
   const content = readFileSync3(indexPath, "utf-8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
-    console.log(chalk3.dim("Trailing slash script already present"));
+    console.log(chalk8.dim("Trailing slash script already present"));
     return;
   }
   const headCloseIndex = content.indexOf("</head>");
   if (headCloseIndex === -1) {
-    console.log(chalk3.red("Could not find </head> tag in index.html"));
+    console.log(chalk8.red("Could not find </head> tag in index.html"));
     return;
   }
   const newContent = content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT + "\n  " + content.slice(headCloseIndex);
   writeFileSync3(indexPath, newContent);
-  console.log(chalk3.green("Added trailing slash redirect to index.html"));
+  console.log(chalk8.green("Added trailing slash redirect to index.html"));
 }
 
 // src/commands/devlog/list.ts
 import { execSync as execSync4 } from "child_process";
 import { basename as basename2 } from "path";
-import chalk5 from "chalk";
+import chalk10 from "chalk";
 
 // src/commands/devlog/shared.ts
 import { execSync as execSync3 } from "child_process";
-import chalk4 from "chalk";
+import chalk9 from "chalk";
 
 // src/commands/devlog/loadDevlogEntries.ts
 import { readdirSync, readFileSync as readFileSync4 } from "fs";
@@ -343,13 +758,13 @@ function shouldIgnoreCommit(files, ignorePaths) {
 }
 function printCommitsWithFiles(commits, ignore2, verbose) {
   for (const commit2 of commits) {
-    console.log(`  ${chalk4.yellow(commit2.hash)} ${commit2.message}`);
+    console.log(`  ${chalk9.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(`    ${chalk4.dim(file)}`);
+        console.log(`    ${chalk9.dim(file)}`);
       }
     }
   }
@@ -402,12 +817,12 @@ function list(options) {
     isFirst = false;
     const entries = devlogEntries.get(date);
     if (skipDays.has(date)) {
-      console.log(`${chalk5.bold.blue(date)} ${chalk5.dim("skipped")}`);
+      console.log(`${chalk10.bold.blue(date)} ${chalk10.dim("skipped")}`);
     } else if (entries && entries.length > 0) {
-      const entryInfo = entries.map((e) => `${chalk5.green(e.version)} ${e.title}`).join(" | ");
-      console.log(`${chalk5.bold.blue(date)} ${entryInfo}`);
+      const entryInfo = entries.map((e) => `${chalk10.green(e.version)} ${e.title}`).join(" | ");
+      console.log(`${chalk10.bold.blue(date)} ${entryInfo}`);
     } else {
-      console.log(`${chalk5.bold.blue(date)} ${chalk5.red("\u26A0 devlog missing")}`);
+      console.log(`${chalk10.bold.blue(date)} ${chalk10.red("\u26A0 devlog missing")}`);
     }
     printCommitsWithFiles(dateCommits, ignore2, options.verbose ?? false);
   }
@@ -415,7 +830,7 @@ function list(options) {
 
 // src/commands/devlog/next.ts
 import { execSync as execSync6 } from "child_process";
-import chalk6 from "chalk";
+import chalk11 from "chalk";
 
 // src/commands/devlog/getLastVersionInfo.ts
 import { execSync as execSync5 } from "child_process";
@@ -524,43 +939,43 @@ function next(options) {
   const targetDate = dates[0];
   if (!targetDate) {
     if (lastInfo) {
-      console.log(chalk6.dim("No commits after last versioned entry"));
+      console.log(chalk11.dim("No commits after last versioned entry"));
     } else {
-      console.log(chalk6.dim("No commits found"));
+      console.log(chalk11.dim("No commits found"));
     }
     return;
   }
   const commits = commitsByDate.get(targetDate) ?? [];
-  console.log(`${chalk6.bold("name:")} ${repoName}`);
+  console.log(`${chalk11.bold("name:")} ${repoName}`);
   if (config.commit?.conventional && commits.length > 0) {
     const version2 = getVersionAtCommit(commits[0].hash);
     if (version2) {
-      console.log(`${chalk6.bold("version:")} ${stripToMinor(version2)}`);
+      console.log(`${chalk11.bold("version:")} ${stripToMinor(version2)}`);
     } else {
-      console.log(`${chalk6.bold("version:")} ${chalk6.red("unknown")}`);
+      console.log(`${chalk11.bold("version:")} ${chalk11.red("unknown")}`);
     }
   } else if (patchVersion && minorVersion) {
     console.log(
-      `${chalk6.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
+      `${chalk11.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
     );
   } else {
-    console.log(`${chalk6.bold("version:")} v0.1 (initial)`);
+    console.log(`${chalk11.bold("version:")} v0.1 (initial)`);
   }
-  console.log(`${chalk6.bold.blue(targetDate)}`);
+  console.log(`${chalk11.bold.blue(targetDate)}`);
   printCommitsWithFiles(commits, ignore2, options.verbose ?? false);
 }
 
 // src/commands/devlog/skip.ts
-import chalk7 from "chalk";
+import chalk12 from "chalk";
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
-    console.log(chalk7.red("Invalid date format. Use YYYY-MM-DD"));
+    console.log(chalk12.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(chalk7.yellow(`${date} is already in skip list`));
+    console.log(chalk12.yellow(`${date} is already in skip list`));
     return;
   }
   skipDays.push(date);
@@ -573,28 +988,28 @@ function skip(date) {
     }
   };
   saveConfig(config);
-  console.log(chalk7.green(`Added ${date} to skip list`));
+  console.log(chalk12.green(`Added ${date} to skip list`));
 }
 
 // src/commands/devlog/version.ts
-import chalk8 from "chalk";
+import chalk13 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(`${chalk8.bold("name:")} ${name}`);
-  console.log(`${chalk8.bold("last:")} ${lastVersion ?? chalk8.dim("none")}`);
-  console.log(`${chalk8.bold("next:")} ${nextVersion ?? chalk8.dim("none")}`);
+  console.log(`${chalk13.bold("name:")} ${name}`);
+  console.log(`${chalk13.bold("last:")} ${lastVersion ?? chalk13.dim("none")}`);
+  console.log(`${chalk13.bold("next:")} ${nextVersion ?? chalk13.dim("none")}`);
 }
 
 // src/commands/enable-ralph/index.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs4 from "fs";
+import * as path2 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import chalk9 from "chalk";
-var __dirname3 = path.dirname(fileURLToPath2(import.meta.url));
+import chalk14 from "chalk";
+var __dirname3 = path2.dirname(fileURLToPath2(import.meta.url));
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -612,30 +1027,30 @@ function deepMerge(target, source) {
   return result;
 }
 async function enableRalph() {
-  const sourcePath = path.join(
+  const sourcePath = path2.join(
     __dirname3,
     "commands/enable-ralph/settings.local.json"
   );
-  const targetPath = path.join(process.cwd(), ".claude/settings.local.json");
-  const sourceData = JSON.parse(fs.readFileSync(sourcePath, "utf-8"));
-  const targetDir = path.dirname(targetPath);
-  if (!fs.existsSync(targetDir)) {
-    fs.mkdirSync(targetDir, { recursive: true });
+  const targetPath = path2.join(process.cwd(), ".claude/settings.local.json");
+  const sourceData = JSON.parse(fs4.readFileSync(sourcePath, "utf-8"));
+  const targetDir = path2.dirname(targetPath);
+  if (!fs4.existsSync(targetDir)) {
+    fs4.mkdirSync(targetDir, { recursive: true });
   }
   let targetData = {};
   let targetContent = "{}";
-  if (fs.existsSync(targetPath)) {
-    targetContent = fs.readFileSync(targetPath, "utf-8");
+  if (fs4.existsSync(targetPath)) {
+    targetContent = fs4.readFileSync(targetPath, "utf-8");
     targetData = JSON.parse(targetContent);
   }
   const merged = deepMerge(targetData, sourceData);
   const mergedContent = `${JSON.stringify(merged, null, "	")}
 `;
   if (mergedContent === targetContent) {
-    console.log(chalk9.green("settings.local.json already has ralph enabled"));
+    console.log(chalk14.green("settings.local.json already has ralph enabled"));
     return;
   }
-  console.log(chalk9.yellow("\nChanges to settings.local.json:"));
+  console.log(chalk14.yellow("\nChanges to settings.local.json:"));
   console.log();
   printDiff(targetContent, mergedContent);
   const confirm = await promptConfirm("Apply these changes?");
@@ -643,15 +1058,15 @@ async function enableRalph() {
     console.log("Skipped");
     return;
   }
-  fs.writeFileSync(targetPath, mergedContent);
+  fs4.writeFileSync(targetPath, mergedContent);
   console.log(`Updated ${targetPath}`);
 }
 
 // src/commands/verify/init.ts
-import chalk20 from "chalk";
+import chalk25 from "chalk";
 
 // src/shared/promptMultiselect.ts
-import chalk10 from "chalk";
+import chalk15 from "chalk";
 import enquirer3 from "enquirer";
 async function promptMultiselect(message, options) {
   const { selected } = await enquirer3.prompt({
@@ -660,7 +1075,7 @@ async function promptMultiselect(message, options) {
     message,
     choices: options.map((opt) => ({
       name: opt.value,
-      message: `${opt.name} - ${chalk10.dim(opt.description)}`
+      message: `${opt.name} - ${chalk15.dim(opt.description)}`
     })),
     // @ts-expect-error - enquirer types don't include symbols but it's supported
     symbols: {
@@ -674,23 +1089,23 @@ async function promptMultiselect(message, options) {
 }
 
 // src/shared/readPackageJson.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import chalk11 from "chalk";
+import * as fs5 from "fs";
+import * as path3 from "path";
+import chalk16 from "chalk";
 function findPackageJson() {
-  const packageJsonPath = path2.join(process.cwd(), "package.json");
-  if (fs2.existsSync(packageJsonPath)) {
+  const packageJsonPath = path3.join(process.cwd(), "package.json");
+  if (fs5.existsSync(packageJsonPath)) {
     return packageJsonPath;
   }
   return null;
 }
 function readPackageJson(filePath) {
-  return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
 }
 function requirePackageJson() {
   const packageJsonPath = findPackageJson();
   if (!packageJsonPath) {
-    console.error(chalk11.red("No package.json found in current directory"));
+    console.error(chalk16.red("No package.json found in current directory"));
     process.exit(1);
   }
   const pkg = readPackageJson(packageJsonPath);
@@ -699,9 +1114,9 @@ function requirePackageJson() {
 function findPackageJsonWithVerifyScripts(startDir) {
   let currentDir = startDir;
   while (true) {
-    const packageJsonPath = path2.join(currentDir, "package.json");
-    if (fs2.existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = path3.join(currentDir, "package.json");
+    if (fs5.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
       const scripts = packageJson.scripts || {};
       const verifyScripts = Object.keys(scripts).filter(
         (name) => name.startsWith("verify:")
@@ -710,7 +1125,7 @@ function findPackageJsonWithVerifyScripts(startDir) {
         return { packageJsonPath, verifyScripts };
       }
     }
-    const parentDir = path2.dirname(currentDir);
+    const parentDir = path3.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -728,15 +1143,15 @@ var expectedScripts = {
 };
 
 // src/commands/verify/setup/setupBuild.ts
-import chalk13 from "chalk";
+import chalk18 from "chalk";
 
 // src/commands/verify/installPackage.ts
 import { execSync as execSync7 } from "child_process";
-import * as fs3 from "fs";
-import * as path3 from "path";
-import chalk12 from "chalk";
+import * as fs6 from "fs";
+import * as path4 from "path";
+import chalk17 from "chalk";
 function writePackageJson(filePath, pkg) {
-  fs3.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
+  fs6.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
 `);
 }
 function addScript(pkg, name, command) {
@@ -749,36 +1164,36 @@ function addScript(pkg, name, command) {
   };
 }
 function installPackage(name, cwd) {
-  console.log(chalk12.dim(`Installing ${name}...`));
+  console.log(chalk17.dim(`Installing ${name}...`));
   try {
     execSync7(`npm install -D ${name}`, { stdio: "inherit", cwd });
     return true;
   } catch {
-    console.error(chalk12.red(`Failed to install ${name}`));
+    console.error(chalk17.red(`Failed to install ${name}`));
     return false;
   }
 }
 function addToKnipIgnoreBinaries(cwd, binary) {
-  const knipJsonPath = path3.join(cwd, "knip.json");
+  const knipJsonPath = path4.join(cwd, "knip.json");
   try {
     let knipConfig;
-    if (fs3.existsSync(knipJsonPath)) {
-      knipConfig = JSON.parse(fs3.readFileSync(knipJsonPath, "utf-8"));
+    if (fs6.existsSync(knipJsonPath)) {
+      knipConfig = JSON.parse(fs6.readFileSync(knipJsonPath, "utf-8"));
     } else {
       knipConfig = { $schema: "https://unpkg.com/knip@5/schema.json" };
     }
     const ignoreBinaries = knipConfig.ignoreBinaries ?? [];
     if (!ignoreBinaries.includes(binary)) {
       knipConfig.ignoreBinaries = [...ignoreBinaries, binary];
-      fs3.writeFileSync(
+      fs6.writeFileSync(
         knipJsonPath,
         `${JSON.stringify(knipConfig, null, "	")}
 `
       );
-      console.log(chalk12.dim(`Added '${binary}' to knip.json ignoreBinaries`));
+      console.log(chalk17.dim(`Added '${binary}' to knip.json ignoreBinaries`));
     }
   } catch {
-    console.log(chalk12.yellow("Warning: Could not update knip.json"));
+    console.log(chalk17.yellow("Warning: Could not update knip.json"));
   }
 }
 function setupVerifyScript(packageJsonPath, scriptName, command) {
@@ -790,7 +1205,7 @@ function setupVerifyScript(packageJsonPath, scriptName, command) {
 
 // src/commands/verify/setup/setupBuild.ts
 async function setupBuild(packageJsonPath, hasVite, hasTypescript) {
-  console.log(chalk13.blue("\nSetting up build verification..."));
+  console.log(chalk18.blue("\nSetting up build verification..."));
   let command;
   if (hasVite && hasTypescript) {
     command = "tsc -b && vite build --logLevel error";
@@ -799,17 +1214,17 @@ async function setupBuild(packageJsonPath, hasVite, hasTypescript) {
   } else {
     command = "tsc --noEmit";
   }
-  console.log(chalk13.dim(`Using: ${command}`));
+  console.log(chalk18.dim(`Using: ${command}`));
   const pkg = readPackageJson(packageJsonPath);
   writePackageJson(packageJsonPath, addScript(pkg, "verify:build", command));
 }
 
 // src/commands/verify/setup/setupDuplicateCode.ts
-import * as path4 from "path";
-import chalk14 from "chalk";
+import * as path5 from "path";
+import chalk19 from "chalk";
 async function setupDuplicateCode(packageJsonPath) {
-  console.log(chalk14.blue("\nSetting up jscpd..."));
-  const cwd = path4.dirname(packageJsonPath);
+  console.log(chalk19.blue("\nSetting up jscpd..."));
+  const cwd = path5.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   const hasJscpd = !!pkg.dependencies?.jscpd || !!pkg.devDependencies?.jscpd;
   if (!hasJscpd && !installPackage("jscpd", cwd)) {
@@ -823,11 +1238,11 @@ async function setupDuplicateCode(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupHardcodedColors.ts
-import * as path5 from "path";
-import chalk15 from "chalk";
+import * as path6 from "path";
+import chalk20 from "chalk";
 async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
-  console.log(chalk15.blue("\nSetting up hardcoded colors check..."));
-  const cwd = path5.dirname(packageJsonPath);
+  console.log(chalk20.blue("\nSetting up hardcoded colors check..."));
+  const cwd = path6.dirname(packageJsonPath);
   if (!hasOpenColor) {
     installPackage("open-color", cwd);
   }
@@ -840,11 +1255,11 @@ async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
 }
 
 // src/commands/verify/setup/setupKnip.ts
-import * as path6 from "path";
-import chalk16 from "chalk";
+import * as path7 from "path";
+import chalk21 from "chalk";
 async function setupKnip(packageJsonPath) {
-  console.log(chalk16.blue("\nSetting up knip..."));
-  const cwd = path6.dirname(packageJsonPath);
+  console.log(chalk21.blue("\nSetting up knip..."));
+  const cwd = path7.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.knip && !installPackage("knip", cwd)) {
     return;
@@ -857,15 +1272,15 @@ async function setupKnip(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupLint.ts
-import * as path7 from "path";
-import chalk18 from "chalk";
+import * as path8 from "path";
+import chalk23 from "chalk";
 
 // src/commands/lint/init.ts
 import { execSync as execSync9 } from "child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname7, join as join7 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import chalk17 from "chalk";
+import chalk22 from "chalk";
 
 // src/shared/removeEslint.ts
 import { execSync as execSync8 } from "child_process";
@@ -971,10 +1386,10 @@ async function init2() {
     console.log("biome.json already has the correct linter config");
     return;
   }
-  console.log(chalk17.yellow("\n\u26A0\uFE0F  biome.json will be updated:"));
+  console.log(chalk22.yellow("\n\u26A0\uFE0F  biome.json will be updated:"));
   console.log();
   printDiff(oldContent, newContent);
-  const confirm = await promptConfirm(chalk17.red("Update biome.json?"));
+  const confirm = await promptConfirm(chalk22.red("Update biome.json?"));
   if (!confirm) {
     console.log("Skipped biome.json update");
     return;
@@ -985,8 +1400,8 @@ async function init2() {
 
 // src/commands/verify/setup/setupLint.ts
 async function setupLint(packageJsonPath) {
-  console.log(chalk18.blue("\nSetting up biome..."));
-  const cwd = path7.dirname(packageJsonPath);
+  console.log(chalk23.blue("\nSetting up biome..."));
+  const cwd = path8.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.["@biomejs/biome"]) {
     if (!installPackage("@biomejs/biome", cwd)) {
@@ -1002,11 +1417,11 @@ async function setupLint(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupTest.ts
-import * as path8 from "path";
-import chalk19 from "chalk";
+import * as path9 from "path";
+import chalk24 from "chalk";
 async function setupTest(packageJsonPath) {
-  console.log(chalk19.blue("\nSetting up vitest..."));
-  const cwd = path8.dirname(packageJsonPath);
+  console.log(chalk24.blue("\nSetting up vitest..."));
+  const cwd = path9.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.vitest && !installPackage("vitest", cwd)) {
     return;
@@ -1148,16 +1563,16 @@ async function init3() {
   const setup = detectExistingSetup(pkg);
   const availableOptions = getAvailableOptions(setup);
   if (availableOptions.length === 0) {
-    console.log(chalk20.green("All verify scripts are already configured!"));
+    console.log(chalk25.green("All verify scripts are already configured!"));
     return;
   }
-  console.log(chalk20.bold("Available verify scripts to add:\n"));
+  console.log(chalk25.bold("Available verify scripts to add:\n"));
   const selected = await promptMultiselect(
     "Select verify scripts to add:",
     availableOptions
   );
   if (selected.length === 0) {
-    console.log(chalk20.yellow("No scripts selected"));
+    console.log(chalk25.yellow("No scripts selected"));
     return;
   }
   for (const choice of selected) {
@@ -1182,43 +1597,43 @@ async function init3() {
         break;
     }
   }
-  console.log(chalk20.green(`
+  console.log(chalk25.green(`
 Added ${selected.length} verify script(s):`));
   for (const choice of selected) {
-    console.log(chalk20.green(`  - verify:${choice}`));
+    console.log(chalk25.green(`  - verify:${choice}`));
   }
-  console.log(chalk20.dim("\nRun 'assist verify' to run all verify scripts"));
+  console.log(chalk25.dim("\nRun 'assist verify' to run all verify scripts"));
 }
 
 // src/commands/vscode/init.ts
-import * as fs5 from "fs";
-import * as path10 from "path";
-import chalk22 from "chalk";
+import * as fs8 from "fs";
+import * as path11 from "path";
+import chalk27 from "chalk";
 
 // src/commands/vscode/createLaunchJson.ts
-import * as fs4 from "fs";
-import * as path9 from "path";
-import chalk21 from "chalk";
+import * as fs7 from "fs";
+import * as path10 from "path";
+import chalk26 from "chalk";
 function ensureVscodeFolder() {
-  const vscodeDir = path9.join(process.cwd(), ".vscode");
-  if (!fs4.existsSync(vscodeDir)) {
-    fs4.mkdirSync(vscodeDir);
-    console.log(chalk21.dim("Created .vscode folder"));
+  const vscodeDir = path10.join(process.cwd(), ".vscode");
+  if (!fs7.existsSync(vscodeDir)) {
+    fs7.mkdirSync(vscodeDir);
+    console.log(chalk26.dim("Created .vscode folder"));
   }
 }
 function removeVscodeFromGitignore() {
-  const gitignorePath = path9.join(process.cwd(), ".gitignore");
-  if (!fs4.existsSync(gitignorePath)) {
+  const gitignorePath = path10.join(process.cwd(), ".gitignore");
+  if (!fs7.existsSync(gitignorePath)) {
     return;
   }
-  const content = fs4.readFileSync(gitignorePath, "utf-8");
+  const content = fs7.readFileSync(gitignorePath, "utf-8");
   const lines = content.split("\n");
   const filteredLines = lines.filter(
     (line) => !line.trim().toLowerCase().includes(".vscode")
   );
   if (filteredLines.length !== lines.length) {
-    fs4.writeFileSync(gitignorePath, filteredLines.join("\n"));
-    console.log(chalk21.dim("Removed .vscode references from .gitignore"));
+    fs7.writeFileSync(gitignorePath, filteredLines.join("\n"));
+    console.log(chalk26.dim("Removed .vscode references from .gitignore"));
   }
 }
 function createLaunchJson() {
@@ -1233,10 +1648,10 @@ function createLaunchJson() {
       }
     ]
   };
-  const launchPath = path9.join(process.cwd(), ".vscode", "launch.json");
-  fs4.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
+  const launchPath = path10.join(process.cwd(), ".vscode", "launch.json");
+  fs7.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
 `);
-  console.log(chalk21.green("Created .vscode/launch.json"));
+  console.log(chalk26.green("Created .vscode/launch.json"));
 }
 function createSettingsJson() {
   const settings = {
@@ -1246,31 +1661,31 @@ function createSettingsJson() {
       "source.organizeImports.biome": "explicit"
     }
   };
-  const settingsPath = path9.join(process.cwd(), ".vscode", "settings.json");
-  fs4.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
+  const settingsPath = path10.join(process.cwd(), ".vscode", "settings.json");
+  fs7.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
 `);
-  console.log(chalk21.green("Created .vscode/settings.json"));
+  console.log(chalk26.green("Created .vscode/settings.json"));
 }
 function createExtensionsJson() {
   const extensions = {
     recommendations: ["biomejs.biome"]
   };
-  const extensionsPath = path9.join(process.cwd(), ".vscode", "extensions.json");
-  fs4.writeFileSync(
+  const extensionsPath = path10.join(process.cwd(), ".vscode", "extensions.json");
+  fs7.writeFileSync(
     extensionsPath,
     `${JSON.stringify(extensions, null, "	")}
 `
   );
-  console.log(chalk21.green("Created .vscode/extensions.json"));
+  console.log(chalk26.green("Created .vscode/extensions.json"));
 }
 
 // src/commands/vscode/init.ts
 function detectExistingSetup2(pkg) {
-  const vscodeDir = path10.join(process.cwd(), ".vscode");
+  const vscodeDir = path11.join(process.cwd(), ".vscode");
   return {
-    hasVscodeFolder: fs5.existsSync(vscodeDir),
-    hasLaunchJson: fs5.existsSync(path10.join(vscodeDir, "launch.json")),
-    hasSettingsJson: fs5.existsSync(path10.join(vscodeDir, "settings.json")),
+    hasVscodeFolder: fs8.existsSync(vscodeDir),
+    hasLaunchJson: fs8.existsSync(path11.join(vscodeDir, "launch.json")),
+    hasSettingsJson: fs8.existsSync(path11.join(vscodeDir, "settings.json")),
     hasVite: !!pkg.devDependencies?.vite || !!pkg.dependencies?.vite
   };
 }
@@ -1293,16 +1708,16 @@ async function init4() {
     });
   }
   if (availableOptions.length === 0) {
-    console.log(chalk22.green("VS Code configuration already exists!"));
+    console.log(chalk27.green("VS Code configuration already exists!"));
     return;
   }
-  console.log(chalk22.bold("Available VS Code configurations to add:\n"));
+  console.log(chalk27.bold("Available VS Code configurations to add:\n"));
   const selected = await promptMultiselect(
     "Select configurations to add:",
     availableOptions
   );
   if (selected.length === 0) {
-    console.log(chalk22.yellow("No configurations selected"));
+    console.log(chalk27.yellow("No configurations selected"));
     return;
   }
   removeVscodeFromGitignore();
@@ -1319,7 +1734,7 @@ async function init4() {
     }
   }
   console.log(
-    chalk22.green(`
+    chalk27.green(`
 Added ${selected.length} VS Code configuration(s)`)
   );
 }
@@ -1331,23 +1746,23 @@ async function init5() {
 }
 
 // src/commands/lint/runFileNameCheck.ts
-import fs7 from "fs";
-import path12 from "path";
-import chalk23 from "chalk";
+import fs10 from "fs";
+import path13 from "path";
+import chalk28 from "chalk";
 
 // src/shared/findSourceFiles.ts
-import fs6 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path12 from "path";
 var EXTENSIONS = [".ts", ".tsx"];
 function findSourceFiles(dir, options = {}) {
   const { includeTests = true } = options;
   const results = [];
-  if (!fs6.existsSync(dir)) {
+  if (!fs9.existsSync(dir)) {
     return results;
   }
-  const entries = fs6.readdirSync(dir, { withFileTypes: true });
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path11.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "node_modules") {
       results.push(...findSourceFiles(fullPath, options));
     } else if (entry.isFile() && EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
@@ -1371,10 +1786,10 @@ function checkFileNames() {
   const sourceFiles = findSourceFiles("src");
   const violations = [];
   for (const filePath of sourceFiles) {
-    const fileName = path12.basename(filePath);
+    const fileName = path13.basename(filePath);
     const nameWithoutExt = fileName.replace(/\.(ts|tsx)$/, "");
     if (/^[A-Z]/.test(nameWithoutExt)) {
-      const content = fs7.readFileSync(filePath, "utf-8");
+      const content = fs10.readFileSync(filePath, "utf-8");
       if (!hasClassOrComponent(content)) {
         violations.push({ filePath, fileName });
       }
@@ -1385,16 +1800,16 @@ function checkFileNames() {
 function runFileNameCheck() {
   const violations = checkFileNames();
   if (violations.length > 0) {
-    console.error(chalk23.red("\nFile name check failed:\n"));
+    console.error(chalk28.red("\nFile name check failed:\n"));
     console.error(
-      chalk23.red(
+      chalk28.red(
         "  Files without classes or React components should not start with a capital letter.\n"
       )
     );
     for (const violation of violations) {
-      console.error(chalk23.red(`  ${violation.filePath}`));
+      console.error(chalk28.red(`  ${violation.filePath}`));
       console.error(
-        chalk23.gray(
+        chalk28.gray(
           `    Rename to: ${violation.fileName.charAt(0).toLowerCase()}${violation.fileName.slice(1)}
 `
         )
@@ -1411,20 +1826,20 @@ function runFileNameCheck() {
 }
 
 // src/commands/lint/runImportExtensionCheck.ts
-import fs8 from "fs";
+import fs11 from "fs";
 
 // src/commands/lint/shared.ts
-import chalk24 from "chalk";
+import chalk29 from "chalk";
 function reportViolations(violations, checkName, errorMessage, successMessage) {
   if (violations.length > 0) {
-    console.error(chalk24.red(`
+    console.error(chalk29.red(`
 ${checkName} failed:
 `));
-    console.error(chalk24.red(`  ${errorMessage}
+    console.error(chalk29.red(`  ${errorMessage}
 `));
     for (const violation of violations) {
-      console.error(chalk24.red(`  ${violation.filePath}:${violation.line}`));
-      console.error(chalk24.gray(`    ${violation.content}
+      console.error(chalk29.red(`  ${violation.filePath}:${violation.line}`));
+      console.error(chalk29.gray(`    ${violation.content}
 `));
     }
     return false;
@@ -1437,7 +1852,7 @@ ${checkName} failed:
 
 // src/commands/lint/runImportExtensionCheck.ts
 function checkForImportExtensions(filePath) {
-  const content = fs8.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const violations = [];
   const importExtensionPattern = /from\s+["']\..*\.(js|ts)["']/;
@@ -1471,9 +1886,9 @@ function runImportExtensionCheck() {
 }
 
 // src/commands/lint/runStaticImportCheck.ts
-import fs9 from "fs";
+import fs12 from "fs";
 function checkForDynamicImports(filePath) {
-  const content = fs9.readFileSync(filePath, "utf-8");
+  const content = fs12.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const violations = [];
   const requirePattern = /\brequire\s*\(/;
@@ -1587,19 +2002,19 @@ function detectPlatform() {
 
 // src/commands/notify/showWindowsNotificationFromWsl.ts
 import { spawn } from "child_process";
-import fs10 from "fs";
+import fs13 from "fs";
 import { createRequire } from "module";
-import path13 from "path";
+import path14 from "path";
 var require2 = createRequire(import.meta.url);
 function getSnoreToastPath() {
-  const notifierPath = path13.dirname(require2.resolve("node-notifier"));
-  return path13.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
+  const notifierPath = path14.dirname(require2.resolve("node-notifier"));
+  return path14.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
 }
 function showWindowsNotificationFromWsl(options) {
   const { title, message, sound } = options;
   const snoreToastPath = getSnoreToastPath();
   try {
-    fs10.chmodSync(snoreToastPath, 493);
+    fs13.chmodSync(snoreToastPath, 493);
   } catch {
   }
   const args = ["-t", title, "-m", message];
@@ -1671,7 +2086,7 @@ async function notify() {
 
 // src/commands/prs.ts
 import { execSync as execSync11 } from "child_process";
-import chalk25 from "chalk";
+import chalk30 from "chalk";
 import enquirer4 from "enquirer";
 var PAGE_SIZE = 10;
 async function prs(options) {
@@ -1706,12 +2121,12 @@ async function displayPaginated(pullRequests) {
   let currentPage = 0;
   const getStatus = (pr) => {
     if (pr.state === "MERGED" && pr.mergedAt) {
-      return { label: chalk25.magenta("merged"), date: pr.mergedAt };
+      return { label: chalk30.magenta("merged"), date: pr.mergedAt };
     }
     if (pr.state === "CLOSED" && pr.closedAt) {
-      return { label: chalk25.red("closed"), date: pr.closedAt };
+      return { label: chalk30.red("closed"), date: pr.closedAt };
     }
-    return { label: chalk25.green("opened"), date: pr.createdAt };
+    return { label: chalk30.green("opened"), date: pr.createdAt };
   };
   const displayPage = (page) => {
     const start = page * PAGE_SIZE;
@@ -1727,9 +2142,9 @@ Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
       const formattedDate = new Date(status.date).toISOString().split("T")[0];
       const fileCount = pr.changedFiles.toLocaleString();
       console.log(
-        `${chalk25.cyan(`#${pr.number}`)} ${pr.title} ${chalk25.dim(`(${pr.author.login},`)} ${status.label} ${chalk25.dim(`${formattedDate})`)}`
+        `${chalk30.cyan(`#${pr.number}`)} ${pr.title} ${chalk30.dim(`(${pr.author.login},`)} ${status.label} ${chalk30.dim(`${formattedDate})`)}`
       );
-      console.log(chalk25.dim(`  ${fileCount} files | ${pr.url}`));
+      console.log(chalk30.dim(`  ${fileCount} files | ${pr.url}`));
       console.log();
     }
   };
@@ -1764,21 +2179,21 @@ Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
 
 // src/commands/refactor/check.ts
 import { spawn as spawn2 } from "child_process";
-import * as path14 from "path";
+import * as path15 from "path";
 
 // src/commands/refactor/getViolations.ts
 import { execSync as execSync12 } from "child_process";
-import fs12 from "fs";
-import { minimatch } from "minimatch";
+import fs15 from "fs";
+import { minimatch as minimatch2 } from "minimatch";
 
 // src/commands/refactor/getIgnoredFiles.ts
-import fs11 from "fs";
+import fs14 from "fs";
 var REFACTOR_YML_PATH = "refactor.yml";
 function parseRefactorYml() {
-  if (!fs11.existsSync(REFACTOR_YML_PATH)) {
+  if (!fs14.existsSync(REFACTOR_YML_PATH)) {
     return [];
   }
-  const content = fs11.readFileSync(REFACTOR_YML_PATH, "utf-8");
+  const content = fs14.readFileSync(REFACTOR_YML_PATH, "utf-8");
   const entries = [];
   const lines = content.split("\n");
   let currentEntry = {};
@@ -1807,7 +2222,7 @@ function getIgnoredFiles() {
 }
 
 // src/commands/refactor/logViolations.ts
-import chalk26 from "chalk";
+import chalk31 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -1816,43 +2231,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk26.red(`
+  console.error(chalk31.red(`
 Refactor check failed:
 `));
-  console.error(chalk26.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk31.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk26.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk31.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk26.yellow(
+    chalk31.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk26.gray(`    assist refactor ignore <file>
+  console.error(chalk31.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk26.cyan(`
+    console.error(chalk31.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk26.cyan(
+      chalk31.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk26.cyan(
+      chalk31.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(
-      chalk26.cyan(
+      chalk31.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -1863,7 +2278,7 @@ Refactor check failed:
 
 // src/commands/refactor/getViolations.ts
 function countLines(filePath) {
-  const content = fs12.readFileSync(filePath, "utf-8");
+  const content = fs15.readFileSync(filePath, "utf-8");
   return content.split("\n").length;
 }
 function getGitFiles(options) {
@@ -1892,7 +2307,7 @@ function getViolations(pattern2, options = {}, maxLines = DEFAULT_MAX_LINES) {
   const ignoredFiles = getIgnoredFiles();
   const gitFiles = getGitFiles(options);
   if (pattern2) {
-    sourceFiles = sourceFiles.filter((f) => minimatch(f, pattern2));
+    sourceFiles = sourceFiles.filter((f) => minimatch2(f, pattern2));
   }
   if (gitFiles) {
     sourceFiles = sourceFiles.filter((f) => gitFiles.has(f));
@@ -1915,7 +2330,7 @@ async function runVerifyQuietly() {
     return true;
   }
   const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path14.dirname(packageJsonPath);
+  const packageDir = path15.dirname(packageJsonPath);
   const results = await Promise.all(
     verifyScripts.map(
       (script) => new Promise(
@@ -1968,28 +2383,28 @@ async function check(pattern2, options) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs13 from "fs";
-import chalk27 from "chalk";
+import fs16 from "fs";
+import chalk32 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
-  if (!fs13.existsSync(file)) {
-    console.error(chalk27.red(`Error: File does not exist: ${file}`));
+  if (!fs16.existsSync(file)) {
+    console.error(chalk32.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs13.readFileSync(file, "utf-8");
+  const content = fs16.readFileSync(file, "utf-8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs13.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs13.readFileSync(REFACTOR_YML_PATH2, "utf-8");
-    fs13.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs16.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs16.readFileSync(REFACTOR_YML_PATH2, "utf-8");
+    fs16.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs13.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs16.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk27.green(
+    chalk32.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -2080,31 +2495,31 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs15 from "fs";
+import * as fs18 from "fs";
 import * as os from "os";
-import * as path16 from "path";
+import * as path17 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/commands/sync/syncSettings.ts
-import * as fs14 from "fs";
-import * as path15 from "path";
-import chalk28 from "chalk";
+import * as fs17 from "fs";
+import * as path16 from "path";
+import chalk33 from "chalk";
 async function syncSettings(claudeDir, targetBase) {
-  const source = path15.join(claudeDir, "settings.json");
-  const target = path15.join(targetBase, "settings.json");
-  const sourceContent = fs14.readFileSync(source, "utf-8");
+  const source = path16.join(claudeDir, "settings.json");
+  const target = path16.join(targetBase, "settings.json");
+  const sourceContent = fs17.readFileSync(source, "utf-8");
   const normalizedSource = JSON.stringify(JSON.parse(sourceContent), null, 2);
-  if (fs14.existsSync(target)) {
-    const targetContent = fs14.readFileSync(target, "utf-8");
+  if (fs17.existsSync(target)) {
+    const targetContent = fs17.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(JSON.parse(targetContent), null, 2);
     if (normalizedSource !== normalizedTarget) {
       console.log(
-        chalk28.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
+        chalk33.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk28.red("Overwrite existing settings.json?"),
+        chalk33.red("Overwrite existing settings.json?"),
         false
       );
       if (!confirm) {
@@ -2113,26 +2528,26 @@ async function syncSettings(claudeDir, targetBase) {
       }
     }
   }
-  fs14.copyFileSync(source, target);
+  fs17.copyFileSync(source, target);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename2 = fileURLToPath4(import.meta.url);
-var __dirname5 = path16.dirname(__filename2);
+var __dirname5 = path17.dirname(__filename2);
 async function sync() {
-  const claudeDir = path16.join(__dirname5, "..", "claude");
-  const targetBase = path16.join(os.homedir(), ".claude");
+  const claudeDir = path17.join(__dirname5, "..", "claude");
+  const targetBase = path17.join(os.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path16.join(claudeDir, "commands");
-  const targetDir = path16.join(targetBase, "commands");
-  fs15.mkdirSync(targetDir, { recursive: true });
-  const files = fs15.readdirSync(sourceDir);
+  const sourceDir = path17.join(claudeDir, "commands");
+  const targetDir = path17.join(targetBase, "commands");
+  fs18.mkdirSync(targetDir, { recursive: true });
+  const files = fs18.readdirSync(sourceDir);
   for (const file of files) {
-    fs15.copyFileSync(path16.join(sourceDir, file), path16.join(targetDir, file));
+    fs18.copyFileSync(path17.join(sourceDir, file), path17.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -2173,7 +2588,7 @@ Total: ${lines.length} hardcoded color(s)`);
 
 // src/commands/verify/run.ts
 import { spawn as spawn4 } from "child_process";
-import * as path17 from "path";
+import * as path18 from "path";
 function formatDuration(ms) {
   if (ms < 1e3) {
     return `${ms}ms`;
@@ -2203,7 +2618,7 @@ async function run2(options = {}) {
     return;
   }
   const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path17.dirname(packageJsonPath);
+  const packageDir = path18.dirname(packageJsonPath);
   console.log(`Running ${verifyScripts.length} verify script(s) in parallel:`);
   for (const script of verifyScripts) {
     console.log(`  - ${script}`);
@@ -2292,4 +2707,13 @@ program.command("status-line").description("Format Claude Code status line from
 program.command("notify").description(
   "Show notification from Claude Code hook (reads JSON from stdin)"
 ).action(notify);
+var complexityCommand = program.command("complexity").description("Analyze TypeScript code complexity metrics");
+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(
+  "--threshold <number>",
+  "Min maintainability threshold",
+  Number.parseInt
+).action(maintainability);
+complexityCommand.command("sloc [pattern]").description("Count source lines of code per file").option("--threshold <number>", "Max lines threshold", Number.parseInt).action(sloc);
 program.parse();