@staff0rd/assist 0.149.0 → 0.149.2

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.149.0",
+  version: "0.149.2",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -91,10 +91,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path49) {
-  if (!existsSync(path49)) return {};
+function loadRawYaml(path50) {
+  if (!existsSync(path50)) return {};
   try {
-    const content = readFileSync(path49, "utf-8");
+    const content = readFileSync(path50, "utf-8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -371,9 +371,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path49) {
+function getNestedValue(obj, path50) {
   let current = obj;
-  for (const key of path49.split(".")) current = stepInto(current, key);
+  for (const key of path50.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -414,8 +414,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path49, value) {
-  const keys = path49.split(".");
+function setNestedValue(obj, path50, value) {
+  const keys = path50.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -3190,11 +3190,11 @@ function registerPlanCommands(cmd) {
   cmd.command("phase-done <id> <phase>").description("Signal that a plan phase is complete").action(phaseDone);
 }
 function registerRunCommands(cmd) {
-  cmd.command("next").description("Pick and run the next backlog item, or open /draft if none").option("--allow-edits", "Run Claude with acceptEdits permission mode").action(
-    (opts) => next({ allowEdits: opts.allowEdits })
+  cmd.command("next").description("Pick and run the next backlog item, or open /draft if none").option("-w, --write", "Run Claude with acceptEdits permission mode").action(
+    (opts) => next({ allowEdits: opts.write })
   );
-  cmd.command("run <id>").description("Run a backlog item's plan phase-by-phase with Claude").option("--allow-edits", "Run Claude with acceptEdits permission mode").action(
-    (id, opts) => run2(id, { allowEdits: opts.allowEdits })
+  cmd.command("run <id>").description("Run a backlog item's plan phase-by-phase with Claude").option("-w, --write", "Run Claude with acceptEdits permission mode").action(
+    (id, opts) => run2(id, { allowEdits: opts.write })
   );
 }
 function registerBacklog(program2) {
@@ -3298,12 +3298,12 @@ function getCliReadsPath() {
 var cachedLines;
 function getCliReadsLines() {
   if (cachedLines) return cachedLines;
-  const path49 = getCliReadsPath();
-  if (!existsSync18(path49)) {
+  const path50 = getCliReadsPath();
+  if (!existsSync18(path50)) {
     cachedLines = [];
     return cachedLines;
   }
-  cachedLines = readFileSync13(path49, "utf-8").split("\n").filter((line) => line.trim() !== "");
+  cachedLines = readFileSync13(path50, "utf-8").split("\n").filter((line) => line.trim() !== "");
   return cachedLines;
 }
 function loadCliReads() {
@@ -3658,14 +3658,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, path49, description, depth, p) {
-  showProgress(p, path49.join(" "));
-  const subHelp = await runHelp([cli, ...path49]);
+async function resolveCommand(cli, path50, description, depth, p) {
+  showProgress(p, path50.join(" "));
+  const subHelp = await runHelp([cli, ...path50]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path49, description }];
+    return [{ path: path50, description }];
   }
-  const children = await discoverAt(cli, path49, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path49, description }];
+  const children = await discoverAt(cli, path50, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path50, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -3813,9 +3813,9 @@ function logPath(cli) {
   return join13(homedir4(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path49 = logPath(cli);
-  if (!existsSync20(path49)) return void 0;
-  return readFileSync15(path49, "utf-8");
+  const path50 = logPath(cli);
+  if (!existsSync20(path50)) return void 0;
+  return readFileSync15(path50, "utf-8");
 }
 function writeCache(cli, output) {
   const dir = join13(homedir4(), ".assist");
@@ -5646,10 +5646,10 @@ function getStorePath(filename) {
   return join19(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path49 = getStorePath(filename);
-  if (existsSync26(path49)) {
+  const path50 = getStorePath(filename);
+  if (existsSync26(path50)) {
     try {
-      return JSON.parse(readFileSync21(path49, "utf-8"));
+      return JSON.parse(readFileSync21(path50, "utf-8"));
     } catch {
       return {};
     }
@@ -6042,7 +6042,7 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-function comment(path49, line, body) {
+function comment(path50, line, body) {
   validateBody(body);
   validateLine(line);
   try {
@@ -6062,7 +6062,7 @@ function comment(path49, line, body) {
           "-f",
           `body=${body}`,
           "-f",
-          `path=${path49}`,
+          `path=${path50}`,
           "-F",
           `line=${line}`
         ],
@@ -6071,7 +6071,7 @@ function comment(path49, line, body) {
       if (result.status !== 0) {
         throw new Error(result.stderr || result.stdout);
       }
-      console.log(`Added review comment on ${path49}:${line}`);
+      console.log(`Added review comment on ${path50}:${line}`);
     } finally {
       unlinkSync5(queryFile);
     }
@@ -6570,8 +6570,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((path49, line, body) => {
-    comment(path49, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path50, line, body) => {
+    comment(path50, Number.parseInt(line, 10), body);
   });
 }
 
@@ -6823,10 +6823,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path49) {
+async function ravenFetch(connection, path50) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path49}`;
+  const url = `${connection.url}${path50}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -6916,16 +6916,16 @@ import chalk82 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path49;
+  let path50;
   if (opts.collection) {
-    path49 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path50 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path49 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path50 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path49 += `&query=${encodeURIComponent(opts.query)}`;
+    path50 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path49;
+  return path50;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -6934,7 +6934,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 path49 = buildQueryPath({
+    const path50 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -6942,7 +6942,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path49);
+    const data = await ravenFetch(connection, path50);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -7202,7 +7202,7 @@ async function check(pattern2, options2) {
 }
 
 // src/commands/refactor/extract/index.ts
-import path32 from "path";
+import path33 from "path";
 import chalk87 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
@@ -7651,6 +7651,21 @@ function resolveBarrel(functionName, sourcePath, destPath, project) {
   };
 }
 
+// src/commands/refactor/extract/rewriteImportPaths.ts
+import path30 from "path";
+function rewriteImportPaths(imports, sourcePath, destPath) {
+  const sourceDir = path30.dirname(sourcePath);
+  const destDir = path30.dirname(destPath);
+  return imports.map((imp) => {
+    if (!imp.moduleSpecifier.startsWith(".")) return imp;
+    const absolute = path30.resolve(sourceDir, imp.moduleSpecifier);
+    let rel = path30.relative(destDir, absolute).replace(/\\/g, "/");
+    if (rel === "") rel = `../${path30.basename(absolute)}`;
+    else if (!rel.startsWith(".")) rel = `./${rel}`;
+    return { ...imp, moduleSpecifier: rel };
+  });
+}
+
 // src/commands/refactor/extract/sourceReferencesName.ts
 import { SyntaxKind as SyntaxKind10 } from "ts-morph";
 var DECLARATION_KINDS = /* @__PURE__ */ new Set([
@@ -7686,12 +7701,17 @@ function sourceReferencesName(sourceFile, functionName, extractedNames) {
 function buildPlan(functionName, sourceFile, sourcePath, destPath, project) {
   const analysis = analyseTarget(sourceFile, functionName);
   const sourceRelPath = getRelativeImportPath(destPath, sourcePath);
+  const rewrittenImports = rewriteImportPaths(
+    analysis.imports,
+    sourcePath,
+    destPath
+  );
   const { functionTexts: _, ...planFields } = analysis;
   return {
     ...planFields,
     destContent: buildDestinationContent(
       analysis.functionTexts,
-      analysis.imports,
+      rewrittenImports,
       sourceRelPath,
       analysis.exportedDeps
     ),
@@ -7708,7 +7728,7 @@ function buildPlan(functionName, sourceFile, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/displayPlan.ts
-import path30 from "path";
+import path31 from "path";
 import chalk85 from "chalk";
 function section(title) {
   return `
@@ -7718,7 +7738,7 @@ 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());
+    const rel = path31.relative(cwd, imp.file.getFilePath());
     console.log(`    ${chalk85.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
@@ -7759,11 +7779,11 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import fs17 from "fs";
-import path31 from "path";
+import path32 from "path";
 import chalk86 from "chalk";
 import { Project as Project2 } from "ts-morph";
 function findTsConfig(sourcePath) {
-  const rootConfig = path31.resolve("tsconfig.json");
+  const rootConfig = path32.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, "");
@@ -7775,8 +7795,8 @@ function findTsConfig(sourcePath) {
   }
   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;
+    const refPath = path32.resolve(ref.path);
+    const configPath = fs17.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path32.join(refPath, "tsconfig.json") : refPath;
     if (!fs17.existsSync(configPath)) continue;
     const project = new Project2({ tsConfigFilePath: configPath });
     if (project.getSourceFile(sourcePath)) return configPath;
@@ -7784,7 +7804,7 @@ function findTsConfig(sourcePath) {
   return rootConfig;
 }
 function loadProjectFile(file) {
-  const sourcePath = path31.resolve(file);
+  const sourcePath = path32.resolve(file);
   const tsConfigPath = findTsConfig(sourcePath);
   const project = new Project2({
     tsConfigFilePath: tsConfigPath
@@ -7799,10 +7819,10 @@ function loadProjectFile(file) {
 
 // src/commands/refactor/extract/index.ts
 async function extract(file, functionName, destination, options2 = {}) {
-  const sourcePath = path32.resolve(file);
-  const destPath = path32.resolve(destination);
+  const sourcePath = path33.resolve(file);
+  const destPath = path33.resolve(destination);
   const cwd = process.cwd();
-  const relDest = path32.relative(cwd, destPath);
+  const relDest = path33.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(file);
   const plan2 = buildPlan(
     functionName,
@@ -7849,13 +7869,13 @@ function ignore(file) {
 }
 
 // src/commands/refactor/rename/index.ts
-import path33 from "path";
+import path34 from "path";
 import chalk89 from "chalk";
 async function rename(source, destination, options2 = {}) {
-  const destPath = path33.resolve(destination);
+  const destPath = path34.resolve(destination);
   const cwd = process.cwd();
-  const relSource = path33.relative(cwd, path33.resolve(source));
-  const relDest = path33.relative(cwd, destPath);
+  const relSource = path34.relative(cwd, path34.resolve(source));
+  const relDest = path34.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(source);
   console.log(chalk89.bold(`Rename: ${relSource} \u2192 ${relDest}`));
   if (options2.apply) {
@@ -7868,7 +7888,7 @@ async function rename(source, destination, options2 = {}) {
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import path35 from "path";
+import path36 from "path";
 import chalk90 from "chalk";
 import { Project as Project3 } from "ts-morph";
 
@@ -7897,12 +7917,12 @@ function findSymbol(sourceFile, symbolName) {
 }
 
 // src/commands/refactor/renameSymbol/groupReferences.ts
-import path34 from "path";
+import path35 from "path";
 function groupReferences(symbol, cwd) {
   const refs = symbol.findReferencesAsNodes();
   const grouped = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    const refFile = path34.relative(cwd, ref.getSourceFile().getFilePath());
+    const refFile = path35.relative(cwd, ref.getSourceFile().getFilePath());
     const lines = grouped.get(refFile) ?? [];
     if (!grouped.has(refFile)) grouped.set(refFile, lines);
     lines.push(ref.getStartLineNumber());
@@ -7912,8 +7932,8 @@ function groupReferences(symbol, cwd) {
 
 // src/commands/refactor/renameSymbol/index.ts
 async function renameSymbol(file, oldName, newName, options2 = {}) {
-  const filePath = path35.resolve(file);
-  const tsConfigPath = path35.resolve("tsconfig.json");
+  const filePath = path36.resolve(file);
+  const tsConfigPath = path36.resolve("tsconfig.json");
   const cwd = process.cwd();
   const project = new Project3({ tsConfigFilePath: tsConfigPath });
   const sourceFile = project.getSourceFile(filePath);
@@ -7948,11 +7968,11 @@ Renamed ${oldName} \u2192 ${newName}`));
 }
 
 // src/commands/refactor/restructure/index.ts
-import path44 from "path";
+import path45 from "path";
 import chalk93 from "chalk";
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-import path36 from "path";
+import path37 from "path";
 import ts7 from "typescript";
 
 // src/commands/refactor/restructure/buildImportGraph/getImportSpecifiers.ts
@@ -7979,7 +7999,7 @@ function loadParsedConfig(tsConfigPath) {
   return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
-    path36.dirname(tsConfigPath)
+    path37.dirname(tsConfigPath)
   );
 }
 function addToSetMap(map, key, value) {
@@ -7995,7 +8015,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 path36.resolve(resolvedPath);
+  return path37.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
   const parsed = loadParsedConfig(tsConfigPath);
@@ -8004,7 +8024,7 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
   for (const sourceFile of program2.getSourceFiles()) {
-    const filePath = path36.resolve(sourceFile.fileName);
+    const filePath = path37.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
       const absTarget = resolveImport(specifier, filePath, parsed.options);
@@ -8018,12 +8038,12 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
 }
 
 // src/commands/refactor/restructure/clusterDirectories.ts
-import path37 from "path";
+import path38 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path37.dirname(edge.source);
-    const targetDir = path37.dirname(edge.target);
+    const sourceDir = path38.dirname(edge.source);
+    const targetDir = path38.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -8051,20 +8071,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path37.relative(ancestor, descendant);
+  const rel = path38.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path38 from "path";
+import path39 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 = path38.dirname(parent);
-  const fileDir = path38.dirname(file);
+  const parentDir = path39.dirname(parent);
+  const fileDir = path39.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path38.basename(parent, path38.extname(parent)) === "index") return file;
+  if (path39.basename(parent, path39.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -8072,16 +8092,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename7 = path38.basename(file, path38.extname(file));
+    const basename7 = path39.basename(file, path39.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 = path38.dirname(parent);
-    const fileDir = path38.dirname(file);
+    const parentDir = path39.dirname(parent);
+    const fileDir = path39.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path38.basename(parent, path38.extname(parent));
+    const parentBasename = path39.basename(parent, path39.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -8093,7 +8113,7 @@ function clusterFiles(graph) {
 }
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
-import path39 from "path";
+import path40 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
 import fs19 from "fs";
@@ -8147,7 +8167,7 @@ function normalizeSpecifier(rel) {
   );
 }
 function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path39.relative(path39.dirname(fromFile), toFile));
+  return normalizeSpecifier(path40.relative(path40.dirname(fromFile), toFile));
 }
 function isAffected(edge, moveMap) {
   return moveMap.has(edge.target) || moveMap.has(edge.source);
@@ -8191,10 +8211,10 @@ function computeRewrites(moves, edges, allProjectFiles) {
 }
 
 // src/commands/refactor/restructure/displayPlan.ts
-import path40 from "path";
+import path41 from "path";
 import chalk91 from "chalk";
 function relPath(filePath) {
-  return path40.relative(process.cwd(), filePath);
+  return path41.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
@@ -8244,33 +8264,33 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 
 // src/commands/refactor/restructure/executePlan.ts
 import fs20 from "fs";
-import path41 from "path";
+import path42 from "path";
 import chalk92 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs20.writeFileSync(file, content, "utf-8");
     console.log(
-      chalk92.cyan(`  Rewrote imports in ${path41.relative(process.cwd(), file)}`)
+      chalk92.cyan(`  Rewrote imports in ${path42.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs20.mkdirSync(dir, { recursive: true });
-    console.log(chalk92.green(`  Created ${path41.relative(process.cwd(), dir)}/`));
+    console.log(chalk92.green(`  Created ${path42.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan2.moves) {
-    const targetDir = path41.dirname(move.to);
+    const targetDir = path42.dirname(move.to);
     if (!fs20.existsSync(targetDir)) {
       fs20.mkdirSync(targetDir, { recursive: true });
     }
     fs20.renameSync(move.from, move.to);
     console.log(
       chalk92.white(
-        `  Moved ${path41.relative(process.cwd(), move.from)} \u2192 ${path41.relative(process.cwd(), move.to)}`
+        `  Moved ${path42.relative(process.cwd(), move.from)} \u2192 ${path42.relative(process.cwd(), move.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path41.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path42.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
@@ -8281,7 +8301,7 @@ function removeEmptyDirectories(dirs) {
       fs20.rmdirSync(dir);
       console.log(
         chalk92.dim(
-          `  Removed empty directory ${path41.relative(process.cwd(), dir)}`
+          `  Removed empty directory ${path42.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -8289,7 +8309,7 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path43 from "path";
+import path44 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
 import fs21 from "fs";
@@ -8304,9 +8324,9 @@ function checkDirConflict(result, label2, dir) {
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
 import fs22 from "fs";
-import path42 from "path";
+import path43 from "path";
 function collectEntry(results, dir, entry) {
-  const full = path42.join(dir, entry.name);
+  const full = path43.join(dir, entry.name);
   const items = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items);
 }
@@ -8320,15 +8340,15 @@ function listFilesRecursive(dir) {
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path42.relative(childDir, file);
-    moves.push({ from: file, to: path42.join(newLocation, rel), reason });
+    const rel = path43.relative(childDir, file);
+    moves.push({ from: file, to: path43.join(newLocation, rel), reason });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path42.join(parentDir, path42.basename(childDir));
+  return path43.join(parentDir, path43.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path42.basename(parentDir)}/`;
+  return `Directory only imported from ${path43.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -8353,7 +8373,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path43.join(newDir, path43.basename(child));
+  const to = path44.join(newDir, path44.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -8361,15 +8381,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path43.basename(filePath, path43.extname(filePath));
+  return path44.basename(filePath, path44.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path43.join(path43.dirname(parent), getBaseName(parent));
+  return path44.join(path44.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path43.join(newDir, `index${path43.extname(parent)}`),
+    to: path44.join(newDir, `index${path44.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -8393,7 +8413,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan2(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path44.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path45.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -8416,7 +8436,7 @@ async function restructure(pattern2, options2 = {}) {
     console.log(chalk93.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path44.resolve("tsconfig.json");
+  const tsConfigPath = path45.resolve("tsconfig.json");
   const plan2 = buildPlan2(files, tsConfigPath);
   if (plan2.moves.length === 0) {
     console.log(chalk93.green("No restructuring needed"));
@@ -10263,16 +10283,16 @@ async function statusLine() {
 // src/commands/sync.ts
 import * as fs25 from "fs";
 import * as os from "os";
-import * as path47 from "path";
+import * as path48 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs23 from "fs";
-import * as path45 from "path";
+import * as path46 from "path";
 import chalk105 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path45.join(claudeDir, "CLAUDE.md");
-  const target = path45.join(targetBase, "CLAUDE.md");
+  const source = path46.join(claudeDir, "CLAUDE.md");
+  const target = path46.join(targetBase, "CLAUDE.md");
   const sourceContent = fs23.readFileSync(source, "utf-8");
   if (fs23.existsSync(target)) {
     const targetContent = fs23.readFileSync(target, "utf-8");
@@ -10298,11 +10318,11 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 
 // src/commands/sync/syncSettings.ts
 import * as fs24 from "fs";
-import * as path46 from "path";
+import * as path47 from "path";
 import chalk106 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path46.join(claudeDir, "settings.json");
-  const target = path46.join(targetBase, "settings.json");
+  const source = path47.join(claudeDir, "settings.json");
+  const target = path47.join(targetBase, "settings.json");
   const sourceContent = fs24.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
   if (fs24.existsSync(target)) {
@@ -10338,21 +10358,21 @@ async function syncSettings(claudeDir, targetBase, options2) {
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname7 = path47.dirname(__filename4);
+var __dirname7 = path48.dirname(__filename4);
 async function sync(options2) {
-  const claudeDir = path47.join(__dirname7, "..", "claude");
-  const targetBase = path47.join(os.homedir(), ".claude");
+  const claudeDir = path48.join(__dirname7, "..", "claude");
+  const targetBase = path48.join(os.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes: options2?.yes });
   await syncClaudeMd(claudeDir, targetBase, { yes: options2?.yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path47.join(claudeDir, "commands");
-  const targetDir = path47.join(targetBase, "commands");
+  const sourceDir = path48.join(claudeDir, "commands");
+  const targetDir = path48.join(targetBase, "commands");
   fs25.mkdirSync(targetDir, { recursive: true });
   const files = fs25.readdirSync(sourceDir);
   for (const file of files) {
-    fs25.copyFileSync(path47.join(sourceDir, file), path47.join(targetDir, file));
+    fs25.copyFileSync(path48.join(sourceDir, file), path48.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -10360,15 +10380,15 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync40 } from "child_process";
-import * as path48 from "path";
+import * as path49 from "path";
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path48.resolve(dir);
-    if (resolved.split(path48.sep).includes("node_modules")) {
+    const resolved = path49.resolve(dir);
+    if (resolved.split(path49.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync40("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path48.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path49.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.149.0",
+	"version": "0.149.2",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {