@staff0rd/assist 0.138.0 → 0.139.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.138.0",
+  version: "0.139.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -90,10 +90,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path44) {
-  if (!existsSync(path44)) return {};
+function loadRawYaml(path49) {
+  if (!existsSync(path49)) return {};
   try {
-    const content = readFileSync(path44, "utf-8");
+    const content = readFileSync(path49, "utf-8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -370,9 +370,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path44) {
+function getNestedValue(obj, path49) {
   let current = obj;
-  for (const key of path44.split(".")) current = stepInto(current, key);
+  for (const key of path49.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -413,8 +413,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path44, value) {
-  const keys = path44.split(".");
+function setNestedValue(obj, path49, value) {
+  const keys = path49.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -3222,12 +3222,12 @@ function getCliReadsPath() {
 var cachedLines;
 function getCliReadsLines() {
   if (cachedLines) return cachedLines;
-  const path44 = getCliReadsPath();
-  if (!existsSync18(path44)) {
+  const path49 = getCliReadsPath();
+  if (!existsSync18(path49)) {
     cachedLines = [];
     return cachedLines;
   }
-  cachedLines = readFileSync13(path44, "utf-8").split("\n").filter((line) => line.trim() !== "");
+  cachedLines = readFileSync13(path49, "utf-8").split("\n").filter((line) => line.trim() !== "");
   return cachedLines;
 }
 function loadCliReads() {
@@ -3582,14 +3582,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path44, description, depth, p) {
-  showProgress(p, path44.join(" "));
-  const subHelp = await runHelp([cli, ...path44]);
+async function resolveCommand(cli, path49, description, depth, p) {
+  showProgress(p, path49.join(" "));
+  const subHelp = await runHelp([cli, ...path49]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path44, description }];
+    return [{ path: path49, description }];
   }
-  const children = await discoverAt(cli, path44, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path44, description }];
+  const children = await discoverAt(cli, path49, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path49, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -3737,9 +3737,9 @@ function logPath(cli) {
   return join13(homedir4(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path44 = logPath(cli);
-  if (!existsSync20(path44)) return void 0;
-  return readFileSync15(path44, "utf-8");
+  const path49 = logPath(cli);
+  if (!existsSync20(path49)) return void 0;
+  return readFileSync15(path49, "utf-8");
 }
 function writeCache(cli, output) {
   const dir = join13(homedir4(), ".assist");
@@ -5570,10 +5570,10 @@ function getStorePath(filename) {
   return join19(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path44 = getStorePath(filename);
-  if (existsSync26(path44)) {
+  const path49 = getStorePath(filename);
+  if (existsSync26(path49)) {
     try {
-      return JSON.parse(readFileSync21(path44, "utf-8"));
+      return JSON.parse(readFileSync21(path49, "utf-8"));
     } catch {
       return {};
     }
@@ -5966,7 +5966,7 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-function comment(path44, line, body) {
+function comment(path49, line, body) {
   validateBody(body);
   validateLine(line);
   try {
@@ -5986,7 +5986,7 @@ function comment(path44, line, body) {
           "-f",
           `body=${body}`,
           "-f",
-          `path=${path44}`,
+          `path=${path49}`,
           "-F",
           `line=${line}`
         ],
@@ -5995,7 +5995,7 @@ function comment(path44, line, body) {
       if (result.status !== 0) {
         throw new Error(result.stderr || result.stdout);
       }
-      console.log(`Added review comment on ${path44}:${line}`);
+      console.log(`Added review comment on ${path49}:${line}`);
     } finally {
       unlinkSync5(queryFile);
     }
@@ -6494,8 +6494,8 @@ function registerPrs(program2) {
   prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason) => {
     wontfix(Number.parseInt(commentId, 10), reason);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path44, line, body) => {
-    comment(path44, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path49, line, body) => {
+    comment(path49, Number.parseInt(line, 10), body);
   });
 }
 
@@ -6747,10 +6747,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path44) {
+async function ravenFetch(connection, path49) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path44}`;
+  const url = `${connection.url}${path49}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -6840,16 +6840,16 @@ import chalk82 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path44;
+  let path49;
   if (opts.collection) {
-    path44 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path49 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path44 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path49 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path44 += `&query=${encodeURIComponent(opts.query)}`;
+    path49 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path44;
+  return path49;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -6858,7 +6858,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path44 = buildQueryPath({
+    const path49 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -6866,7 +6866,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path44);
+    const data = await ravenFetch(connection, path49);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -7125,98 +7125,685 @@ async function check(pattern2, options2) {
   }
 }
 
-// src/commands/refactor/ignore.ts
-import fs17 from "fs";
+// src/commands/refactor/extract/index.ts
+import path32 from "path";
+import chalk87 from "chalk";
+
+// src/commands/refactor/extract/applyExtraction.ts
+import { SyntaxKind as SyntaxKind3 } from "ts-morph";
+
+// src/commands/refactor/extract/removeStaleImports.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+function collectReferencedNames(sourceFile) {
+  const names = /* @__PURE__ */ new Set();
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind2.Identifier)) {
+    names.add(id.getText());
+  }
+  return names;
+}
+function isImportEmpty(importDecl, usedNames) {
+  if (importDecl.getNamedImports().length > 0) return false;
+  const def = importDecl.getDefaultImport();
+  if (def && usedNames.has(def.getText())) return false;
+  const ns = importDecl.getNamespaceImport();
+  if (ns && usedNames.has(ns.getText())) return false;
+  return true;
+}
+function removeStaleImports(sourceFile) {
+  const usedNames = collectReferencedNames(sourceFile);
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    for (const ni of importDecl.getNamedImports()) {
+      const name = ni.getAliasNode()?.getText() ?? ni.getName();
+      if (!usedNames.has(name)) ni.remove();
+    }
+    if (isImportEmpty(importDecl, usedNames)) {
+      importDecl.remove();
+    }
+  }
+}
+
+// src/commands/refactor/extract/updateImporters.ts
+function updateImporters(functionName, sourceFile, importers) {
+  for (const { file: importerFile, relPath: relPath2 } of importers) {
+    let alias;
+    for (const importDecl of importerFile.getImportDeclarations()) {
+      if (importDecl.getModuleSpecifierSourceFile() !== sourceFile) continue;
+      for (const ni of importDecl.getNamedImports()) {
+        if (ni.getName() === functionName) {
+          alias = ni.getAliasNode()?.getText();
+          ni.remove();
+          break;
+        }
+      }
+      if (importDecl.getNamedImports().length === 0 && !importDecl.getDefaultImport() && !importDecl.getNamespaceImport()) {
+        importDecl.remove();
+      }
+    }
+    importerFile.addImportDeclaration({
+      moduleSpecifier: relPath2,
+      namedImports: [alias ? { name: functionName, alias } : functionName]
+    });
+  }
+}
+
+// src/commands/refactor/extract/applyExtraction.ts
+function isNameReferencedInSource(sourceFile, name) {
+  return sourceFile.getDescendantsOfKind(SyntaxKind3.Identifier).some((id) => id.getText() === name);
+}
+async function applyExtraction(functionName, sourceFile, destPath, plan2, project) {
+  project.createSourceFile(destPath, plan2.destContent, { overwrite: false });
+  for (const fn of [plan2.target, ...plan2.dependencies]) {
+    fn.remove();
+  }
+  for (const stmt of plan2.statementsToRemove) {
+    stmt.remove();
+  }
+  removeStaleImports(sourceFile);
+  if (isNameReferencedInSource(sourceFile, functionName)) {
+    sourceFile.addImportDeclaration({
+      moduleSpecifier: plan2.destRelPath,
+      namedImports: [functionName]
+    });
+  }
+  updateImporters(functionName, sourceFile, plan2.importersToUpdate);
+  if (plan2.barrel) {
+    plan2.barrel.addExportDeclaration({
+      moduleSpecifier: plan2.barrelRelPath,
+      namedExports: [functionName]
+    });
+  }
+  await project.save();
+}
+
+// src/commands/refactor/extract/buildPlan.ts
+import path29 from "path";
+
+// src/commands/refactor/extract/collectDependencies.ts
+import {
+  SyntaxKind as SyntaxKind5
+} from "ts-morph";
+
+// src/commands/refactor/extract/collectPrivateFunctions.ts
+import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+function isPrivate(fn) {
+  return !fn.isExported() && !fn.isDefaultExport();
+}
+function getCalledFunctionNames(fn) {
+  const names = /* @__PURE__ */ new Set();
+  for (const call of fn.getDescendantsOfKind(SyntaxKind4.CallExpression)) {
+    const expr = call.getExpression();
+    if (expr.getKind() === SyntaxKind4.Identifier) {
+      names.add(expr.getText());
+    }
+  }
+  return names;
+}
+function collectPrivateFunctions(target, fnMap) {
+  const collected = /* @__PURE__ */ new Set();
+  const queue = [target];
+  let current = queue.pop();
+  while (current) {
+    for (const name of getCalledFunctionNames(current)) {
+      if (collected.has(name)) continue;
+      const fn = fnMap.get(name);
+      if (fn && isPrivate(fn)) {
+        collected.add(name);
+        queue.push(fn);
+      }
+    }
+    current = queue.pop();
+  }
+  return [...collected].flatMap((name) => {
+    const fn = fnMap.get(name);
+    return fn ? [fn] : [];
+  });
+}
+
+// src/commands/refactor/extract/getPrivateStatementMap.ts
+function getPrivateStatementMap(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  for (const stmt of sourceFile.getVariableStatements()) {
+    if (stmt.isExported()) continue;
+    for (const decl of stmt.getDeclarations()) map.set(decl.getName(), stmt);
+  }
+  for (const alias of sourceFile.getTypeAliases()) {
+    if (!alias.isExported()) map.set(alias.getName(), alias);
+  }
+  for (const iface of sourceFile.getInterfaces()) {
+    if (!iface.isExported()) map.set(iface.getName(), iface);
+  }
+  return map;
+}
+
+// src/commands/refactor/extract/collectDependencies.ts
+function getReferencedIdentifiers(fn) {
+  const names = /* @__PURE__ */ new Set();
+  for (const id of fn.getDescendantsOfKind(SyntaxKind5.Identifier)) {
+    names.add(id.getText());
+  }
+  return names;
+}
+function getFunctionMap(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  for (const fn of sourceFile.getDescendantsOfKind(
+    SyntaxKind5.FunctionDeclaration
+  )) {
+    const name = fn.getName();
+    if (name) map.set(name, fn);
+  }
+  return map;
+}
+function collectPrivateStatements(functions, stmtMap) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const fn of functions) {
+    for (const name of getReferencedIdentifiers(fn)) {
+      const stmt = stmtMap.get(name);
+      if (stmt) seen.add(stmt);
+    }
+  }
+  return [...seen];
+}
+function getRemainingFunctions(sourceFile, extracted) {
+  return sourceFile.getDescendantsOfKind(SyntaxKind5.FunctionDeclaration).filter((fn) => !extracted.has(fn));
+}
+function collectDependencies(target, sourceFile) {
+  const fnMap = getFunctionMap(sourceFile);
+  const depFunctions = collectPrivateFunctions(target, fnMap);
+  const allExtracted = [target, ...depFunctions];
+  const stmtMap = getPrivateStatementMap(sourceFile);
+  const toCopy = collectPrivateStatements(allExtracted, stmtMap);
+  const extractedSet = new Set(allExtracted);
+  const remaining = getRemainingFunctions(sourceFile, extractedSet);
+  const usedByRemaining = new Set(collectPrivateStatements(remaining, stmtMap));
+  const toRemove = toCopy.filter((s) => !usedByRemaining.has(s));
+  return {
+    functions: depFunctions,
+    statements: { toCopy, toRemove }
+  };
+}
+
+// src/commands/refactor/extract/findFunction.ts
+import {
+  SyntaxKind as SyntaxKind6
+} from "ts-morph";
+function findFunction(sourceFile, functionName) {
+  return sourceFile.getDescendantsOfKind(SyntaxKind6.FunctionDeclaration).find((fn) => fn.getName() === functionName);
+}
+
+// src/commands/refactor/extract/getExportedDependencyNames.ts
+import { SyntaxKind as SyntaxKind7 } from "ts-morph";
+function getExportedDependencyNames(target, sourceFile) {
+  const calledNames = /* @__PURE__ */ new Set();
+  for (const call of target.getDescendantsOfKind(SyntaxKind7.CallExpression)) {
+    const expr = call.getExpression();
+    if (expr.getKind() === SyntaxKind7.Identifier) {
+      calledNames.add(expr.getText());
+    }
+  }
+  const exported = [];
+  for (const fn of sourceFile.getDescendantsOfKind(
+    SyntaxKind7.FunctionDeclaration
+  )) {
+    const name = fn.getName();
+    if (name && calledNames.has(name) && fn.isExported()) {
+      exported.push(name);
+    }
+  }
+  return exported;
+}
+
+// src/commands/refactor/extract/getStatementNames.ts
+import { SyntaxKind as SyntaxKind8 } from "ts-morph";
+function getStatementNames(node) {
+  if (node.getKind() === SyntaxKind8.VariableStatement) {
+    const stmt = node;
+    return stmt.getDeclarations().map((d) => d.getName());
+  }
+  const named = node;
+  return named.getName ? [named.getName()] : [];
+}
+
+// src/commands/refactor/extract/resolveImports.ts
+import {
+  SyntaxKind as SyntaxKind9
+} from "ts-morph";
+
+// src/commands/refactor/extract/matchImport.ts
+function matchNamedImports(importDecl, neededNames) {
+  const matched = [];
+  for (const specifier of importDecl.getNamedImports()) {
+    const name = specifier.getAliasNode()?.getText() ?? specifier.getName();
+    if (!neededNames.has(name)) continue;
+    const original = specifier.getName();
+    const alias = specifier.getAliasNode()?.getText();
+    matched.push(alias ? `${original} as ${alias}` : original);
+  }
+  return matched;
+}
+function matchOptionalImport(node, neededNames) {
+  return node && neededNames.has(node.getText()) ? node.getText() : void 0;
+}
+function matchImport(importDecl, neededNames) {
+  const namedImports = matchNamedImports(importDecl, neededNames);
+  const defaultImport = matchOptionalImport(
+    importDecl.getDefaultImport(),
+    neededNames
+  );
+  const namespaceImport = matchOptionalImport(
+    importDecl.getNamespaceImport(),
+    neededNames
+  );
+  if (namedImports.length === 0 && !defaultImport && !namespaceImport) {
+    return void 0;
+  }
+  return {
+    moduleSpecifier: importDecl.getModuleSpecifierValue(),
+    namedImports,
+    defaultImport,
+    namespaceImport,
+    isTypeOnly: importDecl.isTypeOnly()
+  };
+}
+
+// src/commands/refactor/extract/resolveImports.ts
+function getReferencedNames(nodes) {
+  const names = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    for (const id of node.getDescendantsOfKind(SyntaxKind9.Identifier)) {
+      names.add(id.getText());
+    }
+  }
+  return names;
+}
+function getLocallyDeclaredNames(functions) {
+  const names = /* @__PURE__ */ new Set();
+  for (const fn of functions) {
+    const name = fn.getName();
+    if (name) names.add(name);
+    for (const param of fn.getParameters()) {
+      names.add(param.getName());
+    }
+    for (const varDecl of fn.getDescendantsOfKind(
+      SyntaxKind9.VariableDeclaration
+    )) {
+      names.add(varDecl.getName());
+    }
+  }
+  return names;
+}
+function resolveImports(target, dependencies, sourceFile, statements = []) {
+  const allFunctions = [target, ...dependencies];
+  const allNodes = [...allFunctions, ...statements];
+  const referencedNames = getReferencedNames(allNodes);
+  const localNames = getLocallyDeclaredNames(allFunctions);
+  const externalNames = /* @__PURE__ */ new Set();
+  for (const name of referencedNames) {
+    if (!localNames.has(name)) externalNames.add(name);
+  }
+  const result = [];
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const matched = matchImport(importDecl, externalNames);
+    if (matched) result.push(matched);
+  }
+  return result;
+}
+
+// src/commands/refactor/extract/analyseTarget.ts
+function extractTexts(target, allFunctions, statements) {
+  const stmtTexts = statements.map((v) => v.getFullText().trim());
+  const fnTexts = allFunctions.map((fn) => {
+    const text = fn.getFullText().trim();
+    if (fn === target && !text.startsWith("export ")) return `export ${text}`;
+    return text;
+  });
+  return [...stmtTexts, ...fnTexts];
+}
+function analyseTarget(sourceFile, functionName) {
+  const target = findFunction(sourceFile, functionName);
+  if (!target) throw new Error(`Function "${functionName}" not found`);
+  const { functions: dependencies, statements } = collectDependencies(
+    target,
+    sourceFile
+  );
+  const all = [target, ...dependencies];
+  return {
+    target,
+    dependencies,
+    statementsToCopy: statements.toCopy,
+    statementsToRemove: statements.toRemove,
+    imports: resolveImports(
+      target,
+      dependencies,
+      sourceFile,
+      statements.toCopy
+    ),
+    exportedDeps: getExportedDependencyNames(target, sourceFile),
+    extractedNames: [
+      ...statements.toRemove.flatMap(getStatementNames),
+      ...all.map((fn) => fn.getName()).filter(Boolean)
+    ],
+    functionTexts: extractTexts(target, all, statements.toCopy)
+  };
+}
+
+// src/commands/refactor/extract/formatImportLine.ts
+function formatImportLine(imp) {
+  const parts = [];
+  if (imp.isTypeOnly) parts.push("type ");
+  if (imp.defaultImport) parts.push(imp.defaultImport);
+  if (imp.namespaceImport) parts.push(`* as ${imp.namespaceImport}`);
+  if (imp.namedImports.length > 0) {
+    if (imp.defaultImport) parts.push(", ");
+    parts.push(`{ ${imp.namedImports.join(", ")} }`);
+  }
+  return `import ${parts.join("")} from "${imp.moduleSpecifier}";`;
+}
+
+// src/commands/refactor/extract/buildDestinationContent.ts
+function buildDestinationContent(functionTexts, imports, sourceRelativePath, sourceImportNames) {
+  const lines = [];
+  for (const imp of imports) {
+    lines.push(formatImportLine(imp));
+  }
+  if (sourceImportNames.length > 0) {
+    lines.push(
+      `import { ${sourceImportNames.join(", ")} } from "${sourceRelativePath}";`
+    );
+  }
+  if (lines.length > 0) lines.push("");
+  for (let i = 0; i < functionTexts.length; i++) {
+    if (i > 0) lines.push("");
+    lines.push(functionTexts[i]);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/refactor/extract/getRelativeImportPath.ts
+import path28 from "path";
+function getRelativeImportPath(from, to) {
+  let rel = path28.relative(path28.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  return rel;
+}
+
+// src/commands/refactor/extract/findImporters.ts
+function findImporters(functionName, sourceFile, destPath, project) {
+  const result = [];
+  for (const sf of project.getSourceFiles()) {
+    if (sf === sourceFile) continue;
+    for (const importDecl of sf.getImportDeclarations()) {
+      if (importDecl.getModuleSpecifierSourceFile() !== sourceFile) continue;
+      if (importDecl.getNamedImports().some((ni) => ni.getName() === functionName)) {
+        result.push({
+          file: sf,
+          relPath: getRelativeImportPath(sf.getFilePath(), destPath)
+        });
+      }
+    }
+  }
+  return result;
+}
+
+// src/commands/refactor/extract/sourceReferencesName.ts
+import { SyntaxKind as SyntaxKind10 } from "ts-morph";
+var DECLARATION_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind10.FunctionDeclaration,
+  SyntaxKind10.ImportSpecifier,
+  SyntaxKind10.ExportSpecifier
+]);
+function isInsideExtractedFunction(node, extracted) {
+  let current = node;
+  while (current) {
+    if (current.getKind() !== SyntaxKind10.FunctionDeclaration) {
+      current = current.getParent();
+      continue;
+    }
+    const name = current.getName?.();
+    if (name && extracted.has(name)) return true;
+    current = current.getParent();
+  }
+  return false;
+}
+function sourceReferencesName(sourceFile, functionName, extractedNames) {
+  const extracted = new Set(extractedNames);
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind10.Identifier)) {
+    if (id.getText() !== functionName) continue;
+    const parent = id.getParent();
+    if (!parent || DECLARATION_KINDS.has(parent.getKind())) continue;
+    if (!isInsideExtractedFunction(parent, extracted)) return true;
+  }
+  return false;
+}
+
+// src/commands/refactor/extract/buildPlan.ts
+function resolveBarrel(destPath, project) {
+  const indexPath = path29.join(path29.dirname(destPath), "index.ts");
+  return {
+    barrel: project.getSourceFile(indexPath),
+    barrelRelPath: getRelativeImportPath(indexPath, destPath)
+  };
+}
+function buildPlan(functionName, sourceFile, sourcePath, destPath, project) {
+  const analysis = analyseTarget(sourceFile, functionName);
+  const sourceRelPath = getRelativeImportPath(destPath, sourcePath);
+  const { functionTexts: _, ...planFields } = analysis;
+  return {
+    ...planFields,
+    destContent: buildDestinationContent(
+      analysis.functionTexts,
+      analysis.imports,
+      sourceRelPath,
+      analysis.exportedDeps
+    ),
+    destRelPath: getRelativeImportPath(sourcePath, destPath),
+    sourceRelPath,
+    sourceNeedsReimport: sourceReferencesName(
+      sourceFile,
+      functionName,
+      analysis.extractedNames
+    ),
+    importersToUpdate: analysis.target.isExported() ? findImporters(functionName, sourceFile, destPath, project) : [],
+    ...resolveBarrel(destPath, project)
+  };
+}
+
+// src/commands/refactor/extract/displayPlan.ts
+import path30 from "path";
 import chalk85 from "chalk";
+function section(title) {
+  return `
+  ${chalk85.cyan(title)}`;
+}
+function displayImporters(plan2, cwd) {
+  if (plan2.importersToUpdate.length === 0) return;
+  console.log(section("Update importers:"));
+  for (const imp of plan2.importersToUpdate) {
+    const rel = path30.relative(cwd, imp.file.getFilePath());
+    console.log(`    ${chalk85.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+  }
+}
+function displayPlan(functionName, relDest, plan2, cwd) {
+  console.log(chalk85.bold(`Extract: ${functionName} \u2192 ${relDest}
+`));
+  console.log(`  ${chalk85.cyan("Functions to move:")}`);
+  for (const name of plan2.extractedNames) {
+    console.log(`    ${name}`);
+  }
+  if (plan2.imports.length > 0) {
+    console.log(section("Imports to copy:"));
+    for (const imp of plan2.imports) {
+      console.log(`    ${formatImportLine(imp)}`);
+    }
+  }
+  if (plan2.exportedDeps.length > 0) {
+    console.log(section("New imports from source:"));
+    console.log(
+      `    import { ${plan2.exportedDeps.join(", ")} } from "${plan2.sourceRelPath}";`
+    );
+  }
+  console.log(section("Source file changes:"));
+  console.log(`    Remove: ${plan2.extractedNames.join(", ")}`);
+  if (plan2.sourceNeedsReimport) {
+    console.log(
+      `    Add: import { ${functionName} } from "${plan2.destRelPath}";`
+    );
+  }
+  displayImporters(plan2, cwd);
+  if (plan2.barrel) {
+    console.log(section("Barrel export:"));
+    console.log(
+      `    Add: export { ${functionName} } from "${plan2.barrelRelPath}";`
+    );
+  }
+}
+
+// src/commands/refactor/extract/loadProjectFile.ts
+import fs17 from "fs";
+import path31 from "path";
+import chalk86 from "chalk";
+import { Project as Project2 } from "ts-morph";
+function findTsConfig(sourcePath) {
+  const rootConfig = path31.resolve("tsconfig.json");
+  if (!fs17.existsSync(rootConfig)) return rootConfig;
+  const raw = fs17.readFileSync(rootConfig, "utf-8");
+  const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  let parsed;
+  try {
+    parsed = JSON.parse(stripped);
+  } catch {
+    return rootConfig;
+  }
+  if (!parsed.references?.length) return rootConfig;
+  for (const ref of parsed.references) {
+    const refPath = path31.resolve(ref.path);
+    const configPath = fs17.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path31.join(refPath, "tsconfig.json") : refPath;
+    if (!fs17.existsSync(configPath)) continue;
+    const project = new Project2({ tsConfigFilePath: configPath });
+    if (project.getSourceFile(sourcePath)) return configPath;
+  }
+  return rootConfig;
+}
+function loadProjectFile(file) {
+  const sourcePath = path31.resolve(file);
+  const tsConfigPath = findTsConfig(sourcePath);
+  const project = new Project2({
+    tsConfigFilePath: tsConfigPath
+  });
+  const sourceFile = project.getSourceFile(sourcePath);
+  if (!sourceFile) {
+    console.log(chalk86.red(`File not found in project: ${file}`));
+    process.exit(1);
+  }
+  return { project, sourceFile };
+}
+
+// src/commands/refactor/extract/index.ts
+async function extract(file, functionName, destination, options2 = {}) {
+  const sourcePath = path32.resolve(file);
+  const destPath = path32.resolve(destination);
+  const cwd = process.cwd();
+  const relDest = path32.relative(cwd, destPath);
+  const { project, sourceFile } = loadProjectFile(file);
+  const plan2 = buildPlan(
+    functionName,
+    sourceFile,
+    sourcePath,
+    destPath,
+    project
+  );
+  displayPlan(functionName, relDest, plan2, cwd);
+  if (options2.apply) {
+    await applyExtraction(functionName, sourceFile, destPath, plan2, project);
+    console.log(chalk87.green("\nExtraction complete"));
+  } else {
+    console.log(chalk87.dim("\nDry run. Use --apply to execute."));
+  }
+}
+
+// src/commands/refactor/ignore.ts
+import fs18 from "fs";
+import chalk88 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
-  if (!fs17.existsSync(file)) {
-    console.error(chalk85.red(`Error: File does not exist: ${file}`));
+  if (!fs18.existsSync(file)) {
+    console.error(chalk88.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs17.readFileSync(file, "utf-8");
+  const content = fs18.readFileSync(file, "utf-8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs17.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs17.readFileSync(REFACTOR_YML_PATH2, "utf-8");
-    fs17.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs18.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs18.readFileSync(REFACTOR_YML_PATH2, "utf-8");
+    fs18.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs17.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs18.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk85.green(
+    chalk88.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
 }
 
 // src/commands/refactor/rename/index.ts
-import path28 from "path";
-import chalk86 from "chalk";
-import { Project as Project2 } from "ts-morph";
+import path33 from "path";
+import chalk89 from "chalk";
 async function rename(source, destination, options2 = {}) {
-  const sourcePath = path28.resolve(source);
-  const destPath = path28.resolve(destination);
+  const destPath = path33.resolve(destination);
   const cwd = process.cwd();
-  const relSource = path28.relative(cwd, sourcePath);
-  const relDest = path28.relative(cwd, destPath);
-  const project = new Project2({
-    tsConfigFilePath: path28.resolve("tsconfig.json")
-  });
-  const sourceFile = project.getSourceFile(sourcePath);
-  if (!sourceFile) {
-    console.log(chalk86.red(`File not found in project: ${source}`));
-    process.exit(1);
-  }
-  console.log(chalk86.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  const relSource = path33.relative(cwd, path33.resolve(source));
+  const relDest = path33.relative(cwd, destPath);
+  const { project, sourceFile } = loadProjectFile(source);
+  console.log(chalk89.bold(`Rename: ${relSource} \u2192 ${relDest}`));
   if (options2.apply) {
     sourceFile.move(destPath);
     await project.save();
-    console.log(chalk86.green("Done"));
+    console.log(chalk89.green("Done"));
   } else {
-    console.log(chalk86.dim("Dry run. Use --apply to execute."));
+    console.log(chalk89.dim("Dry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import path30 from "path";
-import chalk87 from "chalk";
+import path35 from "path";
+import chalk90 from "chalk";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
-import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+import { SyntaxKind as SyntaxKind11 } from "ts-morph";
 var declarationKinds = [
-  SyntaxKind2.VariableDeclaration,
-  SyntaxKind2.FunctionDeclaration,
-  SyntaxKind2.ClassDeclaration,
-  SyntaxKind2.InterfaceDeclaration,
-  SyntaxKind2.TypeAliasDeclaration,
-  SyntaxKind2.EnumDeclaration,
-  SyntaxKind2.PropertyDeclaration,
-  SyntaxKind2.MethodDeclaration,
-  SyntaxKind2.Parameter
+  SyntaxKind11.VariableDeclaration,
+  SyntaxKind11.FunctionDeclaration,
+  SyntaxKind11.ClassDeclaration,
+  SyntaxKind11.InterfaceDeclaration,
+  SyntaxKind11.TypeAliasDeclaration,
+  SyntaxKind11.EnumDeclaration,
+  SyntaxKind11.PropertyDeclaration,
+  SyntaxKind11.MethodDeclaration,
+  SyntaxKind11.Parameter
 ];
 function isDeclaration(identifier) {
   const parent = identifier.getParent();
   return parent !== void 0 && declarationKinds.includes(parent.getKind());
 }
 function findSymbol(sourceFile, symbolName) {
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind2.Identifier)) {
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind11.Identifier)) {
     if (id.getText() === symbolName && isDeclaration(id)) return id;
   }
   return void 0;
 }
 
 // src/commands/refactor/renameSymbol/groupReferences.ts
-import path29 from "path";
+import path34 from "path";
 function groupReferences(symbol, cwd) {
   const refs = symbol.findReferencesAsNodes();
   const grouped = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    const refFile = path29.relative(cwd, ref.getSourceFile().getFilePath());
+    const refFile = path34.relative(cwd, ref.getSourceFile().getFilePath());
     const lines = grouped.get(refFile) ?? [];
     if (!grouped.has(refFile)) grouped.set(refFile, lines);
     lines.push(ref.getStartLineNumber());
@@ -7226,47 +7813,47 @@ function groupReferences(symbol, cwd) {
 
 // src/commands/refactor/renameSymbol/index.ts
 async function renameSymbol(file, oldName, newName, options2 = {}) {
-  const filePath = path30.resolve(file);
-  const tsConfigPath = path30.resolve("tsconfig.json");
+  const filePath = path35.resolve(file);
+  const tsConfigPath = path35.resolve("tsconfig.json");
   const cwd = process.cwd();
   const project = new Project3({ tsConfigFilePath: tsConfigPath });
   const sourceFile = project.getSourceFile(filePath);
   if (!sourceFile) {
-    console.log(chalk87.red(`File not found in project: ${file}`));
+    console.log(chalk90.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk87.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk90.red(`Symbol "${oldName}" not found in ${file}`));
     process.exit(1);
   }
   const grouped = groupReferences(symbol, cwd);
   const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
   console.log(
-    chalk87.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk90.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines] of grouped) {
     console.log(
-      `  ${chalk87.dim(refFile)}: lines ${chalk87.cyan(lines.join(", "))}`
+      `  ${chalk90.dim(refFile)}: lines ${chalk90.cyan(lines.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk87.green(`
+    console.log(chalk90.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk87.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk90.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
-import path39 from "path";
-import chalk90 from "chalk";
+import path44 from "path";
+import chalk93 from "chalk";
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-import path31 from "path";
+import path36 from "path";
 import ts7 from "typescript";
 
 // src/commands/refactor/restructure/buildImportGraph/getImportSpecifiers.ts
@@ -7293,7 +7880,7 @@ function loadParsedConfig(tsConfigPath) {
   return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
-    path31.dirname(tsConfigPath)
+    path36.dirname(tsConfigPath)
   );
 }
 function addToSetMap(map, key, value) {
@@ -7309,7 +7896,7 @@ function resolveImport(specifier, filePath, options2) {
   const resolved = ts7.resolveModuleName(specifier, filePath, options2, ts7.sys);
   const resolvedPath = resolved.resolvedModule?.resolvedFileName;
   if (!resolvedPath || resolvedPath.includes("node_modules")) return null;
-  return path31.resolve(resolvedPath);
+  return path36.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
   const parsed = loadParsedConfig(tsConfigPath);
@@ -7318,7 +7905,7 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
   for (const sourceFile of program2.getSourceFiles()) {
-    const filePath = path31.resolve(sourceFile.fileName);
+    const filePath = path36.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
       const absTarget = resolveImport(specifier, filePath, parsed.options);
@@ -7332,12 +7919,12 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
 }
 
 // src/commands/refactor/restructure/clusterDirectories.ts
-import path32 from "path";
+import path37 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path32.dirname(edge.source);
-    const targetDir = path32.dirname(edge.target);
+    const sourceDir = path37.dirname(edge.source);
+    const targetDir = path37.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -7365,20 +7952,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path32.relative(ancestor, descendant);
+  const rel = path37.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path33 from "path";
+import path38 from "path";
 function findRootParent(file, importedBy, visited) {
   const importers = importedBy.get(file);
   if (!importers || importers.size !== 1) return file;
   const parent = [...importers][0];
-  const parentDir = path33.dirname(parent);
-  const fileDir = path33.dirname(file);
+  const parentDir = path38.dirname(parent);
+  const fileDir = path38.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path33.basename(parent, path33.extname(parent)) === "index") return file;
+  if (path38.basename(parent, path38.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -7386,16 +7973,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename7 = path33.basename(file, path33.extname(file));
+    const basename7 = path38.basename(file, path38.extname(file));
     if (basename7 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
     if (!graph.files.has(parent)) continue;
-    const parentDir = path33.dirname(parent);
-    const fileDir = path33.dirname(file);
+    const parentDir = path38.dirname(parent);
+    const fileDir = path38.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path33.basename(parent, path33.extname(parent));
+    const parentBasename = path38.basename(parent, path38.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -7407,10 +7994,10 @@ function clusterFiles(graph) {
 }
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
-import path34 from "path";
+import path39 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
-import fs18 from "fs";
+import fs19 from "fs";
 function getOrCreateList(map, key) {
   const list4 = map.get(key) ?? [];
   if (!map.has(key)) map.set(key, list4);
@@ -7429,7 +8016,7 @@ function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
   return content.replace(pattern2, `$1${newSpecifier}$2`);
 }
 function applyFileRewrites(file, fileRewrites) {
-  let content = fs18.readFileSync(file, "utf-8");
+  let content = fs19.readFileSync(file, "utf-8");
   for (const { oldSpecifier, newSpecifier } of fileRewrites) {
     content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
   }
@@ -7461,7 +8048,7 @@ function normalizeSpecifier(rel) {
   );
 }
 function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path34.relative(path34.dirname(fromFile), toFile));
+  return normalizeSpecifier(path39.relative(path39.dirname(fromFile), toFile));
 }
 function isAffected(edge, moveMap) {
   return moveMap.has(edge.target) || moveMap.has(edge.source);
@@ -7505,51 +8092,51 @@ function computeRewrites(moves, edges, allProjectFiles) {
 }
 
 // src/commands/refactor/restructure/displayPlan.ts
-import path35 from "path";
-import chalk88 from "chalk";
+import path40 from "path";
+import chalk91 from "chalk";
 function relPath(filePath) {
-  return path35.relative(process.cwd(), filePath);
+  return path40.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk88.bold("\nFile moves:"));
+  console.log(chalk91.bold("\nFile moves:"));
   for (const move of plan2.moves) {
     console.log(
-      `  ${chalk88.red(relPath(move.from))} \u2192 ${chalk88.green(relPath(move.to))}`
+      `  ${chalk91.red(relPath(move.from))} \u2192 ${chalk91.green(relPath(move.to))}`
     );
-    console.log(chalk88.dim(`    ${move.reason}`));
+    console.log(chalk91.dim(`    ${move.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk88.bold(`
+  console.log(chalk91.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk88.cyan(relPath(file))}:`);
+    console.log(`  ${chalk91.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk88.red(`"${oldSpecifier}"`)} \u2192 ${chalk88.green(`"${newSpecifier}"`)}`
+        `    ${chalk91.red(`"${oldSpecifier}"`)} \u2192 ${chalk91.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
-function displayPlan(plan2) {
+function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk88.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk88.yellow(`  ${w}`));
+    console.log(chalk91.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk91.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk88.bold("\nNew directories:"));
+    console.log(chalk91.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk88.green(`  ${dir}/`));
+      console.log(chalk91.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk88.dim(
+    chalk91.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -7557,45 +8144,45 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 }
 
 // src/commands/refactor/restructure/executePlan.ts
-import fs19 from "fs";
-import path36 from "path";
-import chalk89 from "chalk";
+import fs20 from "fs";
+import path41 from "path";
+import chalk92 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
-    fs19.writeFileSync(file, content, "utf-8");
+    fs20.writeFileSync(file, content, "utf-8");
     console.log(
-      chalk89.cyan(`  Rewrote imports in ${path36.relative(process.cwd(), file)}`)
+      chalk92.cyan(`  Rewrote imports in ${path41.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
-    fs19.mkdirSync(dir, { recursive: true });
-    console.log(chalk89.green(`  Created ${path36.relative(process.cwd(), dir)}/`));
+    fs20.mkdirSync(dir, { recursive: true });
+    console.log(chalk92.green(`  Created ${path41.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan2.moves) {
-    const targetDir = path36.dirname(move.to);
-    if (!fs19.existsSync(targetDir)) {
-      fs19.mkdirSync(targetDir, { recursive: true });
+    const targetDir = path41.dirname(move.to);
+    if (!fs20.existsSync(targetDir)) {
+      fs20.mkdirSync(targetDir, { recursive: true });
     }
-    fs19.renameSync(move.from, move.to);
+    fs20.renameSync(move.from, move.to);
     console.log(
-      chalk89.white(
-        `  Moved ${path36.relative(process.cwd(), move.from)} \u2192 ${path36.relative(process.cwd(), move.to)}`
+      chalk92.white(
+        `  Moved ${path41.relative(process.cwd(), move.from)} \u2192 ${path41.relative(process.cwd(), move.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path36.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path41.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
   for (const dir of unique) {
-    if (!fs19.existsSync(dir)) continue;
-    const entries = fs19.readdirSync(dir);
+    if (!fs20.existsSync(dir)) continue;
+    const entries = fs20.readdirSync(dir);
     if (entries.length === 0) {
-      fs19.rmdirSync(dir);
+      fs20.rmdirSync(dir);
       console.log(
-        chalk89.dim(
-          `  Removed empty directory ${path36.relative(process.cwd(), dir)}`
+        chalk92.dim(
+          `  Removed empty directory ${path41.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -7603,46 +8190,46 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path38 from "path";
+import path43 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
-import fs20 from "fs";
+import fs21 from "fs";
 function emptyResult() {
   return { moves: [], directories: [], warnings: [] };
 }
 function checkDirConflict(result, label2, dir) {
-  if (!fs20.existsSync(dir)) return false;
+  if (!fs21.existsSync(dir)) return false;
   result.warnings.push(`Skipping ${label2}: directory ${dir} already exists`);
   return true;
 }
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
-import fs21 from "fs";
-import path37 from "path";
+import fs22 from "fs";
+import path42 from "path";
 function collectEntry(results, dir, entry) {
-  const full = path37.join(dir, entry.name);
+  const full = path42.join(dir, entry.name);
   const items = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items);
 }
 function listFilesRecursive(dir) {
-  if (!fs21.existsSync(dir)) return [];
+  if (!fs22.existsSync(dir)) return [];
   const results = [];
-  for (const entry of fs21.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs22.readdirSync(dir, { withFileTypes: true })) {
     collectEntry(results, dir, entry);
   }
   return results;
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path37.relative(childDir, file);
-    moves.push({ from: file, to: path37.join(newLocation, rel), reason });
+    const rel = path42.relative(childDir, file);
+    moves.push({ from: file, to: path42.join(newLocation, rel), reason });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path37.join(parentDir, path37.basename(childDir));
+  return path42.join(parentDir, path42.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path37.basename(parentDir)}/`;
+  return `Directory only imported from ${path42.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -7667,7 +8254,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path38.join(newDir, path38.basename(child));
+  const to = path43.join(newDir, path43.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -7675,15 +8262,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path38.basename(filePath, path38.extname(filePath));
+  return path43.basename(filePath, path43.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path38.join(path38.dirname(parent), getBaseName(parent));
+  return path43.join(path43.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path38.join(newDir, `index${path38.extname(parent)}`),
+    to: path43.join(newDir, `index${path43.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -7706,8 +8293,8 @@ function planFileMoves(clusters) {
 }
 
 // src/commands/refactor/restructure/index.ts
-function buildPlan(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path39.resolve(f)));
+function buildPlan2(candidateFiles, tsConfigPath) {
+  const candidates = new Set(candidateFiles.map((f) => path44.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -7727,40 +8314,42 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk90.yellow("No files found matching pattern"));
+    console.log(chalk93.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path39.resolve("tsconfig.json");
-  const plan2 = buildPlan(files, tsConfigPath);
+  const tsConfigPath = path44.resolve("tsconfig.json");
+  const plan2 = buildPlan2(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk90.green("No restructuring needed"));
+    console.log(chalk93.green("No restructuring needed"));
     return;
   }
-  displayPlan(plan2);
+  displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk90.bold("\nApplying changes..."));
+    console.log(chalk93.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk90.green("\nRestructuring complete"));
+    console.log(chalk93.green("\nRestructuring complete"));
   } else {
-    console.log(chalk90.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk93.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/registerRefactor.ts
-function registerRefactor(program2) {
-  const refactorCommand = program2.command("refactor").description("Run refactoring checks for code quality");
-  refactorCommand.command("check [pattern]").description("Check for files that exceed the maximum line count").option("--modified", "Check only staged and unstaged files").option("--staged", "Check only staged files").option("--unstaged", "Check only unstaged files").option(
+function registerCheck(parent) {
+  parent.command("check [pattern]").description("Check for files that exceed the maximum line count").option("--modified", "Check only staged and unstaged files").option("--staged", "Check only staged files").option("--unstaged", "Check only unstaged files").option(
     "--max-lines <number>",
     "Maximum lines allowed per file (default: 100)",
     Number.parseInt
   ).action(check);
-  refactorCommand.command("ignore <file>").description("Add a file to the refactor ignore list").action(ignore);
-  const renameCommand = refactorCommand.command("rename").description("Rename files or symbols with automatic import updates");
+}
+function registerRename(parent) {
+  const renameCommand = parent.command("rename").description("Rename files or symbols with automatic import updates");
   renameCommand.command("file <source> <destination>").description("Rename/move a TypeScript file and update all imports").option("--apply", "Execute the rename (default: dry-run)").action(rename);
   renameCommand.command("symbol <file> <oldName> <newName>").description(
     "Rename a variable, function, class, or type across the project"
   ).option("--apply", "Execute the rename (default: dry-run)").action(renameSymbol);
-  refactorCommand.command("restructure [pattern]").description(
+}
+function registerRestructure(parent) {
+  parent.command("restructure [pattern]").description(
     "Analyze import graph and restructure tightly-coupled files into nested directories"
   ).option("--apply", "Execute the restructuring (default: dry-run)").option(
     "--max-depth <number>",
@@ -7768,9 +8357,19 @@ function registerRefactor(program2) {
     Number.parseInt
   ).action(restructure);
 }
+function registerRefactor(program2) {
+  const refactorCommand = program2.command("refactor").description("Run refactoring checks for code quality");
+  registerCheck(refactorCommand);
+  refactorCommand.command("extract <file> <functionName> <destination>").description(
+    "Extract a function and its private dependencies to a new file"
+  ).option("--apply", "Execute the extraction (default: dry-run)").action(extract);
+  refactorCommand.command("ignore <file>").description("Add a file to the refactor ignore list").action(ignore);
+  registerRename(refactorCommand);
+  registerRestructure(refactorCommand);
+}
 
 // src/commands/seq/seqAuth.ts
-import chalk92 from "chalk";
+import chalk95 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -7799,11 +8398,11 @@ function setDefaultConnection(name) {
 }
 
 // src/commands/seq/promptConnection.ts
-import chalk91 from "chalk";
+import chalk94 from "chalk";
 async function promptConnection2(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   if (existingNames.includes(name)) {
-    console.error(chalk91.red(`Connection "${name}" already exists.`));
+    console.error(chalk94.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput("url", "Seq URL:", "http://localhost:5341");
@@ -7815,32 +8414,32 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk92.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk95.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk95 from "chalk";
+import chalk98 from "chalk";
 
 // src/commands/seq/formatEvent.ts
-import chalk93 from "chalk";
+import chalk96 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk93.bgRed.white;
+      return chalk96.bgRed.white;
     case "Error":
-      return chalk93.red;
+      return chalk96.red;
     case "Warning":
-      return chalk93.yellow;
+      return chalk96.yellow;
     case "Information":
-      return chalk93.cyan;
+      return chalk96.cyan;
     case "Debug":
-      return chalk93.gray;
+      return chalk96.gray;
     case "Verbose":
-      return chalk93.dim;
+      return chalk96.dim;
     default:
-      return chalk93.white;
+      return chalk96.white;
   }
 }
 function levelAbbrev(level) {
@@ -7881,31 +8480,31 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk93.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk96.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines.push(chalk93.red(`  ${line}`));
+      lines.push(chalk96.red(`  ${line}`));
     }
   }
   return lines.join("\n");
 }
 
 // src/commands/seq/resolveConnection.ts
-import chalk94 from "chalk";
+import chalk97 from "chalk";
 function resolveConnection2(name) {
   const connections = loadConnections2();
   if (connections.length === 0) {
     console.error(
-      chalk94.red("No Seq connections configured. Run 'assist seq auth' first.")
+      chalk97.red("No Seq connections configured. Run 'assist seq auth' first.")
     );
     process.exit(1);
   }
   const target = name ?? getDefaultConnection() ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk94.red(`Seq connection "${target}" not found.`));
+    console.error(chalk97.red(`Seq connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -7925,12 +8524,12 @@ async function seqQuery(filter, options2) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk95.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk98.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   const events = await response.json();
   if (events.length === 0) {
-    console.log(chalk95.yellow("No events found."));
+    console.log(chalk98.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -7941,11 +8540,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk95.dim(`
+  console.log(chalk98.dim(`
 ${events.length} events`));
   if (events.length >= count) {
     console.log(
-      chalk95.yellow(
+      chalk98.yellow(
         `Results limited to ${count}. Use --count to retrieve more.`
       )
     );
@@ -7953,11 +8552,11 @@ ${events.length} events`));
 }
 
 // src/commands/seq/seqSetConnection.ts
-import chalk96 from "chalk";
+import chalk99 from "chalk";
 function seqSetConnection(name) {
   const connections = loadConnections2();
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk96.red(`Connection "${name}" not found.`));
+    console.error(chalk99.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefaultConnection(name);
@@ -8496,14 +9095,14 @@ import {
 import { dirname as dirname20, join as join29 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk97 from "chalk";
+import chalk100 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk97.red(
+      chalk100.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -8512,7 +9111,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk97.red(
+      chalk100.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -8905,7 +9504,7 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk98 from "chalk";
+import chalk101 from "chalk";
 
 // src/lib/openBrowser.ts
 import { execSync as execSync36 } from "child_process";
@@ -9080,13 +9679,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk98.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk101.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk98.white("http://localhost:14523/callback\n"));
-  console.log(chalk98.blue("Opening browser for authorization..."));
-  console.log(chalk98.dim("Waiting for authorization callback..."));
+  console.log(chalk101.white("http://localhost:14523/callback\n"));
+  console.log(chalk101.blue("Opening browser for authorization..."));
+  console.log(chalk101.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk98.dim("Exchanging code for tokens..."));
+  console.log(chalk101.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -9102,7 +9701,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk98.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk101.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -9323,7 +9922,7 @@ import { execSync as execSync38 } from "child_process";
 import { existsSync as existsSync38, mkdirSync as mkdirSync13, unlinkSync as unlinkSync10, writeFileSync as writeFileSync27 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join38, resolve as resolve5 } from "path";
-import chalk99 from "chalk";
+import chalk102 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -9474,22 +10073,22 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve5(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk99.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk102.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk99.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk102.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk99.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk102.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
 
 // src/commands/statusLine.ts
-import chalk101 from "chalk";
+import chalk104 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk100 from "chalk";
+import chalk103 from "chalk";
 var FIVE_HOUR_SECONDS = 5 * 3600;
 var SEVEN_DAY_SECONDS = 7 * 86400;
 function formatTimeLeft(resetsAt) {
@@ -9512,10 +10111,10 @@ function projectUsage(pct, resetsAt, windowSeconds) {
 function colorizeRateLimit(pct, resetsAt, windowSeconds) {
   const label2 = `${Math.round(pct)}%`;
   const projected = projectUsage(pct, resetsAt, windowSeconds);
-  if (projected == null) return chalk100.green(label2);
-  if (projected > 100) return chalk100.red(label2);
-  if (projected > 75) return chalk100.yellow(label2);
-  return chalk100.green(label2);
+  if (projected == null) return chalk103.green(label2);
+  if (projected > 100) return chalk103.red(label2);
+  if (projected > 75) return chalk103.yellow(label2);
+  return chalk103.green(label2);
 }
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel) {
   const timeLabel = resetsAt ? formatTimeLeft(resetsAt) : fallbackLabel;
@@ -9541,14 +10140,14 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk101.level = 3;
+chalk104.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
-  if (pct > 80) return chalk101.red(label2);
-  if (pct > 40) return chalk101.yellow(label2);
+  if (pct > 80) return chalk104.red(label2);
+  if (pct > 40) return chalk104.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -9563,29 +10162,29 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 import * as os from "os";
-import * as path42 from "path";
+import * as path47 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs22 from "fs";
-import * as path40 from "path";
-import chalk102 from "chalk";
+import * as fs23 from "fs";
+import * as path45 from "path";
+import chalk105 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase) {
-  const source = path40.join(claudeDir, "CLAUDE.md");
-  const target = path40.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs22.readFileSync(source, "utf-8");
-  if (fs22.existsSync(target)) {
-    const targetContent = fs22.readFileSync(target, "utf-8");
+  const source = path45.join(claudeDir, "CLAUDE.md");
+  const target = path45.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs23.readFileSync(source, "utf-8");
+  if (fs23.existsSync(target)) {
+    const targetContent = fs23.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk102.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk105.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk102.red("Overwrite existing CLAUDE.md?"),
+        chalk105.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -9594,21 +10193,21 @@ async function syncClaudeMd(claudeDir, targetBase) {
       }
     }
   }
-  fs22.copyFileSync(source, target);
+  fs23.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs23 from "fs";
-import * as path41 from "path";
-import chalk103 from "chalk";
+import * as fs24 from "fs";
+import * as path46 from "path";
+import chalk106 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path41.join(claudeDir, "settings.json");
-  const target = path41.join(targetBase, "settings.json");
-  const sourceContent = fs23.readFileSync(source, "utf-8");
+  const source = path46.join(claudeDir, "settings.json");
+  const target = path46.join(targetBase, "settings.json");
+  const sourceContent = fs24.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
-  if (fs23.existsSync(target)) {
-    const targetContent = fs23.readFileSync(target, "utf-8");
+  if (fs24.existsSync(target)) {
+    const targetContent = fs24.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(
       JSON.parse(targetContent),
       null,
@@ -9617,14 +10216,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk103.yellow(
+          chalk106.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk103.red("Overwrite existing settings.json?"),
+          chalk106.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -9634,27 +10233,27 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs23.writeFileSync(target, mergedContent);
+  fs24.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname7 = path42.dirname(__filename4);
+var __dirname7 = path47.dirname(__filename4);
 async function sync(options2) {
-  const claudeDir = path42.join(__dirname7, "..", "claude");
-  const targetBase = path42.join(os.homedir(), ".claude");
+  const claudeDir = path47.join(__dirname7, "..", "claude");
+  const targetBase = path47.join(os.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes: options2?.yes });
   await syncClaudeMd(claudeDir, targetBase);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path42.join(claudeDir, "commands");
-  const targetDir = path42.join(targetBase, "commands");
-  fs24.mkdirSync(targetDir, { recursive: true });
-  const files = fs24.readdirSync(sourceDir);
+  const sourceDir = path47.join(claudeDir, "commands");
+  const targetDir = path47.join(targetBase, "commands");
+  fs25.mkdirSync(targetDir, { recursive: true });
+  const files = fs25.readdirSync(sourceDir);
   for (const file of files) {
-    fs24.copyFileSync(path42.join(sourceDir, file), path42.join(targetDir, file));
+    fs25.copyFileSync(path47.join(sourceDir, file), path47.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -9662,15 +10261,15 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync39 } from "child_process";
-import * as path43 from "path";
+import * as path48 from "path";
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path43.resolve(dir);
-    if (resolved.split(path43.sep).includes("node_modules")) {
+    const resolved = path48.resolve(dir);
+    if (resolved.split(path48.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync39("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path43.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path48.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }