@staff0rd/assist 0.42.1 → 0.42.2

package/claude/settings.json

@@ -44,6 +44,6 @@
 			"Skill(transcript-summarise)",
 			"WebFetch(domain:staffordwilliams.com)"
 		],
-		"deny": ["Bash(git commit:*)", "Bash(npm run:*)"]
+		"deny": ["Bash(git commit:*)", "Bash(npm run:*)", "Bash(npx assist:*)"]
 	}
 }

package/dist/index.js

@@ -7,7 +7,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.42.1",
+  version: "0.42.2",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -28,7 +28,7 @@ var package_default = {
     "verify:types": "tsc --noEmit",
     "verify:knip": "knip --no-progress --treat-config-hints-as-errors",
     "verify:duplicate-code": "jscpd --format 'typescript,tsx' --exitCode 1 --ignore '**/*.test.*' -r consoleFull src",
-    "verify:maintainability": "assist complexity maintainability ./src --threshold 50",
+    "verify:maintainability": "assist complexity maintainability ./src --threshold 55",
     "verify:custom-lint": "assist lint"
   },
   keywords: [],
@@ -212,72 +212,159 @@ function commit(message) {
 import chalk3 from "chalk";
 
 // src/commands/complexity/shared.ts
+import fs2 from "fs";
+import path2 from "path";
+import chalk2 from "chalk";
+import ts4 from "typescript";
+
+// src/commands/complexity/findSourceFiles.ts
 import fs from "fs";
 import path from "path";
-import chalk2 from "chalk";
 import { minimatch } from "minimatch";
-import ts3 from "typescript";
+function applyIgnoreGlobs(files) {
+  const { complexity } = loadConfig();
+  return files.filter(
+    (f) => !complexity.ignore.some((glob) => minimatch(f, glob))
+  );
+}
+function walk(dir, results) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+  const extensions = [".ts", ".tsx"];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "node_modules" && entry.name !== ".git") {
+        walk(fullPath, results);
+      }
+    } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
+      results.push(fullPath);
+    }
+  }
+}
+function findSourceFiles(pattern2, baseDir = ".") {
+  const results = [];
+  if (pattern2.includes("*")) {
+    walk(baseDir, results);
+    return applyIgnoreGlobs(results.filter((f) => minimatch(f, pattern2)));
+  }
+  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isFile()) {
+    return [pattern2];
+  }
+  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isDirectory()) {
+    walk(pattern2, results);
+    return applyIgnoreGlobs(results);
+  }
+  walk(baseDir, results);
+  return applyIgnoreGlobs(results.filter((f) => minimatch(f, pattern2)));
+}
 
-// src/commands/complexity/calculateCyclomaticComplexity.ts
+// src/commands/complexity/getNodeName.ts
 import ts from "typescript";
+function getNodeName(node) {
+  if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+    return node.name?.text ?? "<anonymous>";
+  }
+  if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) {
+    if (ts.isIdentifier(node.name)) {
+      return node.name.text;
+    }
+    if (ts.isStringLiteral(node.name)) {
+      return node.name.text;
+    }
+    return "<computed>";
+  }
+  if (ts.isArrowFunction(node)) {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+      return parent.name.text;
+    }
+    if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
+      return parent.name.text;
+    }
+    return "<arrow>";
+  }
+  if (ts.isGetAccessor(node) || ts.isSetAccessor(node)) {
+    const prefix = ts.isGetAccessor(node) ? "get " : "set ";
+    if (ts.isIdentifier(node.name)) {
+      return `${prefix}${node.name.text}`;
+    }
+    return `${prefix}<computed>`;
+  }
+  if (ts.isConstructorDeclaration(node)) {
+    return "constructor";
+  }
+  return "<unknown>";
+}
+function hasFunctionBody(node) {
+  if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isConstructorDeclaration(node)) {
+    return node.body !== void 0;
+  }
+  return false;
+}
+
+// src/commands/complexity/calculateCyclomaticComplexity.ts
+import ts2 from "typescript";
 var complexityKinds = /* @__PURE__ */ new Set([
-  ts.SyntaxKind.IfStatement,
-  ts.SyntaxKind.ForStatement,
-  ts.SyntaxKind.ForInStatement,
-  ts.SyntaxKind.ForOfStatement,
-  ts.SyntaxKind.WhileStatement,
-  ts.SyntaxKind.DoStatement,
-  ts.SyntaxKind.CaseClause,
-  ts.SyntaxKind.CatchClause,
-  ts.SyntaxKind.ConditionalExpression
+  ts2.SyntaxKind.IfStatement,
+  ts2.SyntaxKind.ForStatement,
+  ts2.SyntaxKind.ForInStatement,
+  ts2.SyntaxKind.ForOfStatement,
+  ts2.SyntaxKind.WhileStatement,
+  ts2.SyntaxKind.DoStatement,
+  ts2.SyntaxKind.CaseClause,
+  ts2.SyntaxKind.CatchClause,
+  ts2.SyntaxKind.ConditionalExpression
 ]);
 var logicalOperators = /* @__PURE__ */ new Set([
-  ts.SyntaxKind.AmpersandAmpersandToken,
-  ts.SyntaxKind.BarBarToken,
-  ts.SyntaxKind.QuestionQuestionToken
+  ts2.SyntaxKind.AmpersandAmpersandToken,
+  ts2.SyntaxKind.BarBarToken,
+  ts2.SyntaxKind.QuestionQuestionToken
 ]);
 function calculateCyclomaticComplexity(node) {
   let complexity = 1;
   function visit(n) {
     if (complexityKinds.has(n.kind)) {
       complexity++;
-    } else if (ts.isBinaryExpression(n) && logicalOperators.has(n.operatorToken.kind)) {
+    } else if (ts2.isBinaryExpression(n) && logicalOperators.has(n.operatorToken.kind)) {
       complexity++;
     }
-    ts.forEachChild(n, visit);
+    ts2.forEachChild(n, visit);
   }
-  ts.forEachChild(node, visit);
+  ts2.forEachChild(node, visit);
   return complexity;
 }
 
 // src/commands/complexity/calculateHalstead.ts
-import ts2 from "typescript";
+import ts3 from "typescript";
 var operatorChecks = [
-  (n) => ts2.isBinaryExpression(n) ? n.operatorToken.getText() : void 0,
-  (n) => ts2.isPrefixUnaryExpression(n) || ts2.isPostfixUnaryExpression(n) ? ts2.tokenToString(n.operator) ?? "" : void 0,
-  (n) => ts2.isCallExpression(n) ? "()" : void 0,
-  (n) => ts2.isPropertyAccessExpression(n) ? "." : void 0,
-  (n) => ts2.isElementAccessExpression(n) ? "[]" : void 0,
-  (n) => ts2.isConditionalExpression(n) ? "?:" : void 0,
-  (n) => ts2.isReturnStatement(n) ? "return" : void 0,
-  (n) => ts2.isIfStatement(n) ? "if" : void 0,
-  (n) => ts2.isForStatement(n) || ts2.isForInStatement(n) || ts2.isForOfStatement(n) ? "for" : void 0,
-  (n) => ts2.isWhileStatement(n) ? "while" : void 0,
-  (n) => ts2.isDoStatement(n) ? "do" : void 0,
-  (n) => ts2.isSwitchStatement(n) ? "switch" : void 0,
-  (n) => ts2.isCaseClause(n) ? "case" : void 0,
-  (n) => ts2.isDefaultClause(n) ? "default" : void 0,
-  (n) => ts2.isBreakStatement(n) ? "break" : void 0,
-  (n) => ts2.isContinueStatement(n) ? "continue" : void 0,
-  (n) => ts2.isThrowStatement(n) ? "throw" : void 0,
-  (n) => ts2.isTryStatement(n) ? "try" : void 0,
-  (n) => ts2.isCatchClause(n) ? "catch" : void 0,
-  (n) => ts2.isNewExpression(n) ? "new" : void 0,
-  (n) => ts2.isTypeOfExpression(n) ? "typeof" : void 0,
-  (n) => ts2.isAwaitExpression(n) ? "await" : void 0
+  (n) => ts3.isBinaryExpression(n) ? n.operatorToken.getText() : void 0,
+  (n) => ts3.isPrefixUnaryExpression(n) || ts3.isPostfixUnaryExpression(n) ? ts3.tokenToString(n.operator) ?? "" : void 0,
+  (n) => ts3.isCallExpression(n) ? "()" : void 0,
+  (n) => ts3.isPropertyAccessExpression(n) ? "." : void 0,
+  (n) => ts3.isElementAccessExpression(n) ? "[]" : void 0,
+  (n) => ts3.isConditionalExpression(n) ? "?:" : void 0,
+  (n) => ts3.isReturnStatement(n) ? "return" : void 0,
+  (n) => ts3.isIfStatement(n) ? "if" : void 0,
+  (n) => ts3.isForStatement(n) || ts3.isForInStatement(n) || ts3.isForOfStatement(n) ? "for" : void 0,
+  (n) => ts3.isWhileStatement(n) ? "while" : void 0,
+  (n) => ts3.isDoStatement(n) ? "do" : void 0,
+  (n) => ts3.isSwitchStatement(n) ? "switch" : void 0,
+  (n) => ts3.isCaseClause(n) ? "case" : void 0,
+  (n) => ts3.isDefaultClause(n) ? "default" : void 0,
+  (n) => ts3.isBreakStatement(n) ? "break" : void 0,
+  (n) => ts3.isContinueStatement(n) ? "continue" : void 0,
+  (n) => ts3.isThrowStatement(n) ? "throw" : void 0,
+  (n) => ts3.isTryStatement(n) ? "try" : void 0,
+  (n) => ts3.isCatchClause(n) ? "catch" : void 0,
+  (n) => ts3.isNewExpression(n) ? "new" : void 0,
+  (n) => ts3.isTypeOfExpression(n) ? "typeof" : void 0,
+  (n) => ts3.isAwaitExpression(n) ? "await" : void 0
 ];
 function classifyNode(n, operators, operands) {
-  if (ts2.isIdentifier(n) || ts2.isNumericLiteral(n) || ts2.isStringLiteral(n)) {
+  if (ts3.isIdentifier(n) || ts3.isNumericLiteral(n) || ts3.isStringLiteral(n)) {
     operands.set(n.text, (operands.get(n.text) ?? 0) + 1);
     return;
   }
@@ -314,9 +401,9 @@ function calculateHalstead(node) {
   const operands = /* @__PURE__ */ new Map();
   function visit(n) {
     classifyNode(n, operators, operands);
-    ts2.forEachChild(n, visit);
+    ts3.forEachChild(n, visit);
   }
-  ts2.forEachChild(node, visit);
+  ts3.forEachChild(node, visit);
   return computeHalsteadMetrics(operators, operands);
 }
 
@@ -358,53 +445,18 @@ function countSloc(content) {
 }
 
 // src/commands/complexity/shared.ts
-function getNodeName(node) {
-  if (ts3.isFunctionDeclaration(node) || ts3.isFunctionExpression(node)) {
-    return node.name?.text ?? "<anonymous>";
-  }
-  if (ts3.isMethodDeclaration(node) || ts3.isMethodSignature(node)) {
-    if (ts3.isIdentifier(node.name)) {
-      return node.name.text;
-    }
-    if (ts3.isStringLiteral(node.name)) {
-      return node.name.text;
-    }
-    return "<computed>";
-  }
-  if (ts3.isArrowFunction(node)) {
-    const parent = node.parent;
-    if (ts3.isVariableDeclaration(parent) && ts3.isIdentifier(parent.name)) {
-      return parent.name.text;
-    }
-    if (ts3.isPropertyAssignment(parent) && ts3.isIdentifier(parent.name)) {
-      return parent.name.text;
-    }
-    return "<arrow>";
-  }
-  if (ts3.isGetAccessor(node) || ts3.isSetAccessor(node)) {
-    const prefix = ts3.isGetAccessor(node) ? "get " : "set ";
-    if (ts3.isIdentifier(node.name)) {
-      return `${prefix}${node.name.text}`;
-    }
-    return `${prefix}<computed>`;
-  }
-  if (ts3.isConstructorDeclaration(node)) {
-    return "constructor";
-  }
-  return "<unknown>";
-}
 function createSourceFromFile(filePath) {
-  const content = fs.readFileSync(filePath, "utf-8");
-  return ts3.createSourceFile(
-    path.basename(filePath),
+  const content = fs2.readFileSync(filePath, "utf-8");
+  return ts4.createSourceFile(
+    path2.basename(filePath),
     content,
-    ts3.ScriptTarget.Latest,
+    ts4.ScriptTarget.Latest,
     true,
-    filePath.endsWith(".tsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
+    filePath.endsWith(".tsx") ? ts4.ScriptKind.TSX : ts4.ScriptKind.TS
   );
 }
 function withSourceFiles(pattern2, callback) {
-  const files = findSourceFilesWithPattern(pattern2);
+  const files = findSourceFiles(pattern2);
   if (files.length === 0) {
     console.log(chalk2.yellow("No files found matching pattern"));
     return void 0;
@@ -418,56 +470,11 @@ function forEachFunction(files, callback) {
       if (hasFunctionBody(node)) {
         callback(file, getNodeName(node), node);
       }
-      ts3.forEachChild(node, visit);
+      ts4.forEachChild(node, visit);
     };
     visit(sourceFile);
   }
 }
-function applyIgnoreGlobs(files) {
-  const { complexity } = loadConfig();
-  return files.filter(
-    (f) => !complexity.ignore.some((glob) => minimatch(f, glob))
-  );
-}
-function findSourceFilesWithPattern(pattern2, baseDir = ".") {
-  const results = [];
-  const extensions = [".ts", ".tsx"];
-  function walk(dir) {
-    if (!fs.existsSync(dir)) {
-      return;
-    }
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name !== "node_modules" && entry.name !== ".git") {
-          walk(fullPath);
-        }
-      } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
-        results.push(fullPath);
-      }
-    }
-  }
-  if (pattern2.includes("*")) {
-    walk(baseDir);
-    return applyIgnoreGlobs(results.filter((f) => minimatch(f, pattern2)));
-  }
-  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isFile()) {
-    return [pattern2];
-  }
-  if (fs.existsSync(pattern2) && fs.statSync(pattern2).isDirectory()) {
-    walk(pattern2);
-    return applyIgnoreGlobs(results);
-  }
-  walk(baseDir);
-  return applyIgnoreGlobs(results.filter((f) => minimatch(f, pattern2)));
-}
-function hasFunctionBody(node) {
-  if (ts3.isFunctionDeclaration(node) || ts3.isFunctionExpression(node) || ts3.isArrowFunction(node) || ts3.isMethodDeclaration(node) || ts3.isGetAccessor(node) || ts3.isSetAccessor(node) || ts3.isConstructorDeclaration(node)) {
-    return node.body !== void 0;
-  }
-  return false;
-}
 
 // src/commands/complexity/cyclomatic.ts
 async function cyclomatic(pattern2 = "**/*.ts", options = {}) {
@@ -533,7 +540,7 @@ Analyzed ${results.length} functions across ${files.length} files`
 }
 
 // src/commands/complexity/maintainability.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import chalk5 from "chalk";
 function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, sloc2) {
   if (halsteadVolume === 0 || sloc2 === 0) {
@@ -546,7 +553,7 @@ 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");
+      const content = fs3.readFileSync(file, "utf-8");
       fileMetrics.set(file, { sloc: countSloc(content), functions: [] });
     }
     forEachFunction(files, (file, _name, node) => {
@@ -585,10 +592,10 @@ async function maintainability(pattern2 = "**/*.ts", options = {}) {
     console.log(chalk5.dim(`
 Analyzed ${results.length} files`));
     if (filtered.length > 0 && threshold !== void 0) {
-      console.log(
+      console.error(
         chalk5.red(
           `
-Fail: ${filtered.length} file(s) below threshold ${threshold}. Maintainability index (0\u2013100) is derived from Halstead volume, cyclomatic complexity, and lines of code.`
+Fail: ${filtered.length} file(s) below threshold ${threshold}. Maintainability index (0\u2013100) is derived from Halstead volume, cyclomatic complexity, and lines of code. Try 'complexity cyclomatic', 'complexity halstead', or 'complexity sloc' to help identify which metric is contributing most. For larger files, start by extracting responsibilities into smaller files.`
         )
       );
       process.exit(1);
@@ -597,14 +604,14 @@ Fail: ${filtered.length} file(s) below threshold ${threshold}. Maintainability i
 }
 
 // src/commands/complexity/sloc.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import chalk6 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
     let hasViolation = false;
     for (const file of files) {
-      const content = fs3.readFileSync(file, "utf-8");
+      const content = fs4.readFileSync(file, "utf-8");
       const lines = countSloc(content);
       results.push({ file, lines });
       if (options.threshold !== void 0 && lines > options.threshold) {
@@ -631,8 +638,8 @@ Total: ${total} lines across ${files.length} files`)
 // src/commands/config/index.ts
 import chalk7 from "chalk";
 import { stringify as stringifyYaml2 } from "yaml";
-function getNestedValue(obj, path19) {
-  const keys = path19.split(".");
+function getNestedValue(obj, path20) {
+  const keys = path20.split(".");
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -642,8 +649,8 @@ function getNestedValue(obj, path19) {
   }
   return current;
 }
-function setNestedValue(obj, path19, value) {
-  const keys = path19.split(".");
+function setNestedValue(obj, path20, value) {
+  const keys = path20.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -670,8 +677,8 @@ function configSet(key, value) {
   const result = assistConfigSchema.safeParse(updated);
   if (!result.success) {
     for (const issue of result.error.issues) {
-      const path19 = issue.path.length > 0 ? issue.path.join(".") : key;
-      console.error(chalk7.red(`${path19}: ${issue.message}`));
+      const path20 = issue.path.length > 0 ? issue.path.join(".") : key;
+      console.error(chalk7.red(`${path20}: ${issue.message}`));
     }
     process.exit(1);
   }
@@ -1221,18 +1228,18 @@ async function promptMultiselect(message, options) {
 }
 
 // src/shared/readPackageJson.ts
-import * as fs4 from "fs";
-import * as path2 from "path";
+import * as fs5 from "fs";
+import * as path3 from "path";
 import chalk17 from "chalk";
 function findPackageJson() {
-  const packageJsonPath = path2.join(process.cwd(), "package.json");
-  if (fs4.existsSync(packageJsonPath)) {
+  const packageJsonPath = path3.join(process.cwd(), "package.json");
+  if (fs5.existsSync(packageJsonPath)) {
     return packageJsonPath;
   }
   return null;
 }
 function readPackageJson(filePath) {
-  return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
 }
 function requirePackageJson() {
   const packageJsonPath = findPackageJson();
@@ -1246,9 +1253,9 @@ function requirePackageJson() {
 function findPackageJsonWithVerifyScripts(startDir) {
   let currentDir = startDir;
   while (true) {
-    const packageJsonPath = path2.join(currentDir, "package.json");
-    if (fs4.existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = path3.join(currentDir, "package.json");
+    if (fs5.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
       const scripts = packageJson.scripts || {};
       const verifyScripts = Object.keys(scripts).filter(
         (name) => name.startsWith("verify:")
@@ -1257,7 +1264,7 @@ function findPackageJsonWithVerifyScripts(startDir) {
         return { packageJsonPath, verifyScripts };
       }
     }
-    const parentDir = path2.dirname(currentDir);
+    const parentDir = path3.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -1279,11 +1286,11 @@ import chalk19 from "chalk";
 
 // src/commands/verify/installPackage.ts
 import { execSync as execSync7 } from "child_process";
-import * as fs5 from "fs";
-import * as path3 from "path";
+import * as fs6 from "fs";
+import * as path4 from "path";
 import chalk18 from "chalk";
 function writePackageJson(filePath, pkg) {
-  fs5.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
+  fs6.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
 `);
 }
 function addScript(pkg, name, command) {
@@ -1306,18 +1313,18 @@ function installPackage(name, cwd) {
   }
 }
 function addToKnipIgnoreBinaries(cwd, binary) {
-  const knipJsonPath = path3.join(cwd, "knip.json");
+  const knipJsonPath = path4.join(cwd, "knip.json");
   try {
     let knipConfig;
-    if (fs5.existsSync(knipJsonPath)) {
-      knipConfig = JSON.parse(fs5.readFileSync(knipJsonPath, "utf-8"));
+    if (fs6.existsSync(knipJsonPath)) {
+      knipConfig = JSON.parse(fs6.readFileSync(knipJsonPath, "utf-8"));
     } else {
       knipConfig = { $schema: "https://unpkg.com/knip@5/schema.json" };
     }
     const ignoreBinaries = knipConfig.ignoreBinaries ?? [];
     if (!ignoreBinaries.includes(binary)) {
       knipConfig.ignoreBinaries = [...ignoreBinaries, binary];
-      fs5.writeFileSync(
+      fs6.writeFileSync(
         knipJsonPath,
         `${JSON.stringify(knipConfig, null, "	")}
 `
@@ -1352,11 +1359,11 @@ async function setupBuild(packageJsonPath, hasVite, hasTypescript) {
 }
 
 // src/commands/verify/setup/setupDuplicateCode.ts
-import * as path4 from "path";
+import * as path5 from "path";
 import chalk20 from "chalk";
 async function setupDuplicateCode(packageJsonPath) {
   console.log(chalk20.blue("\nSetting up jscpd..."));
-  const cwd = path4.dirname(packageJsonPath);
+  const cwd = path5.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   const hasJscpd = !!pkg.dependencies?.jscpd || !!pkg.devDependencies?.jscpd;
   if (!hasJscpd && !installPackage("jscpd", cwd)) {
@@ -1370,11 +1377,11 @@ async function setupDuplicateCode(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupHardcodedColors.ts
-import * as path5 from "path";
+import * as path6 from "path";
 import chalk21 from "chalk";
 async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
   console.log(chalk21.blue("\nSetting up hardcoded colors check..."));
-  const cwd = path5.dirname(packageJsonPath);
+  const cwd = path6.dirname(packageJsonPath);
   if (!hasOpenColor) {
     installPackage("open-color", cwd);
   }
@@ -1387,11 +1394,11 @@ async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
 }
 
 // src/commands/verify/setup/setupKnip.ts
-import * as path6 from "path";
+import * as path7 from "path";
 import chalk22 from "chalk";
 async function setupKnip(packageJsonPath) {
   console.log(chalk22.blue("\nSetting up knip..."));
-  const cwd = path6.dirname(packageJsonPath);
+  const cwd = path7.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.knip && !installPackage("knip", cwd)) {
     return;
@@ -1404,7 +1411,7 @@ async function setupKnip(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupLint.ts
-import * as path7 from "path";
+import * as path8 from "path";
 import chalk24 from "chalk";
 
 // src/commands/lint/init.ts
@@ -1533,7 +1540,7 @@ async function init2() {
 // src/commands/verify/setup/setupLint.ts
 async function setupLint(packageJsonPath) {
   console.log(chalk24.blue("\nSetting up biome..."));
-  const cwd = path7.dirname(packageJsonPath);
+  const cwd = path8.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.["@biomejs/biome"]) {
     if (!installPackage("@biomejs/biome", cwd)) {
@@ -1549,11 +1556,11 @@ async function setupLint(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupTest.ts
-import * as path8 from "path";
+import * as path9 from "path";
 import chalk25 from "chalk";
 async function setupTest(packageJsonPath) {
   console.log(chalk25.blue("\nSetting up vitest..."));
-  const cwd = path8.dirname(packageJsonPath);
+  const cwd = path9.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.vitest && !installPackage("vitest", cwd)) {
     return;
@@ -1738,33 +1745,33 @@ Added ${selected.length} verify script(s):`));
 }
 
 // src/commands/vscode/init.ts
-import * as fs7 from "fs";
-import * as path10 from "path";
+import * as fs8 from "fs";
+import * as path11 from "path";
 import chalk28 from "chalk";
 
 // src/commands/vscode/createLaunchJson.ts
-import * as fs6 from "fs";
-import * as path9 from "path";
+import * as fs7 from "fs";
+import * as path10 from "path";
 import chalk27 from "chalk";
 function ensureVscodeFolder() {
-  const vscodeDir = path9.join(process.cwd(), ".vscode");
-  if (!fs6.existsSync(vscodeDir)) {
-    fs6.mkdirSync(vscodeDir);
+  const vscodeDir = path10.join(process.cwd(), ".vscode");
+  if (!fs7.existsSync(vscodeDir)) {
+    fs7.mkdirSync(vscodeDir);
     console.log(chalk27.dim("Created .vscode folder"));
   }
 }
 function removeVscodeFromGitignore() {
-  const gitignorePath = path9.join(process.cwd(), ".gitignore");
-  if (!fs6.existsSync(gitignorePath)) {
+  const gitignorePath = path10.join(process.cwd(), ".gitignore");
+  if (!fs7.existsSync(gitignorePath)) {
     return;
   }
-  const content = fs6.readFileSync(gitignorePath, "utf-8");
+  const content = fs7.readFileSync(gitignorePath, "utf-8");
   const lines = content.split("\n");
   const filteredLines = lines.filter(
     (line) => !line.trim().toLowerCase().includes(".vscode")
   );
   if (filteredLines.length !== lines.length) {
-    fs6.writeFileSync(gitignorePath, filteredLines.join("\n"));
+    fs7.writeFileSync(gitignorePath, filteredLines.join("\n"));
     console.log(chalk27.dim("Removed .vscode references from .gitignore"));
   }
 }
@@ -1780,8 +1787,8 @@ function createLaunchJson() {
       }
     ]
   };
-  const launchPath = path9.join(process.cwd(), ".vscode", "launch.json");
-  fs6.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
+  const launchPath = path10.join(process.cwd(), ".vscode", "launch.json");
+  fs7.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
 `);
   console.log(chalk27.green("Created .vscode/launch.json"));
 }
@@ -1793,8 +1800,8 @@ function createSettingsJson() {
       "source.organizeImports.biome": "explicit"
     }
   };
-  const settingsPath = path9.join(process.cwd(), ".vscode", "settings.json");
-  fs6.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
+  const settingsPath = path10.join(process.cwd(), ".vscode", "settings.json");
+  fs7.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
 `);
   console.log(chalk27.green("Created .vscode/settings.json"));
 }
@@ -1802,8 +1809,8 @@ function createExtensionsJson() {
   const extensions = {
     recommendations: ["biomejs.biome"]
   };
-  const extensionsPath = path9.join(process.cwd(), ".vscode", "extensions.json");
-  fs6.writeFileSync(
+  const extensionsPath = path10.join(process.cwd(), ".vscode", "extensions.json");
+  fs7.writeFileSync(
     extensionsPath,
     `${JSON.stringify(extensions, null, "	")}
 `
@@ -1813,11 +1820,11 @@ function createExtensionsJson() {
 
 // src/commands/vscode/init.ts
 function detectExistingSetup2(pkg) {
-  const vscodeDir = path10.join(process.cwd(), ".vscode");
+  const vscodeDir = path11.join(process.cwd(), ".vscode");
   return {
-    hasVscodeFolder: fs7.existsSync(vscodeDir),
-    hasLaunchJson: fs7.existsSync(path10.join(vscodeDir, "launch.json")),
-    hasSettingsJson: fs7.existsSync(path10.join(vscodeDir, "settings.json")),
+    hasVscodeFolder: fs8.existsSync(vscodeDir),
+    hasLaunchJson: fs8.existsSync(path11.join(vscodeDir, "launch.json")),
+    hasSettingsJson: fs8.existsSync(path11.join(vscodeDir, "settings.json")),
     hasVite: !!pkg.devDependencies?.vite || !!pkg.dependencies?.vite
   };
 }
@@ -1878,25 +1885,25 @@ async function init5() {
 }
 
 // src/commands/lint/runFileNameCheck.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path13 from "path";
 import chalk29 from "chalk";
 
 // src/shared/findSourceFiles.ts
-import fs8 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path12 from "path";
 var EXTENSIONS = [".ts", ".tsx"];
-function findSourceFiles(dir, options = {}) {
+function findSourceFiles2(dir, options = {}) {
   const { includeTests = true } = options;
   const results = [];
-  if (!fs8.existsSync(dir)) {
+  if (!fs9.existsSync(dir)) {
     return results;
   }
-  const entries = fs8.readdirSync(dir, { withFileTypes: true });
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path11.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "node_modules") {
-      results.push(...findSourceFiles(fullPath, options));
+      results.push(...findSourceFiles2(fullPath, options));
     } else if (entry.isFile() && EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
       if (!includeTests && entry.name.includes(".test.")) {
         continue;
@@ -1915,13 +1922,13 @@ function hasClassOrComponent(content) {
   return classPattern.test(content) || functionComponentPattern.test(content) || arrowComponentPattern.test(content);
 }
 function checkFileNames() {
-  const sourceFiles = findSourceFiles("src");
+  const sourceFiles = findSourceFiles2("src");
   const violations = [];
   for (const filePath of sourceFiles) {
-    const fileName = path12.basename(filePath);
+    const fileName = path13.basename(filePath);
     const nameWithoutExt = fileName.replace(/\.(ts|tsx)$/, "");
     if (/^[A-Z]/.test(nameWithoutExt)) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs10.readFileSync(filePath, "utf-8");
       if (!hasClassOrComponent(content)) {
         violations.push({ filePath, fileName });
       }
@@ -1958,7 +1965,7 @@ function runFileNameCheck() {
 }
 
 // src/commands/lint/runImportExtensionCheck.ts
-import fs10 from "fs";
+import fs11 from "fs";
 
 // src/commands/lint/shared.ts
 import chalk30 from "chalk";
@@ -1984,7 +1991,7 @@ ${checkName} failed:
 
 // src/commands/lint/runImportExtensionCheck.ts
 function checkForImportExtensions(filePath) {
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const violations = [];
   const importExtensionPattern = /from\s+["']\..*\.(js|ts)["']/;
@@ -2001,7 +2008,7 @@ function checkForImportExtensions(filePath) {
   return violations;
 }
 function checkImportExtensions() {
-  const sourceFiles = findSourceFiles("src");
+  const sourceFiles = findSourceFiles2("src");
   const violations = [];
   for (const filePath of sourceFiles) {
     violations.push(...checkForImportExtensions(filePath));
@@ -2018,9 +2025,9 @@ function runImportExtensionCheck() {
 }
 
 // src/commands/lint/runStaticImportCheck.ts
-import fs11 from "fs";
+import fs12 from "fs";
 function checkForDynamicImports(filePath) {
-  const content = fs11.readFileSync(filePath, "utf-8");
+  const content = fs12.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const violations = [];
   const requirePattern = /\brequire\s*\(/;
@@ -2038,7 +2045,7 @@ function checkForDynamicImports(filePath) {
   return violations;
 }
 function checkStaticImports() {
-  const sourceFiles = findSourceFiles("src");
+  const sourceFiles = findSourceFiles2("src");
   const violations = [];
   for (const filePath of sourceFiles) {
     violations.push(...checkForDynamicImports(filePath));
@@ -2134,19 +2141,19 @@ function detectPlatform() {
 
 // src/commands/notify/showWindowsNotificationFromWsl.ts
 import { spawn } from "child_process";
-import fs12 from "fs";
+import fs13 from "fs";
 import { createRequire } from "module";
-import path13 from "path";
+import path14 from "path";
 var require2 = createRequire(import.meta.url);
 function getSnoreToastPath() {
-  const notifierPath = path13.dirname(require2.resolve("node-notifier"));
-  return path13.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
+  const notifierPath = path14.dirname(require2.resolve("node-notifier"));
+  return path14.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
 }
 function showWindowsNotificationFromWsl(options) {
   const { title, message, sound } = options;
   const snoreToastPath = getSnoreToastPath();
   try {
-    fs12.chmodSync(snoreToastPath, 493);
+    fs13.chmodSync(snoreToastPath, 493);
   } catch {
   }
   const args = ["-t", title, "-m", message];
@@ -2347,7 +2354,6 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments.ts
-import { execSync as execSync13 } from "child_process";
 import { existsSync as existsSync12, mkdirSync as mkdirSync3, writeFileSync as writeFileSync11 } from "fs";
 import { join as join11 } from "path";
 import chalk31 from "chalk";
@@ -2358,8 +2364,53 @@ function isClaudeCode() {
   return process.env.CLAUDECODE !== void 0;
 }
 
-// src/commands/prs/fetchThreadIds.ts
+// src/commands/prs/fetchReviewComments.ts
 import { execSync as execSync12 } from "child_process";
+function fetchReviewComments(org, repo, prNumber) {
+  const result = execSync12(
+    `gh api repos/${org}/${repo}/pulls/${prNumber}/reviews`,
+    { encoding: "utf-8" }
+  );
+  if (!result.trim()) return [];
+  const reviews = JSON.parse(result);
+  return reviews.filter((r) => r.body).map(
+    (r) => ({
+      type: "review",
+      id: r.id,
+      user: r.user.login,
+      state: r.state,
+      body: r.body
+    })
+  );
+}
+function fetchLineComments(org, repo, prNumber, threadInfo) {
+  const result = execSync12(
+    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments`,
+    { encoding: "utf-8" }
+  );
+  if (!result.trim()) return [];
+  const comments = JSON.parse(result);
+  return comments.map(
+    (c) => {
+      const threadId = threadInfo.threadMap.get(c.id) ?? "";
+      return {
+        type: "line",
+        id: c.id,
+        threadId,
+        user: c.user.login,
+        path: c.path,
+        line: c.line,
+        body: c.body,
+        diff_hunk: c.diff_hunk,
+        html_url: c.html_url,
+        resolved: threadInfo.resolvedThreadIds.has(threadId)
+      };
+    }
+  );
+}
+
+// src/commands/prs/fetchThreadIds.ts
+import { execSync as execSync13 } from "child_process";
 import { unlinkSync as unlinkSync3, writeFileSync as writeFileSync10 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join10 } from "path";
@@ -2368,7 +2419,7 @@ function fetchThreadIds(org, repo, prNumber) {
   const queryFile = join10(tmpdir2(), `gh-query-${Date.now()}.graphql`);
   writeFileSync10(queryFile, THREAD_QUERY);
   try {
-    const result = execSync12(
+    const result = execSync13(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf-8" }
     );
@@ -2439,48 +2490,6 @@ function writeCommentsCache(prNumber, comments) {
   const cachePath = join11(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync11(cachePath, stringify(cacheData));
 }
-function fetchReviewComments(org, repo, prNumber) {
-  const result = execSync13(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/reviews`,
-    { encoding: "utf-8" }
-  );
-  if (!result.trim()) return [];
-  const reviews = JSON.parse(result);
-  return reviews.filter((r) => r.body).map(
-    (r) => ({
-      type: "review",
-      id: r.id,
-      user: r.user.login,
-      state: r.state,
-      body: r.body
-    })
-  );
-}
-function fetchLineComments(org, repo, prNumber, threadInfo) {
-  const result = execSync13(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments`,
-    { encoding: "utf-8" }
-  );
-  if (!result.trim()) return [];
-  const comments = JSON.parse(result);
-  return comments.map(
-    (c) => {
-      const threadId = threadInfo.threadMap.get(c.id) ?? "";
-      return {
-        type: "line",
-        id: c.id,
-        threadId,
-        user: c.user.login,
-        path: c.path,
-        line: c.line,
-        body: c.body,
-        diff_hunk: c.diff_hunk,
-        html_url: c.html_url,
-        resolved: threadInfo.resolvedThreadIds.has(threadId)
-      };
-    }
-  );
-}
 async function listComments() {
   try {
     const prNumber = getCurrentPrNumber();
@@ -2647,21 +2656,21 @@ function wontfix(commentId, reason) {
 
 // src/commands/refactor/check.ts
 import { spawn as spawn2 } from "child_process";
-import * as path14 from "path";
+import * as path15 from "path";
 
 // src/commands/refactor/getViolations.ts
 import { execSync as execSync16 } from "child_process";
-import fs14 from "fs";
+import fs15 from "fs";
 import { minimatch as minimatch2 } from "minimatch";
 
 // src/commands/refactor/getIgnoredFiles.ts
-import fs13 from "fs";
+import fs14 from "fs";
 var REFACTOR_YML_PATH = "refactor.yml";
 function parseRefactorYml() {
-  if (!fs13.existsSync(REFACTOR_YML_PATH)) {
+  if (!fs14.existsSync(REFACTOR_YML_PATH)) {
     return [];
   }
-  const content = fs13.readFileSync(REFACTOR_YML_PATH, "utf-8");
+  const content = fs14.readFileSync(REFACTOR_YML_PATH, "utf-8");
   const entries = [];
   const lines = content.split("\n");
   let currentEntry = {};
@@ -2746,7 +2755,7 @@ Refactor check failed:
 
 // src/commands/refactor/getViolations.ts
 function countLines(filePath) {
-  const content = fs14.readFileSync(filePath, "utf-8");
+  const content = fs15.readFileSync(filePath, "utf-8");
   return content.split("\n").length;
 }
 function getGitFiles(options) {
@@ -2771,7 +2780,7 @@ function getGitFiles(options) {
   return files;
 }
 function getViolations(pattern2, options = {}, maxLines = DEFAULT_MAX_LINES) {
-  let sourceFiles = findSourceFiles("src", { includeTests: false });
+  let sourceFiles = findSourceFiles2("src", { includeTests: false });
   const ignoredFiles = getIgnoredFiles();
   const gitFiles = getGitFiles(options);
   if (pattern2) {
@@ -2798,7 +2807,7 @@ async function runVerifyQuietly() {
     return true;
   }
   const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path14.dirname(packageJsonPath);
+  const packageDir = path15.dirname(packageJsonPath);
   const results = await Promise.all(
     verifyScripts.map(
       (script) => new Promise(
@@ -2851,25 +2860,25 @@ async function check(pattern2, options) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import chalk34 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
-  if (!fs15.existsSync(file)) {
+  if (!fs16.existsSync(file)) {
     console.error(chalk34.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs15.readFileSync(file, "utf-8");
+  const content = fs16.readFileSync(file, "utf-8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs15.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs15.readFileSync(REFACTOR_YML_PATH2, "utf-8");
-    fs15.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs16.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs16.readFileSync(REFACTOR_YML_PATH2, "utf-8");
+    fs16.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs15.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs16.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
     chalk34.green(
@@ -2963,21 +2972,21 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import * as os from "os";
-import * as path17 from "path";
+import * as path18 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 import chalk35 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase) {
-  const source = path15.join(claudeDir, "CLAUDE.md");
-  const target = path15.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs16.readFileSync(source, "utf-8");
-  if (fs16.existsSync(target)) {
-    const targetContent = fs16.readFileSync(target, "utf-8");
+  const source = path16.join(claudeDir, "CLAUDE.md");
+  const target = path16.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs17.readFileSync(source, "utf-8");
+  if (fs17.existsSync(target)) {
+    const targetContent = fs17.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
         chalk35.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
@@ -2994,21 +3003,21 @@ async function syncClaudeMd(claudeDir, targetBase) {
       }
     }
   }
-  fs16.copyFileSync(source, target);
+  fs17.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 import chalk36 from "chalk";
 async function syncSettings(claudeDir, targetBase) {
-  const source = path16.join(claudeDir, "settings.json");
-  const target = path16.join(targetBase, "settings.json");
-  const sourceContent = fs17.readFileSync(source, "utf-8");
+  const source = path17.join(claudeDir, "settings.json");
+  const target = path17.join(targetBase, "settings.json");
+  const sourceContent = fs18.readFileSync(source, "utf-8");
   const normalizedSource = JSON.stringify(JSON.parse(sourceContent), null, 2);
-  if (fs17.existsSync(target)) {
-    const targetContent = fs17.readFileSync(target, "utf-8");
+  if (fs18.existsSync(target)) {
+    const targetContent = fs18.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(JSON.parse(targetContent), null, 2);
     if (normalizedSource !== normalizedTarget) {
       console.log(
@@ -3026,27 +3035,27 @@ async function syncSettings(claudeDir, targetBase) {
       }
     }
   }
-  fs17.copyFileSync(source, target);
+  fs18.copyFileSync(source, target);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname4 = path17.dirname(__filename2);
+var __dirname4 = path18.dirname(__filename2);
 async function sync() {
-  const claudeDir = path17.join(__dirname4, "..", "claude");
-  const targetBase = path17.join(os.homedir(), ".claude");
+  const claudeDir = path18.join(__dirname4, "..", "claude");
+  const targetBase = path18.join(os.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase);
   await syncClaudeMd(claudeDir, targetBase);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path17.join(claudeDir, "commands");
-  const targetDir = path17.join(targetBase, "commands");
-  fs18.mkdirSync(targetDir, { recursive: true });
-  const files = fs18.readdirSync(sourceDir);
+  const sourceDir = path18.join(claudeDir, "commands");
+  const targetDir = path18.join(targetBase, "commands");
+  fs19.mkdirSync(targetDir, { recursive: true });
+  const files = fs19.readdirSync(sourceDir);
   for (const file of files) {
-    fs18.copyFileSync(path17.join(sourceDir, file), path17.join(targetDir, file));
+    fs19.copyFileSync(path18.join(sourceDir, file), path18.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -3168,58 +3177,7 @@ async function configure() {
 import { existsSync as existsSync16, mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
 import { basename as basename4, dirname as dirname11, join as join17 } from "path";
 
-// src/commands/transcript/parseVtt.ts
-function parseTimestamp(ts4) {
-  const parts = ts4.split(":");
-  let hours = 0;
-  let minutes = 0;
-  let seconds = 0;
-  if (parts.length === 3) {
-    hours = Number.parseInt(parts[0], 10);
-    minutes = Number.parseInt(parts[1], 10);
-    seconds = Number.parseFloat(parts[2]);
-  } else if (parts.length === 2) {
-    minutes = Number.parseInt(parts[0], 10);
-    seconds = Number.parseFloat(parts[1]);
-  }
-  return Math.round((hours * 3600 + minutes * 60 + seconds) * 1e3);
-}
-function parseVtt(content) {
-  const cues = [];
-  const lines = content.split(/\r?\n/);
-  let i = 0;
-  while (i < lines.length && !lines[i].includes("-->")) {
-    i++;
-  }
-  while (i < lines.length) {
-    const line = lines[i].trim();
-    if (line.includes("-->")) {
-      const [startStr, endStr] = line.split("-->").map((s) => s.trim());
-      const startMs = parseTimestamp(startStr);
-      const endMs = parseTimestamp(endStr);
-      const textLines = [];
-      i++;
-      while (i < lines.length && lines[i].trim() && !lines[i].includes("-->")) {
-        textLines.push(lines[i].trim());
-        i++;
-      }
-      const fullText = textLines.join(" ");
-      const speakerMatch = fullText.match(/^<v\s+([^>]+)>/);
-      let speaker = null;
-      let text = fullText;
-      if (speakerMatch) {
-        speaker = speakerMatch[1];
-        text = fullText.replace(/<v\s+[^>]+>/, "").trim();
-      }
-      if (text) {
-        cues.push({ startMs, endMs, speaker, text });
-      }
-    } else {
-      i++;
-    }
-  }
-  return cues;
-}
+// src/commands/transcript/deduplicateCues.ts
 function removeSubstringDuplicates(cues) {
   const toRemove = /* @__PURE__ */ new Set();
   for (let i = 0; i < cues.length; i++) {
@@ -3305,6 +3263,59 @@ function deduplicateCues(cues) {
   }));
 }
 
+// src/commands/transcript/parseVtt.ts
+function parseTimestamp(ts5) {
+  const parts = ts5.split(":");
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  if (parts.length === 3) {
+    hours = Number.parseInt(parts[0], 10);
+    minutes = Number.parseInt(parts[1], 10);
+    seconds = Number.parseFloat(parts[2]);
+  } else if (parts.length === 2) {
+    minutes = Number.parseInt(parts[0], 10);
+    seconds = Number.parseFloat(parts[1]);
+  }
+  return Math.round((hours * 3600 + minutes * 60 + seconds) * 1e3);
+}
+function parseVtt(content) {
+  const cues = [];
+  const lines = content.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length && !lines[i].includes("-->")) {
+    i++;
+  }
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (line.includes("-->")) {
+      const [startStr, endStr] = line.split("-->").map((s) => s.trim());
+      const startMs = parseTimestamp(startStr);
+      const endMs = parseTimestamp(endStr);
+      const textLines = [];
+      i++;
+      while (i < lines.length && lines[i].trim() && !lines[i].includes("-->")) {
+        textLines.push(lines[i].trim());
+        i++;
+      }
+      const fullText = textLines.join(" ");
+      const speakerMatch = fullText.match(/^<v\s+([^>]+)>/);
+      let speaker = null;
+      let text = fullText;
+      if (speakerMatch) {
+        speaker = speakerMatch[1];
+        text = fullText.replace(/<v\s+[^>]+>/, "").trim();
+      }
+      if (text) {
+        cues.push({ startMs, endMs, speaker, text });
+      }
+    } else {
+      i++;
+    }
+  }
+  return cues;
+}
+
 // src/commands/transcript/formatChatLog.ts
 function cuesToChatMessages(cues) {
   const messages = [];
@@ -3618,7 +3629,7 @@ Total: ${lines.length} hardcoded color(s)`);
 
 // src/commands/verify/run.ts
 import { spawn as spawn4 } from "child_process";
-import * as path18 from "path";
+import * as path19 from "path";
 function formatDuration(ms) {
   if (ms < 1e3) {
     return `${ms}ms`;
@@ -3648,7 +3659,7 @@ async function run2(options = {}) {
     return;
   }
   const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path18.dirname(packageJsonPath);
+  const packageDir = path19.dirname(packageJsonPath);
   console.log(`Running ${verifyScripts.length} verify script(s) in parallel:`);
   for (const script of verifyScripts) {
     console.log(`  - ${script}`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.42.1",
+	"version": "0.42.2",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {
@@ -21,7 +21,7 @@
 		"verify:types": "tsc --noEmit",
 		"verify:knip": "knip --no-progress --treat-config-hints-as-errors",
 		"verify:duplicate-code": "jscpd --format 'typescript,tsx' --exitCode 1 --ignore '**/*.test.*' -r consoleFull src",
-		"verify:maintainability": "assist complexity maintainability ./src --threshold 50",
+		"verify:maintainability": "assist complexity maintainability ./src --threshold 55",
 		"verify:custom-lint": "assist lint"
 	},
 	"keywords": [],