@joshski/dust 0.1.91 → 0.1.93

package/dist/artifacts/index.d.ts

@@ -40,6 +40,7 @@ export interface ArtifactsRepository {
     createRefineIdeaTask(options: {
         ideaSlug: string;
         description?: string;
+        openQuestionResponses?: OpenQuestionResponse[];
         dustCommand?: string;
     }): Promise<CreateIdeaTransitionTaskResult>;
     createDecomposeIdeaTask(options: DecomposeIdeaOptions & {

package/dist/artifacts/workflow-tasks.d.ts

@@ -45,7 +45,7 @@ export interface DecomposeIdeaOptions {
     description?: string;
     openQuestionResponses?: OpenQuestionResponse[];
 }
-export declare function createRefineIdeaTask(fileSystem: FileSystem, dustPath: string, ideaSlug: string, description?: string, dustCommand?: string): Promise<CreateIdeaTransitionTaskResult>;
+export declare function createRefineIdeaTask(fileSystem: FileSystem, dustPath: string, ideaSlug: string, description?: string, openQuestionResponses?: OpenQuestionResponse[], dustCommand?: string): Promise<CreateIdeaTransitionTaskResult>;
 export declare function decomposeIdea(fileSystem: FileSystem, dustPath: string, options: DecomposeIdeaOptions, dustCommand?: string): Promise<CreateIdeaTransitionTaskResult>;
 export declare function createShelveIdeaTask(fileSystem: FileSystem, dustPath: string, ideaSlug: string, description?: string, _dustCommand?: string): Promise<CreateIdeaTransitionTaskResult>;
 export declare function createIdeaTask(fileSystem: FileSystem, dustPath: string, options: {

package/dist/artifacts.js

@@ -460,14 +460,17 @@ async function createIdeaTransitionTask(fileSystem, dustPath, workflowType, pref
   await fileSystem.writeFile(filePath, content);
   return { filePath };
 }
-async function createRefineIdeaTask(fileSystem, dustPath, ideaSlug, description, dustCommand) {
+async function createRefineIdeaTask(fileSystem, dustPath, ideaSlug, description, openQuestionResponses, dustCommand) {
   const cmd = dustCommand ?? "dust";
   return createIdeaTransitionTask(fileSystem, dustPath, "refine-idea", "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",
     "Idea file is updated with findings"
-  ], "Refines Idea", { description });
+  ], "Refines Idea", {
+    description,
+    resolvedQuestions: openQuestionResponses
+  });
 }
 async function decomposeIdea(fileSystem, dustPath, options, dustCommand) {
   const cmd = dustCommand ?? "dust";
@@ -632,7 +635,7 @@ function buildArtifactsRepository(fileSystem, dustPath) {
       return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, "")).sort();
     },
     async createRefineIdeaTask(options) {
-      return createRefineIdeaTask(fileSystem, dustPath, options.ideaSlug, options.description, options.dustCommand);
+      return createRefineIdeaTask(fileSystem, dustPath, options.ideaSlug, options.description, options.openQuestionResponses, options.dustCommand);
     },
     async createDecomposeIdeaTask(options) {
       return decomposeIdea(fileSystem, dustPath, options, options.dustCommand);

package/dist/dust.js

@@ -500,7 +500,7 @@ async function loadSettings(cwd, fileSystem) {
 }
 
 // lib/version.ts
-var DUST_VERSION = "0.1.91";
+var DUST_VERSION = "0.1.93";
 
 // lib/session.ts
 var DUST_UNATTENDED = "DUST_UNATTENDED";
@@ -2072,6 +2072,7 @@ import { spawn as nodeSpawn5 } from "node:child_process";
 import { accessSync, statSync } from "node:fs";
 import { chmod, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
+import { basename as basename2, resolve } from "node:path";
 
 // lib/bucket/auth.ts
 import { join as join5 } from "node:path";
@@ -2562,6 +2563,25 @@ function selectAgentCapabilities(input) {
   }
   return agents;
 }
+async function fetchCodexModelsFromApi(apiKey) {
+  try {
+    const response = await fetch("https://api.openai.com/v1/models", {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!response.ok) {
+      log2(`OpenAI models API returned ${response.status}`);
+      return [];
+    }
+    const body = await response.json();
+    if (!body.data || !Array.isArray(body.data)) {
+      return [];
+    }
+    return body.data.map((m) => m.id).filter((id) => id.includes("codex")).sort();
+  } catch (error) {
+    log2(`OpenAI models API fetch failed: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
 async function discoverAgentCapabilities(dependencies) {
   const [claudeVersionProbe, codexVersionProbe] = await Promise.all([
     probeCommand(dependencies.spawn, "claude", ["--version"]),
@@ -2569,10 +2589,18 @@ async function discoverAgentCapabilities(dependencies) {
   ]);
   let codexModelsProbe = null;
   if (codexVersionProbe.success) {
-    codexModelsProbe = await probeCommand(dependencies.spawn, "codex", [
-      "models",
-      "--json"
-    ]);
+    const getEnv = dependencies.getEnv ?? ((name) => process.env[name]);
+    const apiKey = getEnv("OPENAI_API_KEY");
+    if (apiKey) {
+      const fetcher = dependencies.fetchCodexModelsFromApi ?? fetchCodexModelsFromApi;
+      const models = await fetcher(apiKey);
+      if (models.length > 0) {
+        codexModelsProbe = {
+          success: true,
+          stdout: JSON.stringify(models)
+        };
+      }
+    }
   }
   return {
     type: "agent-capabilities",
@@ -5600,7 +5628,7 @@ function createDefaultBucketDependencies() {
     getTerminalSize: defaultGetTerminalSize,
     writeStdout: defaultWriteStdout,
     isTTY: process.stdout.isTTY ?? false,
-    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
     getReposDir: () => getReposDir(process.env, homedir2()),
     auth: {
       createServer: createLocalServer,
@@ -5744,8 +5772,8 @@ function createTUIContext(state, context, useTUI) {
 function waitForConnection(token, bucketDeps) {
   const wsUrl = getWebSocketUrl();
   const ws = bucketDeps.createWebSocket(wsUrl, token);
-  return new Promise((resolve, reject) => {
-    ws.onopen = () => resolve(ws);
+  return new Promise((resolve2, reject) => {
+    ws.onopen = () => resolve2(ws);
     ws.onerror = (error) => reject(new Error(error.message));
     ws.onclose = (event) => reject(new Error(`Connection closed (code ${event.code})`));
   });
@@ -6140,24 +6168,51 @@ async function bucketWorker(dependencies, bucketDeps = createDefaultBucketDepend
   } catch {
     state.ui.connectedHost = wsUrl;
   }
+  function findRepoPathByRepositoryId(repositories, repositoryId) {
+    for (const repoState of repositories.values()) {
+      if (repoState.repository.id === repositoryId) {
+        return repoState.path;
+      }
+    }
+    return;
+  }
   let tuiHandle;
   let cleanupKeypress;
   let cleanupSignals;
-  const forwardToolExecution = (request) => {
+  const forwardToolExecution = async (request) => {
     const ws = state.ws;
     if (!ws || ws.readyState !== WS_OPEN) {
       log10(`tool execution rejected: ${request.toolName} (WebSocket not connected)`);
-      return Promise.resolve({
+      return {
         status: "error",
         error: "Bucket session is not connected"
-      });
+      };
     }
     const requestId = crypto.randomUUID();
+    const repoPath = findRepoPathByRepositoryId(state.repositories, Number(request.repositoryId));
     const toolDef = state.tools.find((t) => t.name === request.toolName);
     const namedArgs = {};
     if (toolDef) {
       for (let i = 0;i < toolDef.parameters.length && i < request.arguments.length; i++) {
-        namedArgs[toolDef.parameters[i].name] = request.arguments[i];
+        const param = toolDef.parameters[i];
+        const value = request.arguments[i];
+        if (param.type === "file" && typeof value === "string") {
+          const filePath = repoPath ? resolve(repoPath, value) : value;
+          try {
+            const data = await readFile(filePath);
+            namedArgs[param.name] = {
+              filename: basename2(value),
+              data: data.toString("base64")
+            };
+          } catch {
+            return {
+              status: "error",
+              error: `Unable to read file: ${value}`
+            };
+          }
+        } else {
+          namedArgs[param.name] = value;
+        }
       }
     } else {
       for (let i = 0;i < request.arguments.length; i++) {
@@ -6172,14 +6227,14 @@ async function bucketWorker(dependencies, bucketDeps = createDefaultBucketDepend
       arguments: namedArgs
     };
     log10(`forwarding tool execution: ${request.toolName} requestId=${requestId}`);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timeoutId = setTimeout(() => {
         pendingToolExecutions.delete(requestId);
         log10(`tool execution timed out: ${request.toolName} requestId=${requestId}`);
         reject(new Error("Timed out waiting for tool execution result"));
       }, 30000);
       pendingToolExecutions.set(requestId, {
-        resolve,
+        resolve: resolve2,
         reject,
         timeoutId
       });
@@ -6197,10 +6252,10 @@ async function bucketWorker(dependencies, bucketDeps = createDefaultBucketDepend
     if (useTUI) {
       tuiHandle = setupTUI(state, bucketDeps);
     }
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       const doShutdown = async () => {
         await shutdown(state, bucketDeps, context);
-        resolve();
+        resolve2();
       };
       const onKey = createKeypressHandler(useTUI, state, () => {
         doShutdown();
@@ -6405,7 +6460,7 @@ function createGitRunner(spawnFn) {
 }
 var defaultGitRunner = createGitRunner(spawn);
 function runBufferedProcess(spawnFn, command, commandArguments, cwd, shell, timeoutMs) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const proc = spawnFn(command, commandArguments, { cwd, shell });
     const chunks = [];
     let resolved = false;
@@ -6417,7 +6472,7 @@ function runBufferedProcess(spawnFn, command, commandArguments, cwd, shell, time
         proc.stdout?.destroy();
         proc.stderr?.destroy();
         proc.unref();
-        resolve({
+        resolve2({
           exitCode: 1,
           output: chunks.join(""),
           timedOut: true
@@ -6435,14 +6490,14 @@ function runBufferedProcess(spawnFn, command, commandArguments, cwd, shell, time
         return;
       if (timer !== undefined)
         clearTimeout(timer);
-      resolve({ exitCode: code ?? 1, output: chunks.join("") });
+      resolve2({ exitCode: code ?? 1, output: chunks.join("") });
     });
     proc.on("error", (error) => {
       if (resolved)
         return;
       if (timer !== undefined)
         clearTimeout(timer);
-      resolve({ exitCode: 1, output: error.message });
+      resolve2({ exitCode: 1, output: error.message });
     });
   });
 }
@@ -6903,7 +6958,7 @@ function validateWorkflowTaskBodySection(filePath, content, ideasPath, fileSyste
 }
 
 // lib/lint/validators/link-validator.ts
-import { dirname as dirname3, resolve } from "node:path";
+import { dirname as dirname3, resolve as resolve2 } from "node:path";
 var SEMANTIC_RULES = [
   {
     section: "## Principles",
@@ -6936,7 +6991,7 @@ function validateLinks(filePath, content, fileSystem) {
           });
         } else {
           const targetPath = linkTarget.split("#")[0];
-          const resolvedPath = resolve(fileDir, targetPath);
+          const resolvedPath = resolve2(fileDir, targetPath);
           if (!fileSystem.exists(resolvedPath)) {
             violations.push({
               file: filePath,
@@ -6989,7 +7044,7 @@ function validateSemanticLinks(filePath, content) {
         continue;
       }
       const targetPath = linkTarget.split("#")[0];
-      const resolvedPath = resolve(fileDir, targetPath);
+      const resolvedPath = resolve2(fileDir, targetPath);
       if (!resolvedPath.includes(rule.requiredPath)) {
         violations.push({
           file: filePath,
@@ -7040,7 +7095,7 @@ function validatePrincipleHierarchyLinks(filePath, content) {
         continue;
       }
       const targetPath = linkTarget.split("#")[0];
-      const resolvedPath = resolve(fileDir, targetPath);
+      const resolvedPath = resolve2(fileDir, targetPath);
       if (!resolvedPath.includes("/.dust/principles/")) {
         violations.push({
           file: filePath,
@@ -7055,7 +7110,7 @@ function validatePrincipleHierarchyLinks(filePath, content) {
 }
 
 // lib/lint/validators/principle-hierarchy.ts
-import { dirname as dirname4, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, resolve as resolve3 } from "node:path";
 var REQUIRED_PRINCIPLE_HEADINGS = ["## Parent Principle", "## Sub-Principles"];
 function validatePrincipleHierarchySections(filePath, content) {
   const violations = [];
@@ -7090,7 +7145,7 @@ function extractPrincipleRelationships(filePath, content) {
       const linkTarget = match[2];
       if (!linkTarget.startsWith("#") && !linkTarget.startsWith("http://") && !linkTarget.startsWith("https://")) {
         const targetPath = linkTarget.split("#")[0];
-        const resolvedPath = resolve2(fileDir, targetPath);
+        const resolvedPath = resolve3(fileDir, targetPath);
         if (resolvedPath.includes("/.dust/principles/")) {
           if (currentSection === "## Parent Principle") {
             parentPrinciples.push(resolvedPath);
@@ -7742,7 +7797,7 @@ async function init(dependencies) {
 }
 
 // lib/cli/commands/list.ts
-import { basename as basename2 } from "node:path";
+import { basename as basename3 } from "node:path";
 function workflowTypeToStatus(type) {
   switch (type) {
     case "refine-idea":
@@ -7775,7 +7830,7 @@ async function buildPrincipleHierarchy(principlesPath, fileSystem) {
     const filePath = `${principlesPath}/${file}`;
     const content = await fileSystem.readFile(filePath);
     relationships.push(extractPrincipleRelationships(filePath, content));
-    const title = extractTitle(content) || basename2(file, ".md");
+    const title = extractTitle(content) || basename3(file, ".md");
     titleMap.set(filePath, title);
   }
   const relMap = new Map;
@@ -7793,7 +7848,7 @@ async function buildPrincipleHierarchy(principlesPath, fileSystem) {
     }
     return {
       filePath,
-      title: titleMap.get(filePath) || basename2(filePath, ".md"),
+      title: titleMap.get(filePath) || basename3(filePath, ".md"),
       children
     };
   }
@@ -7812,7 +7867,12 @@ function renderHierarchy(nodes, output, prefix = "") {
   }
 }
 async function list(dependencies) {
-  const { arguments: commandArguments, context, fileSystem } = dependencies;
+  const {
+    arguments: commandArguments,
+    context,
+    fileSystem,
+    settings
+  } = dependencies;
   const dustPath = `${context.cwd}/.dust`;
   const colors = getColors();
   if (!fileSystem.exists(dustPath)) {
@@ -7827,6 +7887,7 @@ async function list(dependencies) {
     return { exitCode: 1 };
   }
   const specificTypeRequested = commandArguments.length > 0;
+  const showTaskCreationHint = specificTypeRequested && typesToList.length === 1 && typesToList[0] === "tasks";
   const workflowTasks = typesToList.includes("ideas") && fileSystem.exists(dustPath) ? await findAllWorkflowTasks(fileSystem, dustPath) : null;
   for (const type of typesToList) {
     const dirPath = `${dustPath}/${type}`;
@@ -7911,6 +7972,11 @@ async function list(dependencies) {
       });
     }
   }
+  if (showTaskCreationHint) {
+    context.stdout("➕ Add a New Task");
+    context.stdout("");
+    context.stdout(`Run \`${settings.dustCommand} new task\``);
+  }
   return { exitCode: 0 };
 }
 
@@ -8113,7 +8179,7 @@ function newTaskInstructions(vars) {
   steps.push("   - The goal is a task description with minimal ambiguity at implementation time");
   steps.push("4. Create a new markdown file in `.dust/tasks/` with a descriptive kebab-case name (e.g., `add-user-authentication.md`)");
   steps.push("5. Add a title as the first line using an H1 heading (e.g., `# Add user authentication`)");
-  steps.push('6. Write a comprehensive description starting with an imperative opening sentence (e.g., "Add caching to the API layer." not "This task adds caching."). Include technical details and references to relevant files.');
+  steps.push('6. Write a comprehensive description starting with an imperative opening sentence (e.g., "Add caching to the API layer." not "This task adds caching."). The opening sentence must be 150 characters or fewer. Include technical details and references to relevant files.');
   steps.push("7. Add a `## Principles` section with links to relevant principles this task supports (e.g., `- [Principle Name](../principles/principle-name.md)`)");
   steps.push("8. Add a `## Blocked By` section listing any tasks that must complete first, or `(none)` if there are no blockers");
   steps.push("9. Add a `## Definition of Done` section with a checklist of completion criteria using `- [ ]` for each item");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.91",
+  "version": "0.1.93",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {