@joshski/dust 0.1.96 → 0.1.97

package/dist/artifacts/ideas.d.ts

@@ -14,6 +14,11 @@ export interface Idea {
     content: string;
     openQuestions: IdeaOpenQuestion[];
 }
+export interface ParsedIdeaContent {
+    title: string | null;
+    body: string;
+    openQuestions: IdeaOpenQuestion[];
+}
 /**
  * Parses the ## Open Questions section from idea markdown content.
  * Extracts each ### question heading and its #### option children.
@@ -23,3 +28,15 @@ export declare function parseOpenQuestions(content: string): IdeaOpenQuestion[];
  * Parses an idea markdown file into a structured Idea object.
  */
 export declare function parseIdea(fileSystem: ReadableFileSystem, dustPath: string, slug: string): Promise<Idea>;
+/**
+ * Parses idea markdown into a structured object that can be bound to a UI
+ * and serialized back to markdown.
+ */
+export declare function parseIdeaContent(markdown: string): ParsedIdeaContent;
+/**
+ * Serializes a ParsedIdeaContent back to markdown.
+ * Open Questions are appended as the last section.
+ */
+export declare function ideaContentToMarkdown(content: ParsedIdeaContent, options?: {
+    includeOpenQuestions?: boolean;
+}): string;

package/dist/artifacts/index.d.ts

@@ -1,10 +1,11 @@
 import type { FileSystem, ReadableFileSystem } from '../filesystem/types';
 import { type Fact } from './facts';
-import { type Idea, type IdeaOpenQuestion, type IdeaOption, parseOpenQuestions } from './ideas';
+import { type Idea, type IdeaOpenQuestion, type IdeaOption, type ParsedIdeaContent, ideaContentToMarkdown, parseIdeaContent, parseOpenQuestions } from './ideas';
+import { extractTitle } from '../markdown/markdown-utilities';
 import { type Principle } from './principles';
 import { type Task } from './tasks';
 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, Principle, Task, WorkflowTaskMatch, WorkflowTaskType, };
+export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedCaptureIdeaTask, ParsedIdeaContent, Principle, Task, WorkflowTaskMatch, WorkflowTaskType, };
 export interface TaskGraphNode {
     task: Task;
     workflowType: WorkflowTaskType | null;
@@ -16,7 +17,7 @@ export interface TaskGraph {
         to: string;
     }>;
 }
-export { CAPTURE_IDEA_PREFIX, findAllWorkflowTasks, parseOpenQuestions, parseResolvedQuestions, };
+export { CAPTURE_IDEA_PREFIX, extractTitle, findAllWorkflowTasks, ideaContentToMarkdown, parseIdeaContent, parseOpenQuestions, parseResolvedQuestions, };
 export type { IdeaInProgress };
 export type ArtifactType = 'ideas' | 'tasks' | 'principles' | 'facts';
 export interface ReadOnlyArtifactsRepository {

package/dist/artifacts.js

@@ -4,50 +4,68 @@ function extractTitle(content) {
   return match ? match[1].trim() : null;
 }
 var MARKDOWN_LINK_PATTERN = /\[([^\]]+)\]\(([^)]+)\)/;
-function extractOpeningSentence(content) {
-  const lines = content.split(`
-`);
-  let h1Index = -1;
+function findH1Index(lines) {
   for (let i = 0;i < lines.length; i++) {
     if (lines[i].match(/^#\s+.+$/)) {
-      h1Index = i;
-      break;
+      return i;
     }
   }
-  if (h1Index === -1) {
-    return null;
+  return -1;
+}
+function findFirstNonBlankLineAfter(lines, startIndex) {
+  for (let i = startIndex + 1;i < lines.length; i++) {
+    if (lines[i].trim() !== "") {
+      return i;
+    }
+  }
+  return -1;
+}
+var LIST_ITEM_PREFIXES = ["-", "*", "+"];
+var STRUCTURAL_PREFIXES = ["#", "```", ">"];
+function isStructuralElement(line) {
+  if (STRUCTURAL_PREFIXES.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  if (LIST_ITEM_PREFIXES.some((prefix) => line.startsWith(prefix))) {
+    return true;
   }
-  let paragraphStart = -1;
-  for (let i = h1Index + 1;i < lines.length; i++) {
+  return /^\d+\./.test(line);
+}
+function isBlockBreak(line) {
+  return STRUCTURAL_PREFIXES.some((prefix) => line.startsWith(prefix));
+}
+function collectParagraph(lines, startIndex) {
+  const parts = [];
+  for (let i = startIndex;i < lines.length; i++) {
     const line = lines[i].trim();
-    if (line !== "") {
-      paragraphStart = i;
+    if (line === "" || isBlockBreak(line)) {
       break;
     }
+    parts.push(line);
   }
-  if (paragraphStart === -1) {
+  return parts.join(" ");
+}
+function extractFirstSentence(paragraph) {
+  const match = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
+  return match ? match[1] : null;
+}
+function extractOpeningSentence(content) {
+  const lines = content.split(`
+`);
+  const h1Index = findH1Index(lines);
+  if (h1Index === -1) {
     return null;
   }
-  const firstLine = lines[paragraphStart];
-  const trimmedFirstLine = firstLine.trim();
-  if (trimmedFirstLine.startsWith("#") || trimmedFirstLine.startsWith("-") || trimmedFirstLine.startsWith("*") || trimmedFirstLine.startsWith("+") || trimmedFirstLine.match(/^\d+\./) || trimmedFirstLine.startsWith("```") || trimmedFirstLine.startsWith(">")) {
+  const paragraphStart = findFirstNonBlankLineAfter(lines, h1Index);
+  if (paragraphStart === -1) {
     return null;
   }
-  let paragraph = "";
-  for (let i = paragraphStart;i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line === "")
-      break;
-    if (line.startsWith("#") || line.startsWith("```") || line.startsWith(">")) {
-      break;
-    }
-    paragraph += (paragraph ? " " : "") + line;
-  }
-  const sentenceMatch = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
-  if (!sentenceMatch) {
+  const trimmedFirstLine = lines[paragraphStart].trim();
+  if (isStructuralElement(trimmedFirstLine)) {
     return null;
   }
-  return sentenceMatch[1];
+  const paragraph = collectParagraph(lines, paragraphStart);
+  return extractFirstSentence(paragraph);
 }
 
 // lib/artifacts/facts.ts
@@ -162,6 +180,83 @@ async function parseIdea(fileSystem, dustPath, slug) {
     openQuestions
   };
 }
+function stripOpenQuestionsSection(content) {
+  const lines = content.split(`
+`);
+  const result = [];
+  let inOpenQuestions = false;
+  let inCodeFence = false;
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      inCodeFence = !inCodeFence;
+      if (!inOpenQuestions)
+        result.push(line);
+      continue;
+    }
+    if (inCodeFence) {
+      if (!inOpenQuestions)
+        result.push(line);
+      continue;
+    }
+    if (line.startsWith("## ")) {
+      inOpenQuestions = line.trimEnd() === "## Open Questions";
+      if (!inOpenQuestions)
+        result.push(line);
+      continue;
+    }
+    if (!inOpenQuestions) {
+      result.push(line);
+    }
+  }
+  while (result.length > 0 && result[result.length - 1].trim() === "") {
+    result.pop();
+  }
+  return result.join(`
+`) + `
+`;
+}
+function stripTitle(content) {
+  const match = content.match(/^#\s+.+\n+/);
+  if (!match)
+    return content;
+  return content.slice(match[0].length);
+}
+function parseIdeaContent(markdown) {
+  const title = extractTitle(markdown);
+  const openQuestions = parseOpenQuestions(markdown);
+  const body = stripTitle(stripOpenQuestionsSection(markdown));
+  return { title, body, openQuestions };
+}
+function ideaContentToMarkdown(content, options) {
+  const includeOQ = options?.includeOpenQuestions ?? true;
+  const parts = [];
+  if (content.title) {
+    parts.push(`# ${content.title}`);
+    parts.push("");
+  }
+  if (content.body) {
+    parts.push(content.body.trimEnd());
+    parts.push("");
+  }
+  if (includeOQ && content.openQuestions.length > 0) {
+    parts.push("## Open Questions");
+    parts.push("");
+    for (const q of content.openQuestions) {
+      parts.push(`### ${q.question}`);
+      parts.push("");
+      for (const o of q.options) {
+        parts.push(`#### ${o.name}`);
+        parts.push("");
+        if (o.description) {
+          parts.push(o.description);
+          parts.push("");
+        }
+      }
+    }
+  }
+  return parts.join(`
+`);
+}
 
 // lib/artifacts/principles.ts
 function extractLinksFromSection(content, sectionHeading) {
@@ -765,7 +860,10 @@ function buildReadOnlyArtifactsRepository(fileSystem, dustPath) {
 export {
   parseResolvedQuestions,
   parseOpenQuestions,
+  parseIdeaContent,
+  ideaContentToMarkdown,
   findAllWorkflowTasks,
+  extractTitle,
   buildReadOnlyArtifactsRepository,
   buildArtifactsRepository,
   CAPTURE_IDEA_PREFIX

package/dist/audits.js

@@ -6,50 +6,68 @@ function extractTitle(content) {
   const match = content.match(/^#\s+(.+)$/m);
   return match ? match[1].trim() : null;
 }
-function extractOpeningSentence(content) {
-  const lines = content.split(`
-`);
-  let h1Index = -1;
+function findH1Index(lines) {
   for (let i = 0;i < lines.length; i++) {
     if (lines[i].match(/^#\s+.+$/)) {
-      h1Index = i;
-      break;
+      return i;
     }
   }
-  if (h1Index === -1) {
-    return null;
+  return -1;
+}
+function findFirstNonBlankLineAfter(lines, startIndex) {
+  for (let i = startIndex + 1;i < lines.length; i++) {
+    if (lines[i].trim() !== "") {
+      return i;
+    }
   }
-  let paragraphStart = -1;
-  for (let i = h1Index + 1;i < lines.length; i++) {
+  return -1;
+}
+var LIST_ITEM_PREFIXES = ["-", "*", "+"];
+var STRUCTURAL_PREFIXES = ["#", "```", ">"];
+function isStructuralElement(line) {
+  if (STRUCTURAL_PREFIXES.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  if (LIST_ITEM_PREFIXES.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  return /^\d+\./.test(line);
+}
+function isBlockBreak(line) {
+  return STRUCTURAL_PREFIXES.some((prefix) => line.startsWith(prefix));
+}
+function collectParagraph(lines, startIndex) {
+  const parts = [];
+  for (let i = startIndex;i < lines.length; i++) {
     const line = lines[i].trim();
-    if (line !== "") {
-      paragraphStart = i;
+    if (line === "" || isBlockBreak(line)) {
       break;
     }
+    parts.push(line);
   }
-  if (paragraphStart === -1) {
+  return parts.join(" ");
+}
+function extractFirstSentence(paragraph) {
+  const match = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
+  return match ? match[1] : null;
+}
+function extractOpeningSentence(content) {
+  const lines = content.split(`
+`);
+  const h1Index = findH1Index(lines);
+  if (h1Index === -1) {
     return null;
   }
-  const firstLine = lines[paragraphStart];
-  const trimmedFirstLine = firstLine.trim();
-  if (trimmedFirstLine.startsWith("#") || trimmedFirstLine.startsWith("-") || trimmedFirstLine.startsWith("*") || trimmedFirstLine.startsWith("+") || trimmedFirstLine.match(/^\d+\./) || trimmedFirstLine.startsWith("```") || trimmedFirstLine.startsWith(">")) {
+  const paragraphStart = findFirstNonBlankLineAfter(lines, h1Index);
+  if (paragraphStart === -1) {
     return null;
   }
-  let paragraph = "";
-  for (let i = paragraphStart;i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line === "")
-      break;
-    if (line.startsWith("#") || line.startsWith("```") || line.startsWith(">")) {
-      break;
-    }
-    paragraph += (paragraph ? " " : "") + line;
-  }
-  const sentenceMatch = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
-  if (!sentenceMatch) {
+  const trimmedFirstLine = lines[paragraphStart].trim();
+  if (isStructuralElement(trimmedFirstLine)) {
     return null;
   }
-  return sentenceMatch[1];
+  const paragraph = collectParagraph(lines, paragraphStart);
+  return extractFirstSentence(paragraph);
 }
 
 // lib/cli/dedent.ts
@@ -214,19 +232,33 @@ function coverageExclusions() {
   return dedent`
     # Coverage Exclusions
 
-    Review coverage exclusion configuration to identify opportunities for removal through refactoring.
+    Audit all coverage exclusions to identify opportunities for removal through refactoring.
 
     ${ideasHint}
 
     ## Scope
 
-    Focus on these areas:
+    Search for exclusions in both configuration and source code:
+
+    1. **Configuration-level exclusions** - Review test framework configuration for file/directory exclusion patterns
+    2. **Inline escape directives** - Search for comments that exclude code from coverage (e.g., ignore directives in source files)
+    3. **Test files** - Include test code in the search; inline directives may hide flaky or unclear test logic
+
+    ## Analysis
+
+    For each exclusion found:
 
-    1. **Current exclusions** - Review all exclusions in \`vitest.config.ts\` or equivalent
-    2. **Justification** - Is each exclusion still necessary?
-    3. **Tooling limitations** - Can workarounds be found for coverage tool issues?
-    4. **Decoupling opportunities** - Can excluded code be restructured to enable testing?
-    5. **Entry point patterns** - Can hard-to-test entry points be decoupled from logic?
+    1. **Document the location** - File path and line number (or config section)
+    2. **Identify the reason** - Why was this exclusion added?
+    3. **Categorize by justification**:
+       - Native wrapper (code that wraps platform APIs with no testable logic)
+       - Defensive guard (unreachable error handling for type safety)
+       - Integration boundary (code that requires external systems)
+       - Tooling limitation (coverage tool bug or limitation)
+       - Technical debt (code that should be testable but isn't)
+       - Unknown (no clear justification found)
+    4. **Label justification quality** - Is the justification well-documented, reasonable, or questionable?
+    5. **Evaluate removal potential** - Can the exclusion be removed through decoupling or refactoring?
 
     ## Principles
 
@@ -241,9 +273,11 @@ function coverageExclusions() {
 
     ## Definition of Done
 
-    - Identified all coverage exclusions in the project
+    - Identified all configuration-level coverage exclusions
+    - Searched source and test files for inline escape directives
     - Documented the reason each exclusion exists
-    - Evaluated whether each exclusion is still necessary
+    - Categorized each exclusion by justification type
+    - Labeled justification quality for visibility
     - Identified exclusions that could be removed through decoupling
     - Proposed ideas for refactoring where feasible
   `;

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

@@ -0,0 +1,38 @@
+/**
+ * Repository lifecycle state type for dust bucket.
+ *
+ * Represents all valid states in the repository lifecycle as a discriminated union,
+ * making invalid state combinations unrepresentable.
+ */
+export type RepositoryLifecycleState = {
+    type: 'idle';
+} | {
+    type: 'starting';
+} | {
+    type: 'running';
+    loopPromise: Promise<void>;
+    cancel: () => void;
+} | {
+    type: 'stopping';
+} | {
+    type: 'stopped';
+};
+export type LifecycleAction = {
+    type: 'start';
+} | {
+    type: 'started';
+    loopPromise: Promise<void>;
+    cancel: () => void;
+} | {
+    type: 'stop';
+} | {
+    type: 'stopped';
+};
+export type TransitionResult = {
+    ok: true;
+    state: RepositoryLifecycleState;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function transition(current: RepositoryLifecycleState, action: LifecycleAction): TransitionResult;

package/dist/bucket/repository.d.ts

@@ -12,9 +12,11 @@ import { type AuthConfig, type RuntimeConfig, type SessionConfig } from '../env-
 import type { ToolExecutionRequest, ToolExecutionResult } from './command-events-proxy';
 import { type BucketEmitFn, type SendEventFn } from './events';
 import { type LogBuffer } from './log-buffer';
+import { type RepositoryLifecycleState } from './repository-lifecycle';
 import type { ToolDefinition } from './server-messages';
 export { cloneRepository, getRepoPath, removeRepository, } from './repository-git';
 export { runRepositoryLoop } from './repository-loop';
+export type { RepositoryLifecycleState } from './repository-lifecycle';
 export interface Repository {
     name: string;
     gitUrl: string;
@@ -26,13 +28,11 @@ export interface Repository {
 export interface RepositoryState {
     repository: Repository;
     path: string;
-    loopPromise: Promise<void> | null;
-    stopRequested: boolean;
     logBuffer: LogBuffer;
+    lifecycle: RepositoryLifecycleState;
     agentStatus: 'idle' | 'busy';
     wakeUp?: () => void;
     taskAvailablePending?: boolean;
-    cancelCurrentIteration?: () => void;
 }
 /**
  * Interface for the subset of bucket state needed by repository management.
@@ -66,7 +66,7 @@ export interface RepositoryDependencies {
     revealFamily?: (familyName: string) => void;
 }
 /**
- * Start (or restart) the per-repository loop and keep loopPromise state accurate.
+ * Start (or restart) the per-repository loop and keep lifecycle state accurate.
  */
 export declare function startRepositoryLoop(repoState: RepositoryState, repoDeps: RepositoryDependencies, sendEvent?: SendEventFn, sessionId?: string): void;
 export declare function createDefaultRepositoryDependencies(fileSystem: FileSystem): RepositoryDependencies;