@joshski/dust 0.1.13 → 0.1.14

package/README.md

@@ -2,7 +2,7 @@
 
 **Flow state for AI coding agents.**
 
-Dust provides a CLI that agents use to systematically blitz through your work queue.
+Dust provides a CLI that agents use to systematically blaze through your backlog.
 
 [![CI](https://github.com/joshski/dust/actions/workflows/ci.yml/badge.svg)](https://github.com/joshski/dust/actions/workflows/ci.yml)
 

package/dist/dust.js

@@ -97,6 +97,20 @@ function loadTemplate(name, variables = {}) {
   return content;
 }
 
+// lib/agents/detection.ts
+function detectAgent(env = process.env) {
+  if (env.CLAUDECODE) {
+    if (env.CLAUDE_CODE_ENTRYPOINT === "remote") {
+      return { type: "claude-code-web", name: "Claude Code Web" };
+    }
+    return { type: "claude-code", name: "Claude Code" };
+  }
+  if (env.CODEX_HOME) {
+    return { type: "codex", name: "Codex" };
+  }
+  return { type: "unknown", name: "Agent" };
+}
+
 // lib/git/hooks.ts
 import { join as join3 } from "node:path";
 var DUST_HOOK_START = "# BEGIN DUST HOOK";
@@ -220,25 +234,13 @@ ${newHookContent}
 }
 
 // lib/cli/commands/agent-shared.ts
-function detectAgent(env = process.env) {
-  if (env.CLAUDECODE) {
-    if (env.CLAUDE_CODE_ENTRYPOINT === "remote") {
-      return "Claude Code Web";
-    }
-    return "Claude Code";
-  }
-  if (env.CODEX_HOME) {
-    return "Codex";
-  }
-  return "Agent";
-}
 function templateVariables(settings, hooksInstalled, env = process.env) {
-  const agentName = detectAgent(env);
+  const agent = detectAgent(env);
   return {
     bin: settings.dustCommand,
-    agentName,
+    agentName: agent.name,
     hooksInstalled: hooksInstalled ? "true" : "false",
-    isClaudeCodeWeb: agentName === "Claude Code Web" ? "true" : ""
+    isClaudeCodeWeb: agent.type === "claude-code-web" ? "true" : ""
   };
 }
 async function manageGitHooks(dependencies) {
@@ -330,6 +332,7 @@ function extractOpeningSentence(content) {
 var REQUIRED_HEADINGS = ["## Goals", "## Blocked by", "## Definition of done"];
 var REQUIRED_GOAL_HEADINGS = ["## Parent Goal", "## Sub-Goals"];
 var SLUG_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*\.md$/;
+var MAX_OPENING_SENTENCE_LENGTH = 150;
 function validateFilename(filePath) {
   const parts = filePath.split("/");
   const filename = parts[parts.length - 1];
@@ -370,6 +373,19 @@ function validateOpeningSentence(filePath, content) {
   }
   return null;
 }
+function validateOpeningSentenceLength(filePath, content) {
+  const openingSentence = extractOpeningSentence(content);
+  if (!openingSentence) {
+    return null;
+  }
+  if (openingSentence.length > MAX_OPENING_SENTENCE_LENGTH) {
+    return {
+      file: filePath,
+      message: `Opening sentence is ${openingSentence.length} characters (max ${MAX_OPENING_SENTENCE_LENGTH}). Split into multiple sentences; only the first sentence is checked.`
+    };
+  }
+  return null;
+}
 function validateTaskHeadings(filePath, content) {
   const violations = [];
   for (const heading of REQUIRED_HEADINGS) {
@@ -662,6 +678,10 @@ async function lintMarkdown(dependencies) {
       if (openingSentenceViolation) {
         violations.push(openingSentenceViolation);
       }
+      const openingSentenceLengthViolation = validateOpeningSentenceLength(filePath, content);
+      if (openingSentenceLengthViolation) {
+        violations.push(openingSentenceLengthViolation);
+      }
       const titleFilenameViolation = validateTitleFilenameMatch(filePath, content);
       if (titleFilenameViolation) {
         violations.push(titleFilenameViolation);
@@ -1202,7 +1222,216 @@ function* parseRawEvent(raw) {
   }
 }
 
+// lib/claude/tool-formatters.ts
+var DIVIDER = "────────────────────────────────";
+function formatWrite(input) {
+  const filePath = input.file_path;
+  const content = input.content;
+  const others = getUnrecognizedArgs(input, ["file_path", "content"]);
+  const lines = [];
+  lines.push(`\uD83D\uDD27 Write: ${filePath ?? "(unknown)"}`);
+  lines.push(DIVIDER);
+  if (content !== undefined) {
+    for (const line of content.split(`
+`)) {
+      lines.push(line);
+    }
+  }
+  lines.push(DIVIDER);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatEdit(input) {
+  const filePath = input.file_path;
+  const oldString = input.old_string;
+  const newString = input.new_string;
+  const others = getUnrecognizedArgs(input, [
+    "file_path",
+    "old_string",
+    "new_string",
+    "replace_all"
+  ]);
+  const lines = [];
+  lines.push(`\uD83D\uDD27 Edit: ${filePath ?? "(unknown)"}`);
+  lines.push("Replace:");
+  lines.push(DIVIDER);
+  if (oldString !== undefined) {
+    for (const line of oldString.split(`
+`)) {
+      lines.push(line);
+    }
+  }
+  lines.push(DIVIDER);
+  lines.push("With:");
+  lines.push(DIVIDER);
+  if (newString !== undefined) {
+    for (const line of newString.split(`
+`)) {
+      lines.push(line);
+    }
+  }
+  lines.push(DIVIDER);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatRead(input) {
+  const filePath = input.file_path;
+  const offset = input.offset;
+  const limit = input.limit;
+  const others = getUnrecognizedArgs(input, ["file_path", "offset", "limit"]);
+  const lines = [];
+  let lineRange = "";
+  if (offset !== undefined || limit !== undefined) {
+    const start = offset ?? 1;
+    const end = limit !== undefined ? start + limit - 1 : undefined;
+    lineRange = end !== undefined ? ` (lines ${start}-${end})` : ` (from line ${start})`;
+  }
+  lines.push(`\uD83D\uDD27 Read: ${filePath ?? "(unknown)"}${lineRange}`);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatBash(input) {
+  const command = input.command;
+  const description = input.description;
+  const others = getUnrecognizedArgs(input, [
+    "command",
+    "description",
+    "timeout",
+    "run_in_background",
+    "dangerouslyDisableSandbox",
+    "_simulatedSedEdit"
+  ]);
+  const lines = [];
+  const header = description ?? "Run command";
+  lines.push(`\uD83D\uDD27 Bash: ${header}`);
+  if (command !== undefined) {
+    lines.push(`$ ${command}`);
+  }
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatTodoWrite(input) {
+  const todos = input.todos;
+  const others = getUnrecognizedArgs(input, ["todos"]);
+  const lines = [];
+  const count = todos?.length ?? 0;
+  lines.push(`\uD83D\uDD27 TodoWrite: ${count} item${count === 1 ? "" : "s"}`);
+  if (todos) {
+    for (const todo of todos) {
+      const icon = todo.status === "completed" ? "☑" : "☐";
+      lines.push(`${icon} ${todo.content}`);
+    }
+  }
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatGrep(input) {
+  const pattern = input.pattern;
+  const path = input.path;
+  const glob = input.glob;
+  const type = input.type;
+  const others = getUnrecognizedArgs(input, [
+    "pattern",
+    "path",
+    "glob",
+    "type",
+    "output_mode",
+    "context",
+    "-A",
+    "-B",
+    "-C",
+    "-i",
+    "-n",
+    "head_limit",
+    "offset",
+    "multiline"
+  ]);
+  const lines = [];
+  const location = path ?? ".";
+  let filter = "";
+  if (glob) {
+    filter = ` (${glob})`;
+  } else if (type) {
+    filter = ` (type: ${type})`;
+  }
+  lines.push(`\uD83D\uDD27 Grep: "${pattern ?? ""}" in ${location}${filter}`);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatGlob(input) {
+  const pattern = input.pattern;
+  const path = input.path;
+  const others = getUnrecognizedArgs(input, ["pattern", "path"]);
+  const lines = [];
+  const location = path ?? ".";
+  lines.push(`\uD83D\uDD27 Glob: ${pattern ?? ""} in ${location}`);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatTask(input) {
+  const description = input.description;
+  const subagentType = input.subagent_type;
+  const prompt = input.prompt;
+  const others = getUnrecognizedArgs(input, [
+    "description",
+    "subagent_type",
+    "prompt",
+    "model",
+    "max_turns",
+    "resume",
+    "run_in_background"
+  ]);
+  const lines = [];
+  const header = description ?? subagentType ?? "task";
+  lines.push(`\uD83D\uDD27 Task: ${header}`);
+  if (prompt !== undefined) {
+    const truncated = prompt.length > 100 ? `${prompt.slice(0, 100)}...` : prompt;
+    lines.push(`"${truncated}"`);
+  }
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatFallback(name, input) {
+  const lines = [];
+  lines.push(`\uD83D\uDD27 Tool: ${name}`);
+  lines.push(`Input: ${JSON.stringify(input, null, 2)}`);
+  return lines;
+}
+var formatters = {
+  Write: formatWrite,
+  Edit: formatEdit,
+  Read: formatRead,
+  Bash: formatBash,
+  TodoWrite: formatTodoWrite,
+  Grep: formatGrep,
+  Glob: formatGlob,
+  Task: formatTask
+};
+function formatToolUse(name, input) {
+  const formatter = formatters[name];
+  if (formatter) {
+    return formatter(input);
+  }
+  return formatFallback(name, input);
+}
+function getUnrecognizedArgs(input, knownKeys) {
+  const others = {};
+  for (const key of Object.keys(input)) {
+    if (!knownKeys.includes(key)) {
+      others[key] = input[key];
+    }
+  }
+  return others;
+}
+function appendOtherArgs(lines, others) {
+  if (Object.keys(others).length > 0) {
+    lines.push("");
+    lines.push(`(Other arguments: ${JSON.stringify(others)})`);
+  }
+}
+
 // lib/claude/streamer.ts
+var DIVIDER2 = "────────────────────────────────";
 async function streamEvents(events, sink) {
   let hadTextOutput = false;
   for await (const raw of events) {
@@ -1226,12 +1455,15 @@ function processEvent(event, sink, state) {
         sink.line("");
         sink.line("");
       }
-      sink.line(`\uD83D\uDD27 Tool: ${event.name}`);
-      sink.line(`   Input: ${JSON.stringify(event.input, null, 2).replace(/\n/g, `
-   `)}`);
+      for (const line of formatToolUse(event.name, event.input)) {
+        sink.line(line);
+      }
       break;
     case "tool_result":
-      sink.line(`✅ Result (${event.content.length} chars)`);
+      sink.line("Result:");
+      sink.line(DIVIDER2);
+      sink.line(event.content);
+      sink.line(DIVIDER2);
       sink.line("");
       break;
     case "result":
@@ -1379,7 +1611,33 @@ async function runOneIteration(dependencies, loopDependencies) {
   context.stdout("\uD83D\uDD04 Syncing with remote...");
   const pullResult = await gitPull(context.cwd, spawn2);
   if (!pullResult.success) {
-    context.stdout(`Note: git pull skipped (${pullResult.message})`);
+    context.stdout(`⚠️  git pull failed: ${pullResult.message}`);
+    context.stdout("");
+    context.stdout("\uD83E\uDD16 Starting Claude to resolve the conflict...");
+    context.stdout("");
+    const prompt = `git pull failed with the following error:
+
+${pullResult.message}
+
+Please resolve this issue. Common approaches:
+1. If there are merge conflicts, resolve them
+2. If local commits need to be rebased, use git rebase
+3. After resolving, commit any changes and push to remote
+
+Make sure the repository is in a clean state and synced with remote before finishing.`;
+    try {
+      await run2(prompt, { cwd: context.cwd, dangerouslySkipPermissions: true });
+      context.stdout("");
+      context.stdout("✅ Claude resolved the git pull conflict. Continuing loop...");
+      context.stdout("");
+      return "resolved_pull_conflict";
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      context.stderr(`Claude failed to resolve git pull conflict: ${message}`);
+      context.stdout("");
+      context.stdout("⚠️  Continuing loop despite unresolved conflict...");
+      context.stdout("");
+    }
   }
   context.stdout("\uD83D\uDD0D Checking for available tasks...");
   const hasTasks = await hasAvailableTasks(dependencies);
@@ -1388,7 +1646,9 @@ async function runOneIteration(dependencies, loopDependencies) {
     context.stdout("");
     return "no_tasks";
   }
-  context.stdout("✨ Found task(s). \uD83E\uDD16 Starting Claude...");
+  context.stdout("✨ Found a task!");
+  context.stdout("");
+  context.stdout("\uD83E\uDD16 Starting Claude...");
   context.stdout("");
   try {
     await run2("go", { cwd: context.cwd, dangerouslySkipPermissions: true });
@@ -1535,12 +1795,13 @@ async function getChangesFromRemote(cwd, gitRunner) {
   }
   return parseGitDiffNameStatus(diffResult.output);
 }
-async function prePush(dependencies, gitRunner = defaultGitRunner) {
+async function prePush(dependencies, gitRunner = defaultGitRunner, env = process.env) {
   const { context } = dependencies;
   const changes = await getChangesFromRemote(context.cwd, gitRunner);
   if (changes.length > 0) {
     const analysis = analyzeChangesForTaskOnlyPattern(changes);
-    if (analysis.isTaskOnly) {
+    const agent2 = detectAgent(env);
+    if (analysis.isTaskOnly && agent2.type === "claude-code-web") {
       context.stderr("");
       context.stderr("⚠️  Task-only commit detected! You added a task but did not implement it.");
       context.stderr("");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.13",
-  "description": "A lightweight planning system for human-AI collaboration",
+  "version": "0.1.14",
+  "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {
     "dust": "./dist/dust.js"