@joshski/dust 0.1.97 → 0.1.99

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,20 @@ 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 ARTIFACT_TYPES: ArtifactType[];
+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,30 @@ async function parseCaptureIdeaTask(fileSystem, dustPath, taskSlug) {
 }
 
 // lib/artifacts/index.ts
+var ARTIFACT_TYPES = [
+  "facts",
+  "ideas",
+  "principles",
+  "tasks"
+];
+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 +1022,14 @@ export {
   parseResolvedQuestions,
   parseOpenQuestions,
   parseIdeaContent,
+  parseArtifactPath,
+  parseArtifact,
   ideaContentToMarkdown,
   findAllWorkflowTasks,
   extractTitle,
   buildReadOnlyArtifactsRepository,
   buildArtifactsRepository,
-  CAPTURE_IDEA_PREFIX
+  DUST_PATH_PREFIX,
+  CAPTURE_IDEA_PREFIX,
+  ARTIFACT_TYPES
 };

package/dist/audits/checks-audit.d.ts

@@ -1,17 +1,17 @@
 /**
- * Checks Audit - Pure functions for detecting tech stacks and suggesting checks.
+ * Checks Audit - Pure functions for detecting configured checks and suggesting improvements.
  *
  * This module provides the functional core for the checks-audit stock audit.
- * It detects the project's technology ecosystem, identifies configured checks,
- * parses CI configuration files, and suggests missing check categories.
+ * It identifies configured checks, parses CI configuration files, and suggests
+ * missing check categories.
+ *
+ * Tech stack detection is imported from lib/tech-stack/.
  */
 import type { DustSettings } from '../cli/types';
-export type Ecosystem = 'javascript' | 'python' | 'go' | 'rust' | 'ruby' | 'php' | 'elixir';
-export interface TechStackDetection {
-    ecosystem: Ecosystem;
-    indicators: string[];
-    packageManager?: string;
-}
+import type { Ecosystem, TechStackDetection } from '../tech-stack';
+import { detectTechStack } from '../tech-stack';
+export { detectTechStack };
+export type { Ecosystem, TechStackDetection };
 export interface CheckOption {
     name: string;
     command: string;
@@ -29,10 +29,6 @@ export interface CIFileContent {
     path: string;
     content: string;
 }
-/**
- * Detects tech stacks based on project files.
- */
-export declare function detectTechStack(projectFiles: string[]): TechStackDetection[];
 /**
  * Extracts check categories from existing dust settings.
  */
@@ -51,5 +47,9 @@ export declare function suggestChecks(techStack: TechStackDetection[], projectFi
 export declare function renderCheckIdea(suggestion: CheckSuggestion, packageManager?: string): string;
 /**
  * Returns the checks-audit stock audit template.
+ *
+ * This template is tech-stack agnostic. Agents should discover appropriate
+ * checks by examining the project structure rather than receiving
+ * ecosystem-specific tool prescriptions.
  */
 export declare function checksAuditTemplate(): string;