@joshski/dust 0.1.97 → 0.1.98

package/dist/agent-events.d.ts

@@ -29,6 +29,19 @@ export type AgentSessionEvent = {
 } | {
     type: 'command-event';
     commandEvent: CommandEvent;
+} | {
+    type: 'preflight-started';
+    step: string;
+    title?: string;
+} | {
+    type: 'preflight-completed';
+    step: string;
+    output?: string;
+} | {
+    type: 'preflight-failed';
+    step: string;
+    output: string;
+    title?: string;
 };
 export interface EventMessage {
     sequence: number;

package/dist/artifacts/index.d.ts

@@ -4,8 +4,9 @@ import { type Idea, type IdeaOpenQuestion, type IdeaOption, type ParsedIdeaConte
 import { extractTitle } from '../markdown/markdown-utilities';
 import { type Principle } from './principles';
 import { type Task } from './tasks';
+import { type ParsedArtifact, type ParsedMarkdownLink, type ParsedSection, parseArtifact } from './parsed-artifact';
 import { type AllWorkflowTasks, CAPTURE_IDEA_PREFIX, type CreateIdeaTransitionTaskResult, type DecomposeIdeaOptions, findAllWorkflowTasks, type IdeaInProgress, type OpenQuestionResponse, type ParsedCaptureIdeaTask, parseResolvedQuestions, type WorkflowTaskMatch, type WorkflowTaskType } from './workflow-tasks';
-export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedCaptureIdeaTask, ParsedIdeaContent, Principle, Task, WorkflowTaskMatch, WorkflowTaskType, };
+export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedArtifact, ParsedCaptureIdeaTask, ParsedIdeaContent, ParsedMarkdownLink, ParsedSection, Principle, Task, WorkflowTaskMatch, WorkflowTaskType, };
 export interface TaskGraphNode {
     task: Task;
     workflowType: WorkflowTaskType | null;
@@ -17,9 +18,19 @@ export interface TaskGraph {
         to: string;
     }>;
 }
-export { CAPTURE_IDEA_PREFIX, extractTitle, findAllWorkflowTasks, ideaContentToMarkdown, parseIdeaContent, parseOpenQuestions, parseResolvedQuestions, };
+export { CAPTURE_IDEA_PREFIX, extractTitle, findAllWorkflowTasks, ideaContentToMarkdown, parseArtifact, parseIdeaContent, parseOpenQuestions, parseResolvedQuestions, };
 export type { IdeaInProgress };
 export type ArtifactType = 'ideas' | 'tasks' | 'principles' | 'facts';
+export declare const DUST_PATH_PREFIX = ".dust/";
+/**
+ * Parses an artifact path into its type and slug components.
+ * This is the inverse of ArtifactsRepository.artifactPath().
+ * Works with relative paths (e.g., '.dust/tasks/my-task.md').
+ */
+export declare function parseArtifactPath(path: string): {
+    type: ArtifactType;
+    slug: string;
+} | null;
 export interface ReadOnlyArtifactsRepository {
     artifactPath(type: ArtifactType, slug: string): string;
     parseIdea(options: {

package/dist/artifacts/parsed-artifact.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Parsed artifact types with positional metadata for validation.
+ *
+ * These types enrich artifact parsing with line numbers to support
+ * single-pass validation and better error reporting.
+ */
+export interface ParsedMarkdownLink {
+    text: string;
+    target: string;
+    line: number;
+}
+export interface ParsedSection {
+    heading: string;
+    level: number;
+    startLine: number;
+    endLine: number;
+    links: ParsedMarkdownLink[];
+}
+export interface ParsedArtifact {
+    filePath: string;
+    rawContent: string;
+    title: string | null;
+    titleLine: number | null;
+    openingSentence: string | null;
+    openingSentenceLine: number | null;
+    sections: ParsedSection[];
+    allLinks: ParsedMarkdownLink[];
+}
+/**
+ * Parses markdown content into a ParsedArtifact with positional metadata.
+ */
+export declare function parseArtifact(filePath: string, content: string): ParsedArtifact;

package/dist/artifacts.js

@@ -379,6 +379,143 @@ async function parseTask(fileSystem, dustPath, slug) {
   };
 }
 
+// lib/artifacts/parsed-artifact.ts
+var MARKDOWN_LINK_PATTERN2 = /\[([^\]]+)\]\(([^)]+)\)/g;
+function parseArtifact(filePath, content) {
+  const lines = content.split(`
+`);
+  let title = null;
+  let titleLine = null;
+  let openingSentence = null;
+  let openingSentenceLine = null;
+  const sections = [];
+  const allLinks = [];
+  let currentSection = null;
+  let inCodeFence = false;
+  let openingSentenceResolved = false;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    if (line.startsWith("```")) {
+      inCodeFence = !inCodeFence;
+      continue;
+    }
+    if (inCodeFence) {
+      continue;
+    }
+    const h1Match = line.match(/^#\s+(.+)$/);
+    if (h1Match) {
+      if (title === null) {
+        title = h1Match[1].trim();
+        titleLine = lineNumber;
+      } else {
+        if (currentSection !== null) {
+          currentSection.endLine = findLastNonEmptyLine(lines, currentSection.startLine, lineNumber - 2);
+          sections.push(currentSection);
+          currentSection = null;
+        }
+      }
+      continue;
+    }
+    const headingMatch = line.match(/^(#{2,6})\s+(.+)$/);
+    if (headingMatch) {
+      openingSentenceResolved = true;
+      if (currentSection !== null) {
+        currentSection.endLine = findLastNonEmptyLine(lines, currentSection.startLine, lineNumber - 2);
+        sections.push(currentSection);
+      }
+      currentSection = {
+        heading: headingMatch[2].trim(),
+        level: headingMatch[1].length,
+        startLine: lineNumber,
+        endLine: -1,
+        links: []
+      };
+      continue;
+    }
+    if (shouldCheckForOpeningSentence(title, openingSentenceResolved, line)) {
+      const result = tryExtractOpeningSentence(lines, i);
+      openingSentence = result.sentence;
+      openingSentenceLine = result.sentence !== null ? lineNumber : null;
+      openingSentenceResolved = true;
+    }
+    const linkMatches = line.matchAll(MARKDOWN_LINK_PATTERN2);
+    for (const match of linkMatches) {
+      const link = {
+        text: match[1],
+        target: match[2],
+        line: lineNumber
+      };
+      allLinks.push(link);
+      if (currentSection !== null) {
+        currentSection.links.push(link);
+      }
+    }
+  }
+  if (currentSection !== null) {
+    currentSection.endLine = findLastNonEmptyLine(lines, currentSection.startLine, lines.length - 1);
+    sections.push(currentSection);
+  }
+  return {
+    filePath,
+    rawContent: content,
+    title,
+    titleLine,
+    openingSentence,
+    openingSentenceLine,
+    sections,
+    allLinks
+  };
+}
+function shouldCheckForOpeningSentence(title, resolved, line) {
+  if (title === null || resolved) {
+    return false;
+  }
+  const trimmed = line.trim();
+  return trimmed !== "" && !isStructuralElement2(trimmed);
+}
+function tryExtractOpeningSentence(lines, startIndex) {
+  const paragraph = collectParagraph2(lines, startIndex);
+  return { sentence: extractFirstSentence2(paragraph) };
+}
+function findLastNonEmptyLine(lines, contentStartIndex, fromIndex) {
+  for (let i = fromIndex;i >= contentStartIndex; i--) {
+    if (lines[i].trim() !== "") {
+      return i + 1;
+    }
+  }
+  return contentStartIndex;
+}
+var LIST_ITEM_PREFIXES2 = ["-", "*", "+"];
+var STRUCTURAL_PREFIXES2 = ["#", "```", ">"];
+function isStructuralElement2(line) {
+  if (STRUCTURAL_PREFIXES2.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  if (LIST_ITEM_PREFIXES2.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  return /^\d+\./.test(line);
+}
+function isBlockBreak2(line) {
+  return STRUCTURAL_PREFIXES2.some((prefix) => line.startsWith(prefix));
+}
+function collectParagraph2(lines, startIndex) {
+  const parts = [];
+  for (let i = startIndex;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "" || isBlockBreak2(line)) {
+      break;
+    }
+    parts.push(line);
+  }
+  return parts.join(" ");
+}
+function extractFirstSentence2(paragraph) {
+  const match = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
+  return match ? match[1] : null;
+}
+
 // lib/artifacts/workflow-tasks.ts
 var CAPTURE_IDEA_PREFIX = "Add Idea: ";
 var EXPEDITE_IDEA_PREFIX = "Expedite Idea: ";
@@ -756,6 +893,25 @@ async function parseCaptureIdeaTask(fileSystem, dustPath, taskSlug) {
 }
 
 // lib/artifacts/index.ts
+var ARTIFACT_TYPES = ["ideas", "tasks", "principles", "facts"];
+var DUST_PATH_PREFIX = ".dust/";
+function parseArtifactPath(path) {
+  if (!path.startsWith(DUST_PATH_PREFIX) || !path.endsWith(".md")) {
+    return null;
+  }
+  const withoutPrefix = path.slice(DUST_PATH_PREFIX.length);
+  const slashIndex = withoutPrefix.indexOf("/");
+  if (slashIndex === -1) {
+    return null;
+  }
+  const type = withoutPrefix.slice(0, slashIndex);
+  if (!ARTIFACT_TYPES.includes(type)) {
+    return null;
+  }
+  const filename = withoutPrefix.slice(slashIndex + 1);
+  const slug = filename.slice(0, -3);
+  return { type, slug };
+}
 function buildReadOperations(fileSystem, dustPath) {
   return {
     artifactPath(type, slug) {
@@ -861,10 +1017,13 @@ export {
   parseResolvedQuestions,
   parseOpenQuestions,
   parseIdeaContent,
+  parseArtifactPath,
+  parseArtifact,
   ideaContentToMarkdown,
   findAllWorkflowTasks,
   extractTitle,
   buildReadOnlyArtifactsRepository,
   buildArtifactsRepository,
+  DUST_PATH_PREFIX,
   CAPTURE_IDEA_PREFIX
 };

package/dist/bucket/repository.d.ts

@@ -64,6 +64,8 @@ export interface RepositoryDependencies {
     forwardToolExecution?: (request: ToolExecutionRequest) => Promise<ToolExecutionResult>;
     /** Mark a tool family as revealed (for progressive disclosure) */
     revealFamily?: (familyName: string) => void;
+    /** Shell runner for pre-flight commands (install, check) */
+    shellRunner?: import('../cli/process-runner').ShellRunner;
 }
 /**
  * Start (or restart) the per-repository loop and keep lifecycle state accurate.

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

@@ -7,5 +7,5 @@
  * Usage: dust focus "add login box"
  */
 import type { CommandDependencies, CommandResult } from '../types';
-export declare function buildImplementationInstructions(bin: string, hooksInstalled: boolean, taskTitle?: string, taskPath?: string, installCommand?: string): string;
+export declare function buildImplementationInstructions(bin: string, hooksInstalled: boolean, taskTitle?: string, taskPath?: string, installCommand?: string, skipPreflightSteps?: boolean): string;
 export declare function focus(dependencies: CommandDependencies): Promise<CommandResult>;

package/dist/cli/process-runner.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared process runner utilities for buffered command execution.
+ *
+ * Provides a unified interface for running shell commands and git commands
+ * with buffered output capture.
+ */
+import { type ChildProcess } from 'node:child_process';
+export interface ProcessResult {
+    exitCode: number;
+    output: string;
+    timedOut?: boolean;
+}
+type SpawnFn = (command: string, commandArguments: string[], options: {
+    cwd: string;
+    shell?: boolean;
+}) => ChildProcess;
+/**
+ * Creates a buffered process runner for executing shell commands.
+ * Commands are run with shell: true for command string interpretation.
+ */
+export interface ShellRunner {
+    run: (command: string, cwd: string, timeoutMs?: number) => Promise<ProcessResult>;
+}
+export declare function createShellRunner(spawnFn: SpawnFn): ShellRunner;
+export declare const defaultShellRunner: ShellRunner;
+/**
+ * Creates a buffered process runner for executing git commands.
+ * Git is run directly without shell interpretation.
+ */
+export interface GitRunner {
+    run: (gitArguments: string[], cwd: string) => Promise<ProcessResult>;
+}
+export declare function createGitRunner(spawnFn: SpawnFn): GitRunner;
+export declare const defaultGitRunner: GitRunner;
+export {};