@joshski/dust 0.1.85 → 0.1.87

package/dist/artifacts.js

@@ -276,6 +276,18 @@ var EXPEDITE_IDEA_PREFIX = "Expedite Idea: ";
 function titleToFilename(title) {
   return `${title.toLowerCase().replace(/\./g, "-").replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}.md`;
 }
+var WORKFLOW_HINT_PATHS = {
+  refine: "config/workflow-hints/refine.md",
+  "decompose-idea": "config/workflow-hints/decompose-idea.md",
+  shelve: "config/workflow-hints/shelve.md"
+};
+async function readWorkflowHint(fileSystem, dustPath, workflowType) {
+  const hintPath = `${dustPath}/${WORKFLOW_HINT_PATHS[workflowType]}`;
+  if (!fileSystem.exists(hintPath)) {
+    return null;
+  }
+  return fileSystem.readFile(hintPath);
+}
 var WORKFLOW_SECTION_HEADINGS = [
   { type: "refine", heading: "Refines Idea" },
   { type: "decompose-idea", heading: "Decomposes Idea" },
@@ -418,12 +430,16 @@ ${definitionOfDone.map((item) => `- [ ] ${item}`).join(`
 `)}
 `;
 }
-async function createIdeaTransitionTask(fileSystem, dustPath, prefix, ideaSlug, openingSentenceTemplate, definitionOfDone, ideaSectionHeading, taskOptions) {
+async function createIdeaTransitionTask(fileSystem, dustPath, workflowType, prefix, ideaSlug, openingSentenceTemplate, definitionOfDone, ideaSectionHeading, taskOptions) {
   const ideaTitle = await readIdeaTitle(fileSystem, dustPath, ideaSlug);
   const taskTitle = `${prefix}${ideaTitle}`;
   const filename = titleToFilename(taskTitle);
   const filePath = `${dustPath}/tasks/${filename}`;
-  const openingSentence = openingSentenceTemplate(ideaTitle);
+  const baseOpeningSentence = openingSentenceTemplate(ideaTitle);
+  const hint = await readWorkflowHint(fileSystem, dustPath, workflowType);
+  const openingSentence = hint ? `${baseOpeningSentence}
+
+${hint}` : baseOpeningSentence;
   const ideaSection = { heading: ideaSectionHeading, ideaTitle, ideaSlug };
   const content = renderTask(taskTitle, openingSentence, definitionOfDone, ideaSection, {
     description: taskOptions?.description,
@@ -434,7 +450,7 @@ async function createIdeaTransitionTask(fileSystem, dustPath, prefix, ideaSlug,
 }
 async function createRefineIdeaTask(fileSystem, dustPath, ideaSlug, description, dustCommand) {
   const cmd = dustCommand ?? "dust";
-  return createIdeaTransitionTask(fileSystem, dustPath, "Refine Idea: ", ideaSlug, (ideaTitle) => `Thoroughly research this idea and refine it into a well-defined proposal. Read the idea file, explore the codebase for relevant context, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. Run \`${cmd} principles\` for alignment and \`${cmd} facts\` for relevant design decisions. See [${ideaTitle}](../ideas/${ideaSlug}.md). If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking.`, [
+  return createIdeaTransitionTask(fileSystem, dustPath, "refine", "Refine Idea: ", ideaSlug, (ideaTitle) => `Thoroughly research this idea and refine it into a well-defined proposal. Read the idea file, explore the codebase for relevant context, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. Run \`${cmd} principles\` for alignment and \`${cmd} facts\` for relevant design decisions. See [${ideaTitle}](../ideas/${ideaSlug}.md). If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking.`, [
     "Idea is thoroughly researched with relevant codebase context",
     "Open questions are added for any ambiguous or underspecified aspects",
     "Open questions follow the required heading format and focus on high-value decisions",
@@ -443,7 +459,7 @@ async function createRefineIdeaTask(fileSystem, dustPath, ideaSlug, description,
 }
 async function decomposeIdea(fileSystem, dustPath, options, dustCommand) {
   const cmd = dustCommand ?? "dust";
-  return createIdeaTransitionTask(fileSystem, dustPath, "Decompose Idea: ", options.ideaSlug, (ideaTitle) => `Create one or more well-defined tasks from this idea. Prefer smaller, narrowly scoped tasks that each deliver a thin but complete vertical slice of working software -- a path through the system that can be tested end-to-end -- rather than component-oriented tasks (like "add schema" or "build endpoint") that only work once all tasks are done. Split the idea into multiple tasks if it covers more than one logical change. Run \`${cmd} principles\` to link relevant principles and \`${cmd} facts\` for design decisions that should inform the task. See [${ideaTitle}](../ideas/${options.ideaSlug}.md).`, [
+  return createIdeaTransitionTask(fileSystem, dustPath, "decompose-idea", "Decompose Idea: ", options.ideaSlug, (ideaTitle) => `Create one or more well-defined tasks from this idea. Prefer smaller, narrowly scoped tasks that each deliver a thin but complete vertical slice of working software -- a path through the system that can be tested end-to-end -- rather than component-oriented tasks (like "add schema" or "build endpoint") that only work once all tasks are done. Split the idea into multiple tasks if it covers more than one logical change. Run \`${cmd} principles\` to link relevant principles and \`${cmd} facts\` for design decisions that should inform the task. See [${ideaTitle}](../ideas/${options.ideaSlug}.md).`, [
     "One or more new tasks are created in .dust/tasks/",
     "Task's Principles section links to relevant principles from .dust/principles/",
     "The original idea is deleted or updated to reflect remaining scope"
@@ -453,7 +469,7 @@ async function decomposeIdea(fileSystem, dustPath, options, dustCommand) {
   });
 }
 async function createShelveIdeaTask(fileSystem, dustPath, ideaSlug, description, _dustCommand) {
-  return createIdeaTransitionTask(fileSystem, dustPath, "Shelve Idea: ", ideaSlug, (ideaTitle) => `Archive this idea and remove it from the active backlog. See [${ideaTitle}](../ideas/${ideaSlug}.md).`, ["Idea file is deleted", "Rationale is recorded in the commit message"], "Shelves Idea", { description });
+  return createIdeaTransitionTask(fileSystem, dustPath, "shelve", "Shelve Idea: ", ideaSlug, (ideaTitle) => `Archive this idea and remove it from the active backlog. See [${ideaTitle}](../ideas/${ideaSlug}.md).`, ["Idea file is deleted", "Rationale is recorded in the commit message"], "Shelves Idea", { description });
 }
 async function createIdeaTask(fileSystem, dustPath, options) {
   const { title, description, expedite, dustCommand } = options;

package/dist/bucket/repository-loop.d.ts

@@ -8,6 +8,7 @@ import type { AgentSessionEvent, EventMessage } from '../agent-events';
 import { type run as claudeRun, type RunnerDependencies } from '../claude/run';
 import type { OutputSink } from '../claude/types';
 import { type LoopEmitFn, type SendAgentEventFn } from '../cli/commands/loop';
+import { type RunnerDependencies as CodexRunnerDependencies, run as codexRun } from '../codex/run';
 import type { SendEventFn } from './events';
 import { type LogBuffer } from './log-buffer';
 import type { RepositoryDependencies, RepositoryState } from './repository';
@@ -53,10 +54,20 @@ export interface LoopState {
  * Create an OutputSink that buffers stdout and logs complete lines.
  */
 export declare function createBufferStdoutSink(loopState: LoopState, logBuffer: LogBuffer): OutputSink;
+/**
+ * Create a factory function that produces OutputSinks for agent runners.
+ * This factory captures loopState and logBuffer, returning a function
+ * that can be passed to RunnerDependencies.createStdoutSink.
+ */
+export declare function createStdoutSinkFactory(loopState: LoopState, logBuffer: LogBuffer): () => OutputSink;
 /**
  * Create a run function that redirects Claude output to a log buffer.
  */
 export declare function createBufferRun(run: RepositoryDependencies['run'], bufferSinkDeps: RunnerDependencies): typeof claudeRun;
+/**
+ * Create a run function that redirects Codex output to a log buffer.
+ */
+export declare function createCodexBufferRun(run: typeof codexRun, codexBufferSinkDeps: CodexRunnerDependencies): typeof claudeRun;
 /** No-op postEvent for LoopDependencies. */
 export declare function noOpPostEvent(): Promise<void>;
 /**

package/dist/bucket/repository.d.ts

@@ -10,6 +10,7 @@ import type { CommandDependencies, FileSystem } from '../cli/types';
 import type { DockerDependencies } from '../docker/docker-agent';
 import { type BucketEmitFn, type SendEventFn } from './events';
 import { type LogBuffer } from './log-buffer';
+import type { ToolDefinition } from './server-messages';
 export { cloneRepository, getRepoPath, removeRepository, } from './repository-git';
 export { runRepositoryLoop } from './repository-loop';
 export interface Repository {
@@ -50,6 +51,8 @@ export interface RepositoryDependencies {
     getReposDir: () => string;
     /** Optional overrides for Docker dependency functions (for testing) */
     dockerDeps?: Partial<DockerDependencies>;
+    /** Function to get current tool definitions */
+    getTools?: () => ToolDefinition[];
 }
 /**
  * Start (or restart) the per-repository loop and keep loopPromise state accurate.

package/dist/bucket/server-messages.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Typed server-to-client WebSocket messages for the bucket protocol.
+ */
+import type { Repository } from './repository';
+export interface RepositoryListMessage {
+    type: 'repository-list';
+    repositories: RepositoryListItem[];
+}
+export interface RepositoryListItem extends Repository {
+    hasTask: boolean;
+}
+export interface TaskAvailableMessage {
+    type: 'task-available';
+    repository: string;
+}
+export interface ToolParameter {
+    name: string;
+    type: 'string' | 'file' | 'number' | 'boolean';
+    required: boolean;
+    description: string;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    endpoint: string;
+    method: 'GET' | 'POST';
+    parameters: ToolParameter[];
+}
+export interface ToolDefinitionsMessage {
+    type: 'tool-definitions';
+    tools: ToolDefinition[];
+}
+export type ServerMessage = RepositoryListMessage | TaskAvailableMessage | ToolDefinitionsMessage;
+/**
+ * Parse and validate a server message from raw JSON data.
+ * Returns the typed message if valid, or null if invalid.
+ */
+export declare function parseServerMessage(data: unknown): ServerMessage | null;

package/dist/bucket/tool-prompt.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Formats tool definitions for injection into agent prompts.
+ */
+import type { ToolDefinition } from './server-messages';
+/**
+ * Format tool definitions into a markdown section for agent prompts.
+ * Returns an empty string if no tools are defined.
+ */
+export declare function formatToolsSection(tools: ToolDefinition[]): string;

package/dist/claude/spawn-claude-code.d.ts

@@ -1,9 +1,13 @@
 import { spawn as nodeSpawn } from 'node:child_process';
 import { createInterface as nodeCreateInterface } from 'node:readline';
-import type { RawEvent, SpawnOptions } from './types';
+import type { DockerSpawnConfig, RawEvent, SpawnOptions } from './types';
 export interface EventSourceDependencies {
     spawn: typeof nodeSpawn;
     createInterface: typeof nodeCreateInterface;
 }
 export declare const defaultDependencies: EventSourceDependencies;
+/**
+ * Build docker run arguments for spawning claude in a container.
+ */
+export declare function buildDockerRunArguments(docker: DockerSpawnConfig, claudeArguments: string[], env: Record<string, string>): string[];
 export declare function spawnClaudeCode(prompt: string, options?: SpawnOptions, dependencies?: EventSourceDependencies): AsyncGenerator<RawEvent>;

package/dist/claude/types.d.ts

@@ -54,8 +54,10 @@ export interface DockerSpawnConfig {
     repoPath: string;
     /** Home directory for credential mounts */
     homeDir: string;
-    /** Whether .gitconfig exists (for optional mount) */
-    hasGitconfig: boolean;
+    /** Git credential proxy URL (e.g., http://host.docker.internal:3001) */
+    gitProxyUrl?: string;
+    /** Claude API proxy URL (e.g., http://host.docker.internal:3002) */
+    claudeApiProxyUrl?: string;
 }
 export interface SpawnOptions {
     cwd?: string;

package/dist/cli/commands/loop.d.ts

@@ -107,6 +107,8 @@ interface IterationOptions {
     repositoryId?: string;
     /** Docker spawn config when running in Docker mode */
     docker?: DockerSpawnConfig;
+    /** Pre-formatted tools section to inject into the prompt */
+    toolsSection?: string;
 }
 export declare function runOneIteration(dependencies: CommandDependencies, loopDependencies: LoopDependencies, onLoopEvent: LoopEmitFn, onAgentEvent?: SendAgentEventFn, options?: IterationOptions): Promise<IterationResult>;
 export declare function parseMaxIterations(commandArguments: string[]): number;

package/dist/docker/docker-agent.d.ts

@@ -41,4 +41,39 @@ export declare function buildDockerImage(config: DockerConfig, dependencies: Doc
  * Check if a Dockerfile exists at .dust/Dockerfile in the repository.
  */
 export declare function hasDockerfile(repoPath: string, dependencies: DockerDependencies): boolean;
+type DockerPrepareEvent = {
+    type: 'loop.docker_detected';
+    imageTag: string;
+} | {
+    type: 'loop.docker_building';
+    imageTag: string;
+} | {
+    type: 'loop.docker_built';
+    imageTag: string;
+} | {
+    type: 'loop.docker_error';
+    error: string;
+};
+interface DockerSpawnConfig {
+    imageTag: string;
+    repoPath: string;
+    homeDir: string;
+}
+type PrepareDockerConfigResult = {
+    config: DockerSpawnConfig;
+} | {
+    error: string;
+} | Record<string, never>;
+/**
+ * Prepare Docker configuration for agent execution.
+ *
+ * Checks for a .dust/Dockerfile, verifies Docker availability, builds the image,
+ * and returns the spawn configuration. Emits events throughout the process.
+ *
+ * Returns:
+ * - `{ config: DockerSpawnConfig }` on success
+ * - `{ error: string }` on failure (Docker not available or build failed)
+ * - `{}` if no Dockerfile exists
+ */
+export declare function prepareDockerConfig(repoPath: string, dependencies: DockerDependencies, onEvent: (event: DockerPrepareEvent) => void): Promise<PrepareDockerConfigResult>;
 export {};