@joshski/dust 0.1.9 → 0.1.10

package/dist/dust.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // lib/cli/entry.ts
 import { existsSync } from "node:fs";
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 
 // lib/cli/templates.ts
 import { readFileSync } from "node:fs";
@@ -9,69 +9,246 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
 var templatesDir = join(__dirname2, "../templates");
+function isTruthy(value) {
+  return value !== undefined && value !== "" && value !== "false";
+}
+function processConditionals(content, variables) {
+  let result = content.replace(/\{\{#if (\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (_, varName, block) => {
+    return isTruthy(variables[varName]) ? block : "";
+  });
+  result = result.replace(/\{\{#unless (\w+)\}\}([\s\S]*?)\{\{\/unless\}\}/g, (_, varName, block) => {
+    return !isTruthy(variables[varName]) ? block : "";
+  });
+  return result;
+}
 function loadTemplate(name, variables = {}) {
   const templatePath = join(templatesDir, `${name}.txt`);
   let content = readFileSync(templatePath, "utf-8");
+  content = processConditionals(content, variables);
   for (const [key, value] of Object.entries(variables)) {
     content = content.replaceAll(`{{${key}}}`, value);
   }
   return content;
 }
 
-// lib/cli/commands/agent.ts
-var AGENT_SUBCOMMANDS = [
-  "new task",
-  "new goal",
-  "new idea",
-  "implement task",
-  "understand goals",
-  "pick task",
-  "help"
-];
-function templateVariables(settings) {
+// lib/git/hooks.ts
+import { join as join2 } from "node:path";
+var DUST_HOOK_START = "# BEGIN DUST HOOK";
+var DUST_HOOK_END = "# END DUST HOOK";
+function generateHookContent(dustCommand) {
+  return `${DUST_HOOK_START}
+${dustCommand} pre push
+if [ $? -ne 0 ]; then
+  echo "dust pre-push check failed"
+  exit 1
+fi
+${DUST_HOOK_END}`;
+}
+function extractDustSection(content) {
+  const startIndex = content.indexOf(DUST_HOOK_START);
+  const endIndex = content.indexOf(DUST_HOOK_END);
+  if (startIndex === -1 || endIndex === -1) {
+    return null;
+  }
+  return content.substring(startIndex, endIndex + DUST_HOOK_END.length);
+}
+function removeDustSection(content) {
+  const startIndex = content.indexOf(DUST_HOOK_START);
+  const endIndex = content.indexOf(DUST_HOOK_END);
+  if (startIndex === -1 || endIndex === -1) {
+    return content;
+  }
+  const before = content.substring(0, startIndex);
+  const after = content.substring(endIndex + DUST_HOOK_END.length);
+  return (before + after).replace(/\n{3,}/g, `
+
+`).trim();
+}
+function createHooksManager(cwd, fileSystem, settings) {
+  const gitDir = join2(cwd, ".git");
+  const hooksDir = join2(gitDir, "hooks");
+  const prePushPath = join2(hooksDir, "pre-push");
+  return {
+    isGitRepo: () => fileSystem.exists(gitDir),
+    isHookInstalled: async () => {
+      if (!fileSystem.exists(prePushPath)) {
+        return false;
+      }
+      try {
+        const content = await fileSystem.readFile(prePushPath);
+        return content.includes(DUST_HOOK_START);
+      } catch {
+        return false;
+      }
+    },
+    installHook: async () => {
+      if (!fileSystem.exists(hooksDir)) {
+        await fileSystem.mkdir(hooksDir, { recursive: true });
+      }
+      const hookContent = generateHookContent(settings.dustCommand);
+      let finalContent;
+      if (fileSystem.exists(prePushPath)) {
+        const existingContent = await fileSystem.readFile(prePushPath);
+        if (existingContent.includes(DUST_HOOK_START)) {
+          const withoutDust = removeDustSection(existingContent);
+          finalContent = withoutDust ? `${withoutDust}
+
+${hookContent}
+` : `#!/bin/sh
+
+${hookContent}
+`;
+        } else {
+          finalContent = `${existingContent.trimEnd()}
+
+${hookContent}
+`;
+        }
+      } else {
+        finalContent = `#!/bin/sh
+
+${hookContent}
+`;
+      }
+      await fileSystem.writeFile(prePushPath, finalContent);
+      await fileSystem.chmod(prePushPath, 493);
+    },
+    getHookBinaryPath: async () => {
+      if (!fileSystem.exists(prePushPath)) {
+        return null;
+      }
+      try {
+        const content = await fileSystem.readFile(prePushPath);
+        const dustSection = extractDustSection(content);
+        if (!dustSection) {
+          return null;
+        }
+        const match = dustSection.match(/^(.+) pre push$/m);
+        return match ? match[1] : null;
+      } catch {
+        return null;
+      }
+    },
+    updateHookBinaryPath: async (newPath) => {
+      if (!fileSystem.exists(prePushPath)) {
+        return;
+      }
+      const content = await fileSystem.readFile(prePushPath);
+      const dustSection = extractDustSection(content);
+      if (!dustSection) {
+        return;
+      }
+      const withoutDust = removeDustSection(content);
+      const newHookContent = generateHookContent(newPath);
+      const finalContent = withoutDust ? `${withoutDust}
+
+${newHookContent}
+` : `#!/bin/sh
+
+${newHookContent}
+`;
+      await fileSystem.writeFile(prePushPath, finalContent);
+      await fileSystem.chmod(prePushPath, 493);
+    }
+  };
+}
+
+// lib/cli/commands/agent-shared.ts
+function templateVariables(settings, hooksInstalled) {
   return {
     bin: settings.dustCommand,
-    installDependenciesHint: settings.installDependenciesHint || "Install any dependencies"
+    installDependenciesHint: settings.installDependenciesHint || "Install any dependencies",
+    hooksInstalled: hooksInstalled ? "true" : "false"
   };
 }
-async function agent(deps) {
-  const { arguments: args, context: ctx, settings } = deps;
-  const verb = args[0];
-  const noun = args[1];
-  const vars = templateVariables(settings);
-  if (!verb) {
-    ctx.stdout(loadTemplate("agent-greeting", vars));
-    return { exitCode: 0 };
+async function manageGitHooks(dependencies) {
+  const { context, fileSystem, settings } = dependencies;
+  const hooks = createHooksManager(context.cwd, fileSystem, settings);
+  if (!hooks.isGitRepo()) {
+    return false;
   }
-  if (verb === "help" && !noun) {
-    ctx.stdout(loadTemplate("agent-help", vars));
-    return { exitCode: 0 };
+  const isInstalled = await hooks.isHookInstalled();
+  if (!isInstalled) {
+    await hooks.installHook();
+    return true;
   }
-  const subcommand = noun ? `${verb} ${noun}` : verb;
-  switch (subcommand) {
-    case "new task":
-      ctx.stdout(loadTemplate("agent-new-task", vars));
-      return { exitCode: 0 };
-    case "new goal":
-      ctx.stdout(loadTemplate("agent-new-goal", vars));
-      return { exitCode: 0 };
-    case "new idea":
-      ctx.stdout(loadTemplate("agent-new-idea", vars));
-      return { exitCode: 0 };
-    case "implement task":
-      ctx.stdout(loadTemplate("agent-implement-task", vars));
-      return { exitCode: 0 };
-    case "understand goals":
-      ctx.stdout(loadTemplate("agent-understand-goals", vars));
-      return { exitCode: 0 };
-    case "pick task":
-      ctx.stdout(loadTemplate("agent-pick-task", vars));
-      return { exitCode: 0 };
-    default:
-      ctx.stderr(`Unknown subcommand: ${subcommand}`);
-      ctx.stderr(`Available: ${AGENT_SUBCOMMANDS.join(", ")}`);
-      return { exitCode: 1 };
+  const hookBinaryPath = await hooks.getHookBinaryPath();
+  if (hookBinaryPath && hookBinaryPath !== settings.dustCommand) {
+    await hooks.updateHookBinaryPath(settings.dustCommand);
   }
+  return true;
+}
+
+// lib/cli/commands/agent.ts
+async function agent(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(loadTemplate("agent-greeting", vars));
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/agent-help.ts
+async function agentHelp(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(loadTemplate("agent-help", vars));
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/agent-implement-task.ts
+async function agentImplementTask(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(loadTemplate("agent-implement-task", vars));
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/agent-new-goal.ts
+async function agentNewGoal(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(loadTemplate("agent-new-goal", vars));
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/agent-new-idea.ts
+async function agentNewIdea(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(loadTemplate("agent-new-idea", vars));
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/agent-new-task.ts
+async function agentNewTask(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(loadTemplate("agent-new-task", vars));
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/agent-pick-task.ts
+async function agentPickTask(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(loadTemplate("agent-pick-task", vars));
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/agent-understand-goals.ts
+async function agentUnderstandGoals(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(loadTemplate("agent-understand-goals", vars));
+  return { exitCode: 0 };
 }
 
 // lib/cli/commands/check.ts
@@ -113,7 +290,7 @@ function validateTaskHeadings(filePath, content) {
   }
   return violations;
 }
-function validateLinks(filePath, content, fs) {
+function validateLinks(filePath, content, fileSystem) {
   const violations = [];
   const lines = content.split(`
 `);
@@ -127,7 +304,7 @@ function validateLinks(filePath, content, fs) {
       if (!linkTarget.startsWith("http://") && !linkTarget.startsWith("https://") && !linkTarget.startsWith("#")) {
         const targetPath = linkTarget.split("#")[0];
         const resolvedPath = resolve(fileDir, targetPath);
-        if (!fs.exists(resolvedPath)) {
+        if (!fileSystem.exists(resolvedPath)) {
           violations.push({
             file: filePath,
             message: `Broken link: "${linkTarget}"`,
@@ -203,31 +380,31 @@ function validateSemanticLinks(filePath, content) {
   }
   return violations;
 }
-async function validate(deps) {
-  const { context: ctx, fileSystem: fs, globScanner: glob } = deps;
-  const dustPath = `${ctx.cwd}/.dust`;
-  if (!fs.exists(dustPath)) {
-    ctx.stderr("Error: .dust directory not found");
-    ctx.stderr("Run 'dust init' to initialize a Dust repository");
+async function validate(dependencies) {
+  const { context, fileSystem, globScanner: glob } = dependencies;
+  const dustPath = `${context.cwd}/.dust`;
+  if (!fileSystem.exists(dustPath)) {
+    context.stderr("Error: .dust directory not found");
+    context.stderr("Run 'dust init' to initialize a Dust repository");
     return { exitCode: 1 };
   }
   const violations = [];
-  ctx.stdout("Validating links in .dust/...");
+  context.stdout("Validating links in .dust/...");
   for await (const file of glob.scan(dustPath)) {
     if (!file.endsWith(".md"))
       continue;
     const filePath = `${dustPath}/${file}`;
-    const content = await fs.readFile(filePath);
-    violations.push(...validateLinks(filePath, content, fs));
+    const content = await fileSystem.readFile(filePath);
+    violations.push(...validateLinks(filePath, content, fileSystem));
   }
   const tasksPath = `${dustPath}/tasks`;
-  if (fs.exists(tasksPath)) {
-    ctx.stdout("Validating task files in .dust/tasks/...");
+  if (fileSystem.exists(tasksPath)) {
+    context.stdout("Validating task files in .dust/tasks/...");
     for await (const file of glob.scan(tasksPath)) {
       if (!file.endsWith(".md"))
         continue;
       const filePath = `${tasksPath}/${file}`;
-      const content = await fs.readFile(filePath);
+      const content = await fileSystem.readFile(filePath);
       const filenameViolation = validateFilename(filePath);
       if (filenameViolation) {
         violations.push(filenameViolation);
@@ -237,15 +414,15 @@ async function validate(deps) {
     }
   }
   if (violations.length === 0) {
-    ctx.stdout("All validations passed!");
+    context.stdout("All validations passed!");
     return { exitCode: 0 };
   }
-  ctx.stderr(`Found ${violations.length} violation(s):`);
-  ctx.stderr("");
+  context.stderr(`Found ${violations.length} violation(s):`);
+  context.stderr("");
   for (const v of violations) {
     const location = v.line ? `:${v.line}` : "";
-    ctx.stderr(`  ${v.file}${location}`);
-    ctx.stderr(`    ${v.message}`);
+    context.stderr(`  ${v.file}${location}`);
+    context.stderr(`    ${v.message}`);
   }
   return { exitCode: 1 };
 }
@@ -266,8 +443,8 @@ function createBufferedRunner(spawnFn) {
         proc.on("close", (code) => {
           resolve2({ exitCode: code ?? 1, output: chunks.join("") });
         });
-        proc.on("error", (err) => {
-          resolve2({ exitCode: 1, output: err.message });
+        proc.on("error", (error) => {
+          resolve2({ exitCode: 1, output: error.message });
         });
       });
     }
@@ -287,16 +464,16 @@ async function runConfiguredChecks(checks, cwd, runner) {
   });
   return Promise.all(promises);
 }
-async function runValidationCheck(deps) {
+async function runValidationCheck(dependencies) {
   const outputLines = [];
-  const bufferedCtx = {
-    cwd: deps.context.cwd,
+  const bufferedContext = {
+    cwd: dependencies.context.cwd,
     stdout: (msg) => outputLines.push(msg),
     stderr: (msg) => outputLines.push(msg)
   };
   const result = await validate({
-    ...deps,
-    context: bufferedCtx,
+    ...dependencies,
+    context: bufferedContext,
     arguments: []
   });
   return {
@@ -308,54 +485,54 @@ async function runValidationCheck(deps) {
     isBuiltIn: true
   };
 }
-function displayResults(results, ctx) {
+function displayResults(results, context) {
   const passed = results.filter((r) => r.exitCode === 0);
   const failed = results.filter((r) => r.exitCode !== 0);
   for (const result of results) {
     if (result.exitCode === 0) {
-      ctx.stdout(`✓ ${result.name}`);
+      context.stdout(`✓ ${result.name}`);
     } else {
-      ctx.stdout(`✗ ${result.name}`);
+      context.stdout(`✗ ${result.name}`);
     }
   }
   for (const result of failed) {
-    ctx.stdout("");
-    ctx.stdout(`> ${result.command}`);
+    context.stdout("");
+    context.stdout(`> ${result.command}`);
     if (result.output.trim()) {
-      ctx.stdout(result.output.trimEnd());
+      context.stdout(result.output.trimEnd());
     }
     if (result.hints && result.hints.length > 0) {
-      ctx.stdout("");
-      ctx.stdout(`Hints for fixing '${result.name}':`);
+      context.stdout("");
+      context.stdout(`Hints for fixing '${result.name}':`);
       for (const hint of result.hints) {
-        ctx.stdout(`  - ${hint}`);
+        context.stdout(`  - ${hint}`);
       }
     }
   }
-  ctx.stdout("");
-  ctx.stdout(`${passed.length}/${results.length} checks passed`);
+  context.stdout("");
+  context.stdout(`${passed.length}/${results.length} checks passed`);
   return failed.length > 0 ? 1 : 0;
 }
-async function check(deps, bufferedRunner = defaultBufferedRunner) {
-  const { context: ctx, fileSystem: fs, settings } = deps;
+async function check(dependencies, bufferedRunner = defaultBufferedRunner) {
+  const { context, fileSystem, settings } = dependencies;
   if (!settings.checks || settings.checks.length === 0) {
-    ctx.stderr("Error: No checks configured in .dust/config/settings.json");
-    ctx.stderr("");
-    ctx.stderr("Add checks to your settings.json:");
-    ctx.stderr("  {");
-    ctx.stderr('    "checks": [');
-    ctx.stderr('      { "name": "lint", "command": "npm run lint" },');
-    ctx.stderr('      { "name": "test", "command": "npm test" }');
-    ctx.stderr("    ]");
-    ctx.stderr("  }");
+    context.stderr("Error: No checks configured in .dust/config/settings.json");
+    context.stderr("");
+    context.stderr("Add checks to your settings.json:");
+    context.stderr("  {");
+    context.stderr('    "checks": [');
+    context.stderr('      { "name": "lint", "command": "npm run lint" },');
+    context.stderr('      { "name": "test", "command": "npm test" }');
+    context.stderr("    ]");
+    context.stderr("  }");
     return { exitCode: 1 };
   }
   const checkPromises = [];
-  const dustPath = `${ctx.cwd}/.dust`;
-  if (fs.exists(dustPath)) {
-    checkPromises.push(runValidationCheck(deps));
+  const dustPath = `${context.cwd}/.dust`;
+  if (fileSystem.exists(dustPath)) {
+    checkPromises.push(runValidationCheck(dependencies));
   }
-  checkPromises.push(runConfiguredChecks(settings.checks, ctx.cwd, bufferedRunner));
+  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, bufferedRunner));
   const promiseResults = await Promise.all(checkPromises);
   const results = [];
   for (const result of promiseResults) {
@@ -365,7 +542,7 @@ async function check(deps, bufferedRunner = defaultBufferedRunner) {
       results.push(result);
     }
   }
-  const exitCode = displayResults(results, ctx);
+  const exitCode = displayResults(results, context);
   return { exitCode };
 }
 
@@ -373,25 +550,40 @@ async function check(deps, bufferedRunner = defaultBufferedRunner) {
 function generateHelpText(settings) {
   return loadTemplate("help", { bin: settings.dustCommand });
 }
-async function help(deps) {
-  deps.context.stdout(generateHelpText(deps.settings));
+async function help(dependencies) {
+  dependencies.context.stdout(generateHelpText(dependencies.settings));
   return { exitCode: 0 };
 }
 
 // lib/cli/settings.ts
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 var DEFAULT_SETTINGS = {
   dustCommand: "npx dust",
   installDependenciesHint: "Install any dependencies"
 };
-function detectDustCommand(cwd, fs) {
-  if (fs.exists(join2(cwd, "bun.lockb"))) {
+function detectInstallDependenciesHint(cwd, fileSystem) {
+  if (fileSystem.exists(join3(cwd, "bun.lockb")) || fileSystem.exists(join3(cwd, "bun.lock"))) {
+    return "Run `bun install`";
+  }
+  if (fileSystem.exists(join3(cwd, "pnpm-lock.yaml"))) {
+    return "Run `pnpm install`";
+  }
+  if (fileSystem.exists(join3(cwd, "package-lock.json"))) {
+    return "Run `npm install`";
+  }
+  if (fileSystem.exists(join3(cwd, "yarn.lock"))) {
+    return "Run `yarn install`";
+  }
+  return "Install any dependencies";
+}
+function detectDustCommand(cwd, fileSystem) {
+  if (fileSystem.exists(join3(cwd, "bun.lockb"))) {
     return "bunx dust";
   }
-  if (fs.exists(join2(cwd, "pnpm-lock.yaml"))) {
+  if (fileSystem.exists(join3(cwd, "pnpm-lock.yaml"))) {
     return "pnpx dust";
   }
-  if (fs.exists(join2(cwd, "package-lock.json"))) {
+  if (fileSystem.exists(join3(cwd, "package-lock.json"))) {
     return "npx dust";
   }
   if (process.env.BUN_INSTALL) {
@@ -399,47 +591,49 @@ function detectDustCommand(cwd, fs) {
   }
   return "npx dust";
 }
-async function loadSettings(cwd, fs) {
-  const settingsPath = join2(cwd, ".dust", "config", "settings.json");
-  if (!fs.exists(settingsPath)) {
+async function loadSettings(cwd, fileSystem) {
+  const settingsPath = join3(cwd, ".dust", "config", "settings.json");
+  if (!fileSystem.exists(settingsPath)) {
     return {
-      dustCommand: detectDustCommand(cwd, fs)
+      dustCommand: detectDustCommand(cwd, fileSystem),
+      installDependenciesHint: detectInstallDependenciesHint(cwd, fileSystem)
     };
   }
   try {
-    const content = await fs.readFile(settingsPath);
+    const content = await fileSystem.readFile(settingsPath);
     const parsed = JSON.parse(content);
-    if (!parsed.dustCommand) {
-      return {
-        ...DEFAULT_SETTINGS,
-        ...parsed,
-        dustCommand: detectDustCommand(cwd, fs)
-      };
-    }
-    return {
+    const result = {
       ...DEFAULT_SETTINGS,
       ...parsed
     };
+    if (!parsed.dustCommand) {
+      result.dustCommand = detectDustCommand(cwd, fileSystem);
+    }
+    if (!parsed.installDependenciesHint) {
+      result.installDependenciesHint = detectInstallDependenciesHint(cwd, fileSystem);
+    }
+    return result;
   } catch {
     return {
-      dustCommand: detectDustCommand(cwd, fs)
+      dustCommand: detectDustCommand(cwd, fileSystem),
+      installDependenciesHint: detectInstallDependenciesHint(cwd, fileSystem)
     };
   }
 }
 
 // lib/cli/commands/init.ts
 var DUST_DIRECTORIES = ["goals", "ideas", "tasks", "facts", "config"];
-function generateSettings(cwd, fs) {
-  const dustCommand = detectDustCommand(cwd, fs);
+function generateSettings(cwd, fileSystem) {
+  const dustCommand = detectDustCommand(cwd, fileSystem);
   const checks = [];
   let installDependenciesHint = "Install any dependencies";
-  if (fs.exists(`${cwd}/bun.lockb`)) {
+  if (fileSystem.exists(`${cwd}/bun.lockb`)) {
     checks.push({ name: "test", command: "bun test" });
     installDependenciesHint = "Run `bun install`";
-  } else if (fs.exists(`${cwd}/pnpm-lock.yaml`)) {
+  } else if (fileSystem.exists(`${cwd}/pnpm-lock.yaml`)) {
     checks.push({ name: "test", command: "pnpm test" });
     installDependenciesHint = "Run `pnpm install`";
-  } else if (fs.exists(`${cwd}/package-lock.json`) || fs.exists(`${cwd}/package.json`)) {
+  } else if (fileSystem.exists(`${cwd}/package-lock.json`) || fileSystem.exists(`${cwd}/package.json`)) {
     checks.push({ name: "test", command: "npm test" });
     installDependenciesHint = "Run `npm install`";
   }
@@ -449,99 +643,277 @@ var USE_DUST_FACT = `# Use dust for planning
 
 This project uses [dust](https://github.com/joshski/dust) for planning and documentation.
 `;
-async function init(deps) {
-  const { context: ctx, fileSystem: fs } = deps;
-  const dustPath = `${ctx.cwd}/.dust`;
-  const dustCommand = detectDustCommand(ctx.cwd, fs);
+async function init(dependencies) {
+  const { context, fileSystem } = dependencies;
+  const dustPath = `${context.cwd}/.dust`;
+  const dustCommand = detectDustCommand(context.cwd, fileSystem);
   const agentInstruction = `Always immediately run \`${dustCommand} agent\` when you start working in this repository.`;
-  if (fs.exists(dustPath)) {
-    ctx.stdout("Note: .dust directory already exists, skipping creation");
+  if (fileSystem.exists(dustPath)) {
+    context.stdout("Note: .dust directory already exists, skipping creation");
   } else {
-    await fs.mkdir(dustPath, { recursive: true });
+    await fileSystem.mkdir(dustPath, { recursive: true });
     for (const dir of DUST_DIRECTORIES) {
-      await fs.mkdir(`${dustPath}/${dir}`, { recursive: true });
+      await fileSystem.mkdir(`${dustPath}/${dir}`, { recursive: true });
     }
-    await fs.writeFile(`${dustPath}/facts/use-dust-for-planning.md`, USE_DUST_FACT);
-    const settings = generateSettings(ctx.cwd, fs);
-    await fs.writeFile(`${dustPath}/config/settings.json`, `${JSON.stringify(settings, null, 2)}
+    await fileSystem.writeFile(`${dustPath}/facts/use-dust-for-planning.md`, USE_DUST_FACT);
+    const settings = generateSettings(context.cwd, fileSystem);
+    await fileSystem.writeFile(`${dustPath}/config/settings.json`, `${JSON.stringify(settings, null, 2)}
 `);
-    ctx.stdout("Initialized Dust repository in .dust/");
-    ctx.stdout(`Created directories: ${DUST_DIRECTORIES.join(", ")}`);
-    ctx.stdout("Created initial fact: .dust/facts/use-dust-for-planning.md");
-    ctx.stdout("Created settings: .dust/config/settings.json");
-  }
-  const claudeMdPath = `${ctx.cwd}/CLAUDE.md`;
-  if (fs.exists(claudeMdPath)) {
-    ctx.stdout(`Warning: CLAUDE.md already exists. Consider adding: "${agentInstruction}"`);
+    context.stdout("Initialized Dust repository in .dust/");
+    context.stdout(`Created directories: ${DUST_DIRECTORIES.join(", ")}`);
+    context.stdout("Created initial fact: .dust/facts/use-dust-for-planning.md");
+    context.stdout("Created settings: .dust/config/settings.json");
+  }
+  const claudeMdPath = `${context.cwd}/CLAUDE.md`;
+  if (fileSystem.exists(claudeMdPath)) {
+    context.stdout(`Warning: CLAUDE.md already exists. Consider adding: "${agentInstruction}"`);
   } else {
     const claudeContent = loadTemplate("claude-md", { dustCommand });
-    await fs.writeFile(claudeMdPath, claudeContent);
-    ctx.stdout("Created CLAUDE.md with agent instructions");
+    await fileSystem.writeFile(claudeMdPath, claudeContent);
+    context.stdout("Created CLAUDE.md with agent instructions");
   }
-  const agentsMdPath = `${ctx.cwd}/AGENTS.md`;
-  if (fs.exists(agentsMdPath)) {
-    ctx.stdout(`Warning: AGENTS.md already exists. Consider adding: "${agentInstruction}"`);
+  const agentsMdPath = `${context.cwd}/AGENTS.md`;
+  if (fileSystem.exists(agentsMdPath)) {
+    context.stdout(`Warning: AGENTS.md already exists. Consider adding: "${agentInstruction}"`);
   } else {
     const agentsContent = loadTemplate("agents-md", { dustCommand });
-    await fs.writeFile(agentsMdPath, agentsContent);
-    ctx.stdout("Created AGENTS.md with agent instructions");
+    await fileSystem.writeFile(agentsMdPath, agentsContent);
+    context.stdout("Created AGENTS.md with agent instructions");
   }
   const runner = dustCommand.split(" ")[0];
-  ctx.stdout("");
-  ctx.stdout("Commit the changes if you are happy, then get planning!");
-  ctx.stdout("");
-  ctx.stdout("If this is a new repository, you can start adding ideas or tasks right away:");
-  ctx.stdout(`> ${runner} claude "Idea: friendly UI for non-technical users"`);
-  ctx.stdout(`> ${runner} codex "Task: set up code coverage"`);
-  ctx.stdout("");
-  ctx.stdout("If this is an existing codebase, you might want to backfill goals and facts:");
-  ctx.stdout(`> ${runner} claude "Add goals and facts based on the code in this repository"`);
+  context.stdout("");
+  context.stdout("Commit the changes if you are happy, then get planning!");
+  context.stdout("");
+  context.stdout("If this is a new repository, you can start adding ideas or tasks right away:");
+  context.stdout(`> ${runner} claude "Idea: friendly UI for non-technical users"`);
+  context.stdout(`> ${runner} codex "Task: set up code coverage"`);
+  context.stdout("");
+  context.stdout("If this is an existing codebase, you might want to backfill goals and facts:");
+  context.stdout(`> ${runner} claude "Add goals and facts based on the code in this repository"`);
   return { exitCode: 0 };
 }
 
 // lib/cli/commands/list.ts
 var VALID_TYPES = ["tasks", "ideas", "goals", "facts"];
-async function list(deps) {
-  const { arguments: args, context: ctx, fileSystem: fs } = deps;
-  const dustPath = `${ctx.cwd}/.dust`;
-  if (!fs.exists(dustPath)) {
-    ctx.stderr("Error: .dust directory not found");
-    ctx.stderr("Run 'dust init' to initialize a Dust repository");
+async function list(dependencies) {
+  const { arguments: commandArguments, context, fileSystem } = dependencies;
+  const dustPath = `${context.cwd}/.dust`;
+  if (!fileSystem.exists(dustPath)) {
+    context.stderr("Error: .dust directory not found");
+    context.stderr("Run 'dust init' to initialize a Dust repository");
     return { exitCode: 1 };
   }
-  const typesToList = args.length === 0 ? [...VALID_TYPES] : args.filter((a) => VALID_TYPES.includes(a));
-  if (args.length > 0 && typesToList.length === 0) {
-    ctx.stderr(`Invalid type: ${args[0]}`);
-    ctx.stderr(`Valid types: ${VALID_TYPES.join(", ")}`);
+  const typesToList = commandArguments.length === 0 ? [...VALID_TYPES] : commandArguments.filter((a) => VALID_TYPES.includes(a));
+  if (commandArguments.length > 0 && typesToList.length === 0) {
+    context.stderr(`Invalid type: ${commandArguments[0]}`);
+    context.stderr(`Valid types: ${VALID_TYPES.join(", ")}`);
     return { exitCode: 1 };
   }
   for (const type of typesToList) {
     const dirPath = `${dustPath}/${type}`;
-    if (!fs.exists(dirPath)) {
+    if (!fileSystem.exists(dirPath)) {
       continue;
     }
-    const files = await fs.readdir(dirPath);
+    const files = await fileSystem.readdir(dirPath);
     const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
     if (mdFiles.length === 0) {
       continue;
     }
-    ctx.stdout(`${type}:`);
+    context.stdout(`${type}:`);
     for (const file of mdFiles) {
       const filePath = `${dirPath}/${file}`;
-      const content = await fs.readFile(filePath);
+      const content = await fileSystem.readFile(filePath);
       const title = extractTitle(content);
       const name = file.replace(/\.md$/, "");
       if (title) {
-        ctx.stdout(`  ${name} - ${title}`);
+        context.stdout(`  ${name} - ${title}`);
       } else {
-        ctx.stdout(`  ${name}`);
+        context.stdout(`  ${name}`);
       }
     }
-    ctx.stdout("");
+    context.stdout("");
   }
   return { exitCode: 0 };
 }
 
+// lib/cli/commands/loop.ts
+import { spawn as nodeSpawn2 } from "node:child_process";
+
+// lib/claude/spawn-claude-code.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { createInterface as nodeCreateInterface } from "node:readline";
+var defaultDependencies = {
+  spawn: nodeSpawn,
+  createInterface: nodeCreateInterface
+};
+async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDependencies) {
+  const {
+    cwd,
+    allowedTools,
+    maxTurns,
+    model,
+    systemPrompt,
+    sessionId,
+    dangerouslySkipPermissions
+  } = options;
+  const claudeArguments = [
+    "-p",
+    prompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--include-partial-messages"
+  ];
+  if (allowedTools?.length) {
+    claudeArguments.push("--allowedTools", ...allowedTools);
+  }
+  if (maxTurns) {
+    claudeArguments.push("--max-turns", String(maxTurns));
+  }
+  if (model) {
+    claudeArguments.push("--model", model);
+  }
+  if (systemPrompt) {
+    claudeArguments.push("--system-prompt", systemPrompt);
+  }
+  if (sessionId) {
+    claudeArguments.push("--session-id", sessionId);
+  }
+  if (dangerouslySkipPermissions) {
+    claudeArguments.push("--dangerously-skip-permissions");
+  }
+  const proc = dependencies.spawn("claude", claudeArguments, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (!proc.stdout) {
+    throw new Error("Failed to get stdout from claude process");
+  }
+  const rl = dependencies.createInterface({ input: proc.stdout });
+  for await (const line of rl) {
+    if (!line.trim())
+      continue;
+    try {
+      yield JSON.parse(line);
+    } catch {}
+  }
+  await new Promise((resolve2, reject) => {
+    proc.on("close", (code) => {
+      if (code === 0 || code === null)
+        resolve2();
+      else
+        reject(new Error(`claude exited with code ${code}`));
+    });
+    proc.on("error", reject);
+  });
+}
+
+// lib/claude/event-parser.ts
+function* parseRawEvent(raw) {
+  if (raw.type === "stream_event") {
+    const event = raw.event;
+    if (event?.delta?.type === "text_delta" && event.delta.text) {
+      yield { type: "text_delta", text: event.delta.text };
+    }
+  } else if (raw.type === "assistant") {
+    const msg = raw;
+    const content = msg.message?.content ?? [];
+    yield { type: "assistant_message", content };
+    for (const block of content) {
+      if (block.type === "tool_use" && block.id && block.name && block.input) {
+        yield {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      }
+    }
+  } else if (raw.type === "user") {
+    const msg = raw;
+    for (const block of msg.message?.content ?? []) {
+      if (block.type === "tool_result" && block.tool_use_id) {
+        yield {
+          type: "tool_result",
+          toolUseId: block.tool_use_id,
+          content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+        };
+      }
+    }
+  } else if (raw.type === "result") {
+    const r = raw;
+    yield {
+      type: "result",
+      subtype: r.subtype ?? "success",
+      result: r.result,
+      error: r.error,
+      cost_usd: r.total_cost_usd ?? r.cost_usd ?? 0,
+      duration_ms: r.duration_ms ?? 0,
+      num_turns: r.num_turns ?? 0,
+      session_id: r.session_id ?? ""
+    };
+  }
+}
+
+// lib/claude/streamer.ts
+async function streamEvents(events, sink) {
+  let hadTextOutput = false;
+  for await (const raw of events) {
+    for (const event of parseRawEvent(raw)) {
+      processEvent(event, sink, { hadTextOutput });
+      if (event.type === "text_delta") {
+        hadTextOutput = true;
+      } else if (event.type === "tool_use") {
+        hadTextOutput = false;
+      }
+    }
+  }
+}
+function processEvent(event, sink, state) {
+  switch (event.type) {
+    case "text_delta":
+      sink.write(event.text);
+      break;
+    case "tool_use":
+      if (state.hadTextOutput) {
+        sink.line("");
+        sink.line("");
+      }
+      sink.line(`\uD83D\uDD27 Tool: ${event.name}`);
+      sink.line(`   Input: ${JSON.stringify(event.input, null, 2).replace(/\n/g, `
+   `)}`);
+      break;
+    case "tool_result":
+      sink.line(`✅ Result (${event.content.length} chars)`);
+      sink.line("");
+      break;
+    case "result":
+      sink.line("");
+      sink.line(`\uD83C\uDFC1 Done: ${event.subtype}, ${event.num_turns} turns, $${event.cost_usd.toFixed(4)}`);
+      break;
+    case "assistant_message":
+      break;
+  }
+}
+function createStdoutSink() {
+  return {
+    write: (text) => process.stdout.write(text),
+    line: (text) => console.log(text)
+  };
+}
+
+// lib/claude/run.ts
+var defaultRunnerDependencies = {
+  spawnClaudeCode,
+  createStdoutSink,
+  streamEvents
+};
+async function run(prompt, options = {}, dependencies = defaultRunnerDependencies) {
+  const events = dependencies.spawnClaudeCode(prompt, options);
+  const sink = dependencies.createStdoutSink();
+  await dependencies.streamEvents(events, sink);
+}
+
 // lib/cli/commands/next.ts
 function extractBlockedBy(content) {
   const blockedByMatch = content.match(/^## Blocked by\s*\n([\s\S]*?)(?=\n## |\n*$)/m);
@@ -561,19 +933,19 @@ function extractBlockedBy(content) {
   }
   return blockers;
 }
-async function next(deps) {
-  const { context: ctx, fileSystem: fs } = deps;
-  const dustPath = `${ctx.cwd}/.dust`;
-  if (!fs.exists(dustPath)) {
-    ctx.stderr("Error: .dust directory not found");
-    ctx.stderr("Run 'dust init' to initialize a Dust repository");
+async function next(dependencies) {
+  const { context, fileSystem } = dependencies;
+  const dustPath = `${context.cwd}/.dust`;
+  if (!fileSystem.exists(dustPath)) {
+    context.stderr("Error: .dust directory not found");
+    context.stderr("Run 'dust init' to initialize a Dust repository");
     return { exitCode: 1 };
   }
   const tasksPath = `${dustPath}/tasks`;
-  if (!fs.exists(tasksPath)) {
+  if (!fileSystem.exists(tasksPath)) {
     return { exitCode: 0 };
   }
-  const files = await fs.readdir(tasksPath);
+  const files = await fileSystem.readdir(tasksPath);
   const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
   if (mdFiles.length === 0) {
     return { exitCode: 0 };
@@ -582,7 +954,7 @@ async function next(deps) {
   const unblockedTasks = [];
   for (const file of mdFiles) {
     const filePath = `${tasksPath}/${file}`;
-    const content = await fs.readFile(filePath);
+    const content = await fileSystem.readFile(filePath);
     const blockers = extractBlockedBy(content);
     const hasIncompleteBlocker = blockers.some((blocker) => existingTasks.has(blocker));
     if (!hasIncompleteBlocker) {
@@ -594,17 +966,111 @@ async function next(deps) {
   if (unblockedTasks.length === 0) {
     return { exitCode: 0 };
   }
-  ctx.stdout("Next tasks:");
+  context.stdout("Next tasks:");
   for (const task of unblockedTasks) {
     if (task.title) {
-      ctx.stdout(`  ${task.path} - ${task.title}`);
+      context.stdout(`  ${task.path} - ${task.title}`);
     } else {
-      ctx.stdout(`  ${task.path}`);
+      context.stdout(`  ${task.path}`);
     }
   }
   return { exitCode: 0 };
 }
 
+// lib/cli/commands/loop.ts
+function createDefaultDependencies() {
+  return {
+    spawn: nodeSpawn2,
+    run,
+    sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
+  };
+}
+var SLEEP_INTERVAL_MS = 30000;
+async function gitPull(cwd, spawn2) {
+  return new Promise((resolve2) => {
+    const proc = spawn2("git", ["pull"], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve2({ success: true });
+      } else {
+        resolve2({ success: false, message: stderr.trim() || "git pull failed" });
+      }
+    });
+    proc.on("error", (error) => {
+      resolve2({ success: false, message: error.message });
+    });
+  });
+}
+async function hasAvailableTasks(dependencies) {
+  let hasOutput = false;
+  const captureContext = {
+    ...dependencies.context,
+    stdout: () => {
+      hasOutput = true;
+    }
+  };
+  await next({ ...dependencies, context: captureContext });
+  return hasOutput;
+}
+async function runOneIteration(dependencies, loopDependencies) {
+  const { context } = dependencies;
+  const { spawn: spawn2, run: run2 } = loopDependencies;
+  context.stdout("Syncing with remote...");
+  const pullResult = await gitPull(context.cwd, spawn2);
+  if (!pullResult.success) {
+    context.stdout(`Note: git pull skipped (${pullResult.message})`);
+  }
+  context.stdout("Checking for available tasks...");
+  const hasTasks = await hasAvailableTasks(dependencies);
+  if (!hasTasks) {
+    context.stdout("No tasks available. Sleeping...");
+    context.stdout("");
+    return "no_tasks";
+  }
+  context.stdout("Found task(s). Starting Claude...");
+  context.stdout("");
+  try {
+    await run2("go", { cwd: context.cwd, dangerouslySkipPermissions: true });
+    context.stdout("");
+    context.stdout("Claude session complete. Continuing loop...");
+    context.stdout("");
+    return "ran_claude";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    context.stderr(`Claude exited with error: ${message}`);
+    context.stdout("");
+    context.stdout("Claude session complete. Continuing loop...");
+    context.stdout("");
+    return "claude_error";
+  }
+}
+async function loop(dependencies, loopDependencies = createDefaultDependencies()) {
+  const { context } = dependencies;
+  context.stdout("WARNING: This command skips all permission checks. Only use in a sandbox environment!");
+  context.stdout("");
+  context.stdout("Starting dust loop...");
+  context.stdout("Press Ctrl+C to stop");
+  context.stdout("");
+  while (true) {
+    const result = await runOneIteration(dependencies, loopDependencies);
+    if (result === "no_tasks") {
+      await loopDependencies.sleep(SLEEP_INTERVAL_MS);
+    }
+  }
+}
+
+// lib/cli/commands/pre-push.ts
+async function prePush(dependencies) {
+  return check(dependencies);
+}
+
 // lib/cli/main.ts
 var commandRegistry = {
   init,
@@ -613,9 +1079,18 @@ var commandRegistry = {
   next,
   check,
   agent,
+  "agent-help": agentHelp,
+  "agent-new-task": agentNewTask,
+  "agent-new-goal": agentNewGoal,
+  "agent-new-idea": agentNewIdea,
+  "agent-implement-task": agentImplementTask,
+  "agent-pick-task": agentPickTask,
+  "agent-understand-goals": agentUnderstandGoals,
+  loop,
+  "pre-push": prePush,
   help
 };
-var COMMANDS = Object.keys(commandRegistry);
+var COMMANDS = Object.keys(commandRegistry).filter((cmd) => !cmd.includes("-"));
 var HELP_TEXT = generateHelpText({ dustCommand: "dust" });
 function isHelpRequest(command) {
   return !command || command === "help" || command === "--help" || command === "-h";
@@ -623,60 +1098,80 @@ function isHelpRequest(command) {
 function isValidCommand(command) {
   return command in commandRegistry;
 }
-async function runCommand(command, deps) {
-  return commandRegistry[command](deps);
+async function runCommand(command, dependencies) {
+  return commandRegistry[command](dependencies);
+}
+function resolveCommand(commandArguments) {
+  for (let i = commandArguments.length;i > 0; i--) {
+    const candidate = commandArguments.slice(0, i).join("-");
+    if (candidate in commandRegistry) {
+      return { command: candidate, remaining: commandArguments.slice(i) };
+    }
+  }
+  return { command: null, remaining: commandArguments };
 }
 async function main(options) {
-  const { args, ctx, fs, glob } = options;
-  const command = args[0];
-  const commandArgs = args.slice(1);
-  const settings = await loadSettings(ctx.cwd, fs);
+  const { commandArguments, context, fileSystem, glob } = options;
+  const settings = await loadSettings(context.cwd, fileSystem);
   const helpText = generateHelpText(settings);
-  if (isHelpRequest(command)) {
-    ctx.stdout(helpText);
+  if (isHelpRequest(commandArguments[0])) {
+    context.stdout(helpText);
     return { exitCode: 0 };
   }
-  if (!isValidCommand(command)) {
-    ctx.stderr(`Unknown command: ${command}`);
-    ctx.stderr(`Run '${settings.dustCommand} help' for available commands`);
+  const { command, remaining } = resolveCommand(commandArguments);
+  if (!command || !isValidCommand(command)) {
+    context.stderr(`Unknown command: ${commandArguments.join(" ")}`);
+    context.stderr(`Run '${settings.dustCommand} help' for available commands`);
     return { exitCode: 1 };
   }
-  const deps = {
-    arguments: commandArgs,
-    context: ctx,
-    fileSystem: fs,
+  const dependencies = {
+    arguments: remaining,
+    context,
+    fileSystem,
     globScanner: glob,
     settings
   };
-  return runCommand(command, deps);
+  return runCommand(command, dependencies);
 }
 
-// lib/cli/entry.ts
-var fs = {
-  exists: existsSync,
-  readFile: (path) => readFile(path, "utf-8"),
-  writeFile: (path, content) => writeFile(path, content, "utf-8"),
-  mkdir: async (path, options) => {
-    await mkdir(path, options);
-  },
-  readdir: (path) => readdir(path)
-};
-var glob = {
-  scan: async function* (dir) {
-    for (const entry of await readdir(dir, { recursive: true })) {
-      if (entry.endsWith(".md"))
-        yield entry;
+// lib/cli/entry-wiring.ts
+function createFileSystem(primitives) {
+  return {
+    exists: primitives.existsSync,
+    readFile: (path) => primitives.readFile(path, "utf-8"),
+    writeFile: (path, content) => primitives.writeFile(path, content, "utf-8"),
+    mkdir: async (path, options) => {
+      await primitives.mkdir(path, options);
+    },
+    readdir: (path) => primitives.readdir(path),
+    chmod: (path, mode) => primitives.chmod(path, mode)
+  };
+}
+function createGlobScanner(readdir) {
+  return {
+    scan: async function* (dir) {
+      for (const entry of await readdir(dir, { recursive: true })) {
+        if (entry.endsWith(".md"))
+          yield entry;
+      }
     }
-  }
-};
-var result = await main({
-  args: process.argv.slice(2),
-  ctx: {
-    cwd: process.cwd(),
-    stdout: console.log,
-    stderr: console.error
-  },
-  fs,
-  glob
-});
-process.exit(result.exitCode);
+  };
+}
+async function wireEntry(fsPrimitives, processPrimitives, consolePrimitives) {
+  const fileSystem = createFileSystem(fsPrimitives);
+  const glob = createGlobScanner(fsPrimitives.readdir);
+  const result = await main({
+    commandArguments: processPrimitives.argv.slice(2),
+    context: {
+      cwd: processPrimitives.cwd(),
+      stdout: consolePrimitives.log,
+      stderr: consolePrimitives.error
+    },
+    fileSystem,
+    glob
+  });
+  processPrimitives.exit(result.exitCode);
+}
+
+// lib/cli/entry.ts
+await wireEntry({ existsSync, readFile, writeFile, mkdir, readdir, chmod }, { argv: process.argv, cwd: () => process.cwd(), exit: process.exit }, { log: console.log, error: console.error });