@joshski/dust 0.1.67 → 0.1.68

package/dist/claude/tool-formatters.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Human-friendly formatters for Claude tool invocations.
+ *
+ * Each formatter transforms a tool's input arguments into readable output lines.
+ * Unknown tools fall back to JSON rendering.
+ */
+type FormatterResult = string[];
+/**
+ * Format a tool invocation for human-readable output.
+ * Returns an array of lines to display.
+ */
+export declare function formatToolUse(name: string, input: Record<string, unknown>): FormatterResult;
+export {};

package/dist/claude/types.d.ts

@@ -0,0 +1,61 @@
+export type RawEvent = Record<string, unknown>;
+export type TextDeltaEvent = {
+    type: 'text_delta';
+    text: string;
+};
+export type ToolUseEvent = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+export type ToolResultEvent = {
+    type: 'tool_result';
+    toolUseId: string;
+    content: string;
+};
+export type AssistantMessageEvent = {
+    type: 'assistant_message';
+    content: Array<{
+        type: string;
+        text?: string;
+        name?: string;
+        input?: unknown;
+    }>;
+};
+export type ResultEvent = {
+    type: 'result';
+    subtype: 'success' | 'error';
+    result?: string;
+    error?: string;
+    cost_usd: number;
+    duration_ms: number;
+    num_turns: number;
+    session_id: string;
+};
+export type ClaudeEvent = TextDeltaEvent | ToolUseEvent | ToolResultEvent | AssistantMessageEvent | ResultEvent;
+export type WriteOp = {
+    op: 'write';
+    text: string;
+};
+export type LineOp = {
+    op: 'line';
+    text: string;
+};
+export type OutputOp = WriteOp | LineOp;
+export interface OutputSink {
+    write(text: string): void;
+    line(text: string): void;
+}
+export interface SpawnOptions {
+    cwd?: string;
+    allowedTools?: string[];
+    maxTurns?: number;
+    model?: string;
+    systemPrompt?: string;
+    sessionId?: string;
+    dangerouslySkipPermissions?: boolean;
+    env?: Record<string, string>;
+    signal?: AbortSignal;
+}
+export type RawEventCallback = (event: RawEvent) => void;

package/dist/cli/colors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ANSI color utilities with support for NO_COLOR and TTY detection.
+ *
+ * Colors are disabled when:
+ * - NO_COLOR environment variable is set (per no-color.org standard)
+ * - TERM=dumb environment variable is set
+ * - stdout is not a TTY (piped output, non-interactive environments)
+ */
+interface Colors {
+    reset: string;
+    bold: string;
+    dim: string;
+    cyan: string;
+    green: string;
+    yellow: string;
+}
+/**
+ * Determines whether colors should be disabled based on environment.
+ */
+export declare function shouldDisableColors(): boolean;
+/**
+ * Returns the appropriate colors object based on environment detection.
+ */
+export declare function getColors(): Colors;
+export {};

package/dist/cli/commands/agent-shared.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared utilities for agent commands
+ *
+ * Provides common functionality used across all agent-* command files.
+ */
+import { type AgentType } from '../../agents/detection';
+import type { CommandDependencies, DustSettings, ReadableFileSystem } from '../types';
+/**
+ * Type-safe template variables for agent commands.
+ * Uses real booleans instead of string-encoded booleans.
+ */
+export interface TemplateVars {
+    bin: string;
+    agentName: string;
+    hooksInstalled: boolean;
+    isClaudeCodeWeb: boolean;
+    hasIdeaFile: boolean;
+}
+export interface TemplateVarsWithInstructions extends TemplateVars {
+    agentInstructions: string;
+}
+/**
+ * Loads agent-specific instructions from .dust/config/agents/{agent-type}.md
+ * Returns empty string if file doesn't exist.
+ */
+export declare function loadAgentInstructions(cwd: string, fileSystem: ReadableFileSystem, agentType: AgentType): Promise<string>;
+export declare function templateVariables(settings: DustSettings, hooksInstalled: boolean, env?: NodeJS.ProcessEnv, options?: {
+    hasIdeaFile?: boolean;
+}): TemplateVars;
+/**
+ * Creates template variables with agent-specific instructions loaded.
+ */
+export declare function templateVariablesWithInstructions(cwd: string, fileSystem: ReadableFileSystem, settings: DustSettings, hooksInstalled: boolean, env?: NodeJS.ProcessEnv, options?: {
+    hasIdeaFile?: boolean;
+}): Promise<TemplateVarsWithInstructions>;
+/**
+ * Manages git hook installation for agent commands.
+ * Automatically installs pre-push hooks if:
+ * - Git is available
+ * - Hooks are not already installed
+ * Also verifies and updates the binary path if needed.
+ * Returns whether hooks are installed.
+ */
+export declare function manageGitHooks(dependencies: CommandDependencies): Promise<boolean>;

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

@@ -0,0 +1,11 @@
+/**
+ * dust focus - Declare current objective and show implementation instructions
+ *
+ * Outputs the current focus/objective to stdout, followed by implementation
+ * instructions (check, implement, commit, push).
+ *
+ * Usage: dust focus "add login box"
+ */
+import type { CommandDependencies, CommandResult } from '../types';
+export declare function buildImplementationInstructions(bin: string, hooksInstalled: boolean, taskTitle?: string): string;
+export declare function focus(dependencies: CommandDependencies): Promise<CommandResult>;

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

@@ -0,0 +1,92 @@
+/**
+ * dust loop claude - Continuous Claude iteration on available tasks
+ *
+ * Runs Claude Code in a loop to work on tasks continuously:
+ * 1. Sync with remote (git pull)
+ * 2. Check for available tasks via `dust next`
+ * 3. If no tasks, sleep and retry
+ * 4. If tasks available, invoke Claude Code
+ * 5. Repeat until max iterations reached (default: 10)
+ *
+ * Usage: dust loop claude [max-iterations]
+ * - max-iterations: Maximum number of task iterations (default: 10)
+ * - Sleep iterations (when no tasks) don't count toward max
+ *
+ * Settings (.dust/config/settings.json):
+ * - eventsUrl: When set, HTTP POST every event to this URL with sequence number
+ */
+import { spawn as nodeSpawn } from 'node:child_process';
+import { type AgentSessionEvent, type EventMessage } from '../../agent-events';
+import { run as claudeRun } from '../../claude/run';
+import type { CommandDependencies, CommandResult } from '../types';
+import { type UnblockedTask } from './next';
+export interface LoopWarningEvent {
+    type: 'loop.warning';
+}
+export interface LoopStartedEvent {
+    type: 'loop.started';
+    maxIterations: number;
+    agentType?: string;
+}
+export interface LoopSyncingEvent {
+    type: 'loop.syncing';
+}
+export interface LoopSyncSkippedEvent {
+    type: 'loop.sync_skipped';
+    reason: string;
+}
+export interface LoopCheckingTasksEvent {
+    type: 'loop.checking_tasks';
+}
+export interface LoopNoTasksEvent {
+    type: 'loop.no_tasks';
+}
+export interface LoopTasksFoundEvent {
+    type: 'loop.tasks_found';
+}
+export interface LoopIterationCompleteEvent {
+    type: 'loop.iteration_complete';
+    iteration: number;
+    maxIterations: number;
+}
+export interface LoopEndedEvent {
+    type: 'loop.ended';
+    maxIterations: number;
+}
+export type LoopEvent = LoopWarningEvent | LoopStartedEvent | LoopSyncingEvent | LoopSyncSkippedEvent | LoopCheckingTasksEvent | LoopNoTasksEvent | LoopTasksFoundEvent | LoopIterationCompleteEvent | LoopEndedEvent;
+export type LoopEmitFn = (event: LoopEvent) => void;
+export declare function formatLoopEvent(event: LoopEvent): string | null;
+export type PostEventFn = (url: string, payload: EventMessage) => Promise<void>;
+export interface LoopDependencies {
+    spawn: typeof nodeSpawn;
+    run: typeof claudeRun;
+    sleep: (ms: number) => Promise<void>;
+    postEvent: PostEventFn;
+    agentType?: string;
+    fetch?: typeof fetch;
+}
+export declare function createPostEvent(fetchFn: typeof fetch): PostEventFn;
+export declare function createDefaultDependencies(): LoopDependencies;
+export type SendAgentEventFn = (event: AgentSessionEvent) => void;
+export declare function createWireEventSender(eventsUrl: string | undefined, sessionId: string, postEvent: PostEventFn, onError: (error: unknown) => void, getAgentSessionId?: () => string | undefined, repository?: string): SendAgentEventFn;
+type GitPullResult = {
+    success: true;
+} | {
+    success: false;
+    message: string;
+};
+export declare function gitPull(cwd: string, spawn: typeof nodeSpawn): Promise<GitPullResult>;
+export declare function findAvailableTasks(dependencies: CommandDependencies): Promise<UnblockedTask[]>;
+type IterationResult = 'no_tasks' | 'ran_claude' | 'claude_error' | 'resolved_pull_conflict';
+type LogFn = (message: string) => void;
+interface IterationOptions {
+    onRawEvent?: (rawEvent: Record<string, unknown>) => void;
+    hooksInstalled?: boolean;
+    signal?: AbortSignal;
+    logger?: LogFn;
+    repositoryId?: string;
+}
+export declare function runOneIteration(dependencies: CommandDependencies, loopDependencies: LoopDependencies, onLoopEvent: LoopEmitFn, onAgentEvent?: SendAgentEventFn, options?: IterationOptions): Promise<IterationResult>;
+export declare function parseMaxIterations(commandArguments: string[]): number;
+export declare function loopClaude(dependencies: CommandDependencies, loopDependencies?: LoopDependencies): Promise<CommandResult>;
+export {};

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

@@ -0,0 +1,25 @@
+/**
+ * dust next - List tasks that are ready to work on
+ *
+ * Displays tasks from .dust/tasks/ that are not blocked by any incomplete tasks.
+ * A task is blocked if its "## Blocked By" section references task files that still exist.
+ */
+import type { CommandContext, CommandDependencies, CommandResult, DirectoryFileSorter, FileSystem } from '../types';
+export interface UnblockedTask {
+    path: string;
+    title: string | null;
+    openingSentence: string | null;
+}
+/**
+ * Finds unblocked tasks in .dust/tasks/.
+ * Returns null if .dust directory is missing, otherwise an array of unblocked tasks.
+ */
+export declare function findUnblockedTasks(cwd: string, fileSystem: FileSystem, directoryFileSorter?: DirectoryFileSorter): Promise<{
+    error?: string;
+    tasks: UnblockedTask[];
+}>;
+/**
+ * Formats unblocked tasks for display.
+ */
+export declare function printTaskList(context: CommandContext, tasks: UnblockedTask[]): void;
+export declare function next(dependencies: CommandDependencies): Promise<CommandResult>;

package/dist/config/settings.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Settings module for dust CLI
+ *
+ * Reads optional configuration from .dust/config/settings.json
+ */
+import type { CheckConfig, DustSettings, ReadableFileSystem } from '../cli/types';
+export type { CheckConfig, DustSettings };
+interface SettingsViolation {
+    message: string;
+}
+export declare function validateSettingsJson(content: string): SettingsViolation[];
+/**
+ * Detects the appropriate dust command based on lockfiles and environment.
+ * Priority:
+ * 1. bun.lockb exists → bunx dust
+ * 2. pnpm-lock.yaml exists → pnpx dust
+ * 3. package-lock.json exists → npx dust
+ * 4. No lockfile + BUN_INSTALL env var set → bunx dust
+ * 5. Default → npx dust
+ */
+export declare function detectDustCommand(cwd: string, fileSystem: ReadableFileSystem): string;
+/**
+ * Detects the appropriate install command based on lockfiles and environment.
+ * Priority:
+ * 1. bun.lockb exists → bun install
+ * 2. pnpm-lock.yaml exists → pnpm install
+ * 3. package-lock.json exists → npm install
+ * 4. No lockfile + BUN_INSTALL env var set → bun install
+ * 5. Default → npm install
+ */
+export declare function detectInstallCommand(cwd: string, fileSystem: ReadableFileSystem): string;
+/**
+ * Detects the appropriate test command based on lockfiles and environment.
+ * Priority:
+ * 1. bun.lockb or bun.lock exists → bun test
+ * 2. pnpm-lock.yaml exists → pnpm test
+ * 3. package-lock.json exists → npm test
+ * 4. yarn.lock exists → yarn test
+ * 5. No lockfile + BUN_INSTALL env var set → bun test
+ * 6. package.json exists → npm test
+ * 7. Default → null (no test command)
+ */
+export declare function detectTestCommand(cwd: string, fileSystem: ReadableFileSystem): string | null;
+export declare function loadSettings(cwd: string, fileSystem: ReadableFileSystem): Promise<DustSettings>;