@staff0rd/assist 0.64.2 → 0.66.0

package/README.md

@@ -7,6 +7,7 @@ You can install `assist` globally using npm:
 
 ```bash
 npm install -g @staff0rd/assist
+assist sync
 ```
 
 ## Local Development
@@ -61,11 +62,11 @@ After installation, the `assist` command will be available globally.
 - `assist backlog done <id>` - Set a backlog item to done
 - `assist roam auth` - Authenticate with Roam via OAuth (opens browser, saves tokens to ~/.assist.yml)
 - `assist run <name>` - Run a configured command from assist.yml
-- `assist run add` - Add a new run configuration to assist.yml
+- `assist run add` - Add a new run configuration to assist.yml and create a Claude command file
 - `assist config set <key> <value>` - Set a config value (e.g. commit.push true)
 - `assist config get <key>` - Get a config value
 - `assist config list` - List all config values
-- `assist verify` - Run all verify:* scripts from package.json in parallel
+- `assist verify` - Run all verify:* commands in parallel (from run configs in assist.yml and scripts in package.json)
 - `assist verify init` - Add verify scripts to a project
 - `assist verify hardcoded-colors` - Check for hardcoded hex colors in src/
 - `assist lint` - Run lint checks for conventions not enforced by biomejs

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.64.2",
+  version: "0.66.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -1333,10 +1333,6 @@ Total: ${lines.length} hardcoded color(s)`);
   }
 }
 
-// src/commands/verify/run/index.ts
-import { spawn } from "child_process";
-import * as path13 from "path";
-
 // src/commands/verify/run/createTimerCallback/printTaskStatuses.ts
 function formatDuration(ms) {
   if (ms < 1e3) {
@@ -1379,41 +1375,87 @@ function initTaskStatuses(scripts) {
   return scripts.map((script) => ({ script, startTime: Date.now() }));
 }
 
-// src/commands/verify/run/index.ts
-function spawnScript(script, cwd) {
-  return spawn("npm", ["run", script], { stdio: "inherit", shell: true, cwd });
-}
-function onScriptClose(script, onComplete, resolve3) {
-  return (code) => {
-    const exitCode = code ?? 1;
-    onComplete?.(exitCode);
-    resolve3({ script, code: exitCode });
-  };
+// src/commands/verify/run/resolveEntries.ts
+import * as path13 from "path";
+function quoteIfNeeded(arg) {
+  return arg.includes(" ") ? `"${arg}"` : arg;
+}
+function buildFullCommand(command, args) {
+  return [quoteIfNeeded(command), ...(args ?? []).map(quoteIfNeeded)].join(" ");
+}
+function getRunEntries() {
+  const { run: run3 } = loadConfig();
+  if (!run3) return [];
+  return run3.filter((r) => r.name.startsWith("verify:")).map((r) => ({
+    name: r.name,
+    fullCommand: buildFullCommand(r.command, r.args)
+  }));
+}
+function getPackageJsonEntries() {
+  const result = findPackageJsonWithVerifyScripts(process.cwd());
+  if (!result) return [];
+  const cwd = path13.dirname(result.packageJsonPath);
+  return result.verifyScripts.map((script) => ({
+    name: script,
+    fullCommand: `npm run ${script}`,
+    cwd
+  }));
+}
+function resolveEntries() {
+  return [...getRunEntries(), ...getPackageJsonEntries()];
+}
+
+// src/commands/verify/run/spawnCommand.ts
+import { spawn } from "child_process";
+var isClaudeCode = !!process.env.CLAUDECODE;
+function spawnCommand(fullCommand, cwd) {
+  return spawn(fullCommand, [], {
+    stdio: isClaudeCode ? "pipe" : "inherit",
+    shell: true,
+    cwd: cwd ?? process.cwd()
+  });
+}
+function collectOutput(child) {
+  if (!isClaudeCode) return [];
+  const chunks = [];
+  child.stdout?.on("data", (data) => chunks.push(data));
+  child.stderr?.on("data", (data) => chunks.push(data));
+  return chunks;
 }
-function runScript(script, cwd, onComplete) {
+function flushIfFailed(exitCode, chunks) {
+  if (exitCode !== 0 && chunks.length > 0) {
+    process.stdout.write(Buffer.concat(chunks));
+  }
+}
+
+// src/commands/verify/run/index.ts
+function runEntry(entry, onComplete) {
   return new Promise((resolve3) => {
-    spawnScript(script, cwd).on(
-      "close",
-      onScriptClose(script, onComplete, resolve3)
-    );
+    const child = spawnCommand(entry.fullCommand, entry.cwd);
+    const chunks = collectOutput(child);
+    child.on("close", (code) => {
+      const exitCode = code ?? 1;
+      flushIfFailed(exitCode, chunks);
+      onComplete?.(exitCode);
+      resolve3({ script: entry.name, code: exitCode });
+    });
   });
 }
-function runAllScripts(verifyScripts, packageDir, timer) {
-  const taskStatuses = initTaskStatuses(verifyScripts);
+function runAllEntries(entries, timer) {
+  const taskStatuses = initTaskStatuses(entries.map((e) => e.name));
   return Promise.all(
-    verifyScripts.map(
-      (script, index) => runScript(
-        script,
-        packageDir,
+    entries.map(
+      (entry, index) => runEntry(
+        entry,
         timer ? createTimerCallback(taskStatuses, index) : void 0
       )
     )
   );
 }
-function printScriptList(scripts) {
-  console.log(`Running ${scripts.length} verify script(s) in parallel:`);
-  for (const script of scripts) {
-    console.log(`  - ${script}`);
+function printEntryList(entries) {
+  console.log(`Running ${entries.length} verify command(s) in parallel:`);
+  for (const entry of entries) {
+    console.log(`  - ${entry.name}`);
   }
 }
 function exitIfFailed(failed) {
@@ -1424,32 +1466,17 @@ function exitIfFailed(failed) {
 function handleResults(results, totalCount) {
   exitIfFailed(results.filter((r) => r.code !== 0));
   console.log(`
-All ${totalCount} verify script(s) passed`);
-}
-function resolveVerifyScripts() {
-  const result = findPackageJsonWithVerifyScripts(process.cwd());
-  if (!result) {
-    console.log("No package.json with verify:* scripts found");
-    return null;
-  }
-  return result;
-}
-function getPackageDir(found) {
-  return path13.dirname(found.packageJsonPath);
-}
-async function executeVerifyScripts(found, timer) {
-  printScriptList(found.verifyScripts);
-  const results = await runAllScripts(
-    found.verifyScripts,
-    getPackageDir(found),
-    timer
-  );
-  handleResults(results, found.verifyScripts.length);
+All ${totalCount} verify command(s) passed`);
 }
 async function run(options2 = {}) {
-  const found = resolveVerifyScripts();
-  if (!found) return;
-  await executeVerifyScripts(found, options2.timer ?? false);
+  const allEntries = resolveEntries();
+  if (allEntries.length === 0) {
+    console.log("No verify commands found");
+    return;
+  }
+  printEntryList(allEntries);
+  const results = await runAllEntries(allEntries, options2.timer ?? false);
+  handleResults(results, allEntries.length);
 }
 
 // src/commands/new/registerNew/initGit.ts
@@ -3125,7 +3152,7 @@ import { join as join14 } from "path";
 import { stringify } from "yaml";
 
 // src/lib/isClaudeCode.ts
-function isClaudeCode() {
+function isClaudeCode2() {
   return process.env.CLAUDECODE !== void 0;
 }
 
@@ -3224,7 +3251,7 @@ function formatForHuman(comment) {
 
 // src/commands/prs/listComments/index.ts
 function formatComment(comment) {
-  return isClaudeCode() ? JSON.stringify(comment) : formatForHuman(comment);
+  return isClaudeCode2() ? JSON.stringify(comment) : formatForHuman(comment);
 }
 function printComments(comments) {
   if (comments.length === 0) {
@@ -3623,7 +3650,7 @@ function getViolations(pattern2, options2 = {}, maxLines = DEFAULT_MAX_LINES) {
 }
 
 // src/commands/refactor/check/index.ts
-function runScript2(script, cwd) {
+function runScript(script, cwd) {
   return new Promise((resolve3) => {
     const child = spawn3("npm", ["run", script], {
       stdio: "pipe",
@@ -3657,7 +3684,7 @@ async function runVerifyQuietly() {
   if (!result) return true;
   const packageDir = path17.dirname(result.packageJsonPath);
   const results = await Promise.all(
-    result.verifyScripts.map((script) => runScript2(script, packageDir))
+    result.verifyScripts.map((script) => runScript(script, packageDir))
   );
   const failed = results.filter((r) => r.code !== 0);
   if (failed.length > 0) {
@@ -4857,7 +4884,7 @@ function registerTranscript(program2) {
 
 // src/commands/registerVerify.ts
 function registerVerify(program2) {
-  const verifyCommand = program2.command("verify").description("Run all verify:* scripts from package.json in parallel").option("--timer", "Show timing information for each task as they complete").action((options2) => run(options2));
+  const verifyCommand = program2.command("verify").description("Run all verify:* commands in parallel").option("--timer", "Show timing information for each task as they complete").action((options2) => run(options2));
   verifyCommand.command("init").description("Add verify scripts to a project").action(init2);
   verifyCommand.command("hardcoded-colors").description("Check for hardcoded hex colors in src/").action(hardcodedColors);
 }
@@ -5072,6 +5099,8 @@ function registerRoam(program2) {
 import { spawn as spawn4 } from "child_process";
 
 // src/commands/run/add.ts
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync17 } from "fs";
+import { join as join21 } from "path";
 function findAddIndex() {
   const addIndex = process.argv.indexOf("add");
   if (addIndex === -1 || addIndex + 2 >= process.argv.length) return -1;
@@ -5124,21 +5153,35 @@ function saveNewRunConfig(name, command, args) {
   runList.push(buildRunEntry(name, command, args));
   saveConfig(config);
 }
+function createCommandFile(name) {
+  const dir = join21(".claude", "commands");
+  mkdirSync7(dir, { recursive: true });
+  const content = `---
+description: Run ${name}
+---
+
+Run \`assist run ${name} $ARGUMENTS 2>&1\`.
+`;
+  const filePath = join21(dir, `${name}.md`);
+  writeFileSync17(filePath, content);
+  console.log(`Created command file: ${filePath}`);
+}
 function add2() {
   const { name, command, args } = requireParsedArgs();
   saveNewRunConfig(name, command, args);
+  createCommandFile(name);
   console.log(
     `Added run configuration: ${name} -> ${formatDisplay(command, args)}`
   );
 }
 
 // src/commands/run/index.ts
-function quoteIfNeeded(arg) {
+function quoteIfNeeded2(arg) {
   return arg.includes(" ") ? `"${arg}"` : arg;
 }
 function buildCommand(command, configArgs, extraArgs) {
   const allArgs = [...configArgs, ...extraArgs];
-  return [quoteIfNeeded(command), ...allArgs.map(quoteIfNeeded)].join(" ");
+  return [quoteIfNeeded2(command), ...allArgs.map(quoteIfNeeded2)].join(" ");
 }
 function printAvailableConfigs(configs) {
   console.error("Available configurations:");
@@ -5168,14 +5211,14 @@ function onSpawnError(err) {
   console.error(`Failed to execute command: ${err.message}`);
   process.exit(1);
 }
-function spawnCommand(fullCommand) {
+function spawnCommand2(fullCommand) {
   const child = spawn4(fullCommand, [], { stdio: "inherit", shell: true });
   child.on("close", (code) => process.exit(code ?? 0));
   child.on("error", onSpawnError);
 }
 function run2(name, args) {
   const runConfig = findRunConfig(name);
-  spawnCommand(buildCommand(runConfig.command, runConfig.args ?? [], args));
+  spawnCommand2(buildCommand(runConfig.command, runConfig.args ?? [], args));
 }
 
 // src/commands/statusLine.ts

package/package.json

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