@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/slash/prompt-workflows.js

@@ -1,8 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { fileURLToPath } from "node:url";
 import { parseFrontmatter } from "../agents/frontmatter.js";
-import { getAgentDir, getProjectConfigDir } from "../shared/utils.js";
+import { getPromptDirectories } from "../shared/prompt-resources.js";
 const RESERVED_COMMAND_NAMES = new Set([
   "chain-prompts",
   "prompt-workflow",
@@ -13,19 +12,9 @@ const RESERVED_COMMAND_NAMES = new Set([
   "subagents-doctor",
   "subagents-models"
 ]);
-function packagePromptsDir() {
-  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "prompts");
-}
-function promptDirs(cwd) {
-  return [
-    packagePromptsDir(),
-    path.join(getAgentDir(), "prompts"),
-    path.join(getProjectConfigDir(cwd), "prompts")
-  ];
-}
 function readPromptFiles(cwd) {
   const files = [];
-  for (const dir of promptDirs(cwd)) {
+  for (const dir of Object.values(getPromptDirectories(cwd))) {
     let entries;
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -89,7 +78,6 @@ function loadPromptWorkflow(filePath) {
     ...model ? { model } : {},
     ...skill !== undefined ? { skill } : {},
     ...cwd ? { cwd } : {},
-    ...booleanField(frontmatter, "worktree") === true ? { worktree: true } : {},
     ...chain ? { chain } : {}
   };
 }
@@ -150,7 +138,6 @@ function parseRuntimeOptions(words) {
   let agentOverride;
   let fork = false;
   let fresh = false;
-  let worktree = false;
   let bg = false;
   for (let i = 0;i < words.length; i++) {
     const word = words[i];
@@ -162,10 +149,6 @@ function parseRuntimeOptions(words) {
       fresh = true;
       continue;
     }
-    if (word === "--worktree") {
-      worktree = true;
-      continue;
-    }
     if (word === "--bg" || word === "--async") {
       bg = true;
       continue;
@@ -181,13 +164,7 @@ function parseRuntimeOptions(words) {
     }
     args.push(word);
   }
-  return { args, agentOverride, fork, fresh, worktree, bg };
-}
-function splitChainDeclaration(input) {
-  const delimiter = input.indexOf(" -- ");
-  if (delimiter === -1)
-    return { declaration: input.trim(), argsText: "" };
-  return { declaration: input.slice(0, delimiter).trim(), argsText: input.slice(delimiter + 4).trim() };
+  return { args, agentOverride, fork, fresh, bg };
 }
 function splitPromptChain(input) {
   return input.split(" -> ").map((part) => part.trim()).filter(Boolean);
@@ -198,26 +175,40 @@ function workflowParams(workflow, args, runtime) {
   return {
     agent: runtime.agentOverride ?? workflow.agent,
     task,
-    clarify: false,
     agentScope: "both",
     ...context ? { context } : {},
     ...workflow.model ? { model: workflow.model } : {},
     ...workflow.skill !== undefined ? { skill: workflow.skill } : {},
-    ...workflow.cwd ? { cwd: workflow.cwd } : {},
-    ...runtime.worktree || workflow.worktree ? { worktree: true } : {},
-    ...runtime.bg ? { async: true } : {}
+    ...workflow.cwd ? { cwd: workflow.cwd } : {}
   };
 }
-function workflowChainStep(workflow, args, runtime) {
-  const params = workflowParams(workflow, args, runtime);
+function promptWorkflowExecutionParams(workflows, args, runtime) {
   return {
-    agent: params.agent ?? "delegate",
-    task: params.task,
-    ...params.model ? { model: params.model } : {},
-    ...params.skill !== undefined ? { skill: params.skill } : {},
-    ...params.cwd ? { cwd: params.cwd } : {}
+    workflowScript: promptWorkflowScript(workflows, args, runtime),
+    agentScope: "both",
+    async: runtime.bg ? true : false
   };
 }
+function promptWorkflowScript(workflows, args, runtime) {
+  const launches = workflows.map((workflow, index) => {
+    const params = workflowParams(workflow, args, runtime);
+    const task = params.task ?? "";
+    const child = {
+      agent: params.agent ?? "delegate",
+      task,
+      ...params.model ? { model: params.model } : {},
+      ...params.skill !== undefined ? { skill: params.skill } : {},
+      ...params.cwd ? { cwd: params.cwd } : {},
+      ...params.context ? { context: params.context } : {}
+    };
+    return `const step${index} = await runs.run(${JSON.stringify(`prompt-${index + 1}-${workflow.name}`)}, { ...${JSON.stringify(child)}, task: ${JSON.stringify(task)}.replaceAll("{previous}", previous) });
+previous = step${index}.output;`;
+  });
+  return `let previous = "";
+${launches.join(`
+`)}
+return previous;`;
+}
 function findWorkflow(workflows, name) {
   return workflows.find((workflow) => workflow.name === name);
 }
@@ -231,15 +222,15 @@ function formatWorkflowList(workflows) {
 `);
 }
 export function registerPromptWorkflowCommands(input) {
-  const { pi, run } = input;
-  pi.registerCommand("prompt-workflow", {
+  const { dm, run } = input;
+  dm.registerCommand("prompt-workflow", {
     description: "Run a prompt template through native dm-subagents: /prompt-workflow <name> [args]",
     handler: async (rawArgs, ctx) => {
       const words = shellWords(rawArgs);
       const name = words.shift();
       const workflows = discoverPromptWorkflows(ctx.cwd);
       if (!name || name === "list") {
-        pi.sendMessage({ content: formatWorkflowList(workflows), display: true });
+        dm.sendMessage({ content: formatWorkflowList(workflows), display: true });
         return;
       }
       const workflow = findWorkflow(workflows, name);
@@ -250,45 +241,16 @@ export function registerPromptWorkflowCommands(input) {
       const runtime = parseRuntimeOptions(words);
       try {
         if (workflow.chain) {
-          const chainNames = splitPromptChain(workflow.chain);
-          const chain = chainNames.map((stepName) => {
+          const chain = splitPromptChain(workflow.chain).map((stepName) => {
             const step = findWorkflow(workflows, stepName);
             if (!step)
               throw new Error(`Unknown prompt workflow in chain '${workflow.name}': ${stepName}`);
-            return workflowChainStep(step, runtime.args, runtime);
+            return step;
           });
-          await run({ chain, task: runtime.args.join(" "), clarify: false, agentScope: "both", ...runtime.bg ? { async: true } : {} }, ctx);
+          await run(promptWorkflowExecutionParams(chain, runtime.args, runtime), ctx);
           return;
         }
-        await run(workflowParams(workflow, runtime.args, runtime), ctx);
-      } catch (error) {
-        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-      }
-    }
-  });
-  pi.registerCommand("chain-prompts", {
-    description: "Run prompt templates as a native subagent chain: /chain-prompts analyze -> fix -- args",
-    handler: async (rawArgs, ctx) => {
-      const { declaration, argsText } = splitChainDeclaration(rawArgs);
-      const workflows = discoverPromptWorkflows(ctx.cwd);
-      if (!declaration || declaration === "list") {
-        pi.sendMessage({ content: formatWorkflowList(workflows), display: true });
-        return;
-      }
-      const runtime = parseRuntimeOptions(shellWords(argsText));
-      const names = splitPromptChain(declaration);
-      if (names.length === 0) {
-        ctx.ui.notify("Usage: /chain-prompts prompt-a -> prompt-b -- args", "error");
-        return;
-      }
-      try {
-        const chain = names.map((name) => {
-          const workflow = findWorkflow(workflows, name);
-          if (!workflow)
-            throw new Error(`Unknown prompt workflow: ${name}`);
-          return workflowChainStep(workflow, runtime.args, runtime);
-        });
-        await run({ chain, task: runtime.args.join(" "), clarify: false, agentScope: "both", ...runtime.bg ? { async: true } : {} }, ctx);
+        await run(promptWorkflowExecutionParams([workflow], runtime.args, runtime), ctx);
       } catch (error) {
         ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
       }

package/extensions/dm-subagents/src/slash/selector.js

@@ -0,0 +1,101 @@
+import { DynamicBorder, keyHint, rawKeyHint } from "@duckmind/dm-coding-agent";
+import { Container, fuzzyFilter, Input, Spacer, Text } from "@duckmind/dm-tui";
+const MAX_VISIBLE = 10;
+
+export class SelectorComponent extends Container {
+  tui;
+  theme;
+  keybindings;
+  items;
+  done;
+  searchInput;
+  listContainer;
+  filtered;
+  selectedIndex = 0;
+  constructor(tui, theme, keybindings, options) {
+    super();
+    this.tui = tui;
+    this.theme = theme;
+    this.keybindings = keybindings;
+    this.items = options.items;
+    this.done = options.done;
+    this.filtered = [...this.items];
+    const border = () => new DynamicBorder((str) => theme.fg("border", str));
+    this.addChild(border());
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(theme.fg("accent", theme.bold(options.title)), 0, 0));
+    if (options.subtitle)
+      this.addChild(new Text(theme.fg("muted", options.subtitle), 0, 0));
+    this.addChild(new Spacer(1));
+    this.searchInput = new Input;
+    this.searchInput.focused = true;
+    this.searchInput.onSubmit = () => this.confirmSelection();
+    this.addChild(this.searchInput);
+    this.addChild(new Spacer(1));
+    this.listContainer = new Container;
+    this.addChild(this.listContainer);
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(rawKeyHint("↑↓", "navigate") + "  " + keyHint("tui.select.confirm", "select") + "  " + keyHint("tui.select.cancel", "cancel"), 0, 0));
+    this.addChild(new Spacer(1));
+    this.addChild(border());
+    const currentIndex = this.filtered.findIndex((item) => item.current);
+    if (currentIndex >= 0)
+      this.selectedIndex = currentIndex;
+    this.updateList();
+  }
+  applyFilter(query) {
+    const previous = this.filtered[this.selectedIndex]?.value;
+    this.filtered = query ? fuzzyFilter(this.items, query, (item) => `${item.label} ${item.value} ${item.badge ?? ""}`) : [...this.items];
+    const keepIndex = this.filtered.findIndex((item) => item.value === previous);
+    this.selectedIndex = keepIndex >= 0 ? keepIndex : Math.min(this.selectedIndex, Math.max(0, this.filtered.length - 1));
+    this.updateList();
+  }
+  updateList() {
+    const th = this.theme;
+    this.listContainer.clear();
+    const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(MAX_VISIBLE / 2), this.filtered.length - MAX_VISIBLE));
+    const endIndex = Math.min(startIndex + MAX_VISIBLE, this.filtered.length);
+    for (let i = startIndex;i < endIndex; i++) {
+      const item = this.filtered[i];
+      const isSelected = i === this.selectedIndex;
+      const badge = item.badge ? ` ${th.fg("muted", `[${item.badge}]`)}` : "";
+      const checkmark = item.current ? th.fg("success", " ✓") : "";
+      const line = isSelected ? `${th.fg("accent", "→ ")}${th.fg("accent", item.label)}${badge}${checkmark}` : `  ${item.label}${badge}${checkmark}`;
+      this.listContainer.addChild(new Text(line, 0, 0));
+    }
+    if (startIndex > 0 || endIndex < this.filtered.length) {
+      this.listContainer.addChild(new Text(th.fg("muted", `  (${this.selectedIndex + 1}/${this.filtered.length})`), 0, 0));
+    }
+    if (this.filtered.length === 0) {
+      this.listContainer.addChild(new Text(th.fg("muted", "  No matching entries"), 0, 0));
+    }
+  }
+  confirmSelection() {
+    const selected = this.filtered[this.selectedIndex];
+    this.done(selected ? { confirmed: true, value: selected.value } : { confirmed: false });
+  }
+  handleInput(keyData) {
+    const kb = this.keybindings;
+    if (kb.matches(keyData, "tui.select.up")) {
+      if (this.filtered.length === 0)
+        return;
+      this.selectedIndex = this.selectedIndex === 0 ? this.filtered.length - 1 : this.selectedIndex - 1;
+      this.updateList();
+      this.tui.requestRender();
+    } else if (kb.matches(keyData, "tui.select.down")) {
+      if (this.filtered.length === 0)
+        return;
+      this.selectedIndex = this.selectedIndex === this.filtered.length - 1 ? 0 : this.selectedIndex + 1;
+      this.updateList();
+      this.tui.requestRender();
+    } else if (kb.matches(keyData, "tui.select.confirm")) {
+      this.confirmSelection();
+    } else if (kb.matches(keyData, "tui.select.cancel")) {
+      this.done({ confirmed: false });
+    } else {
+      this.searchInput.handleInput(keyData);
+      this.applyFilter(this.searchInput.getValue());
+      this.tui.requestRender();
+    }
+  }
+}

package/extensions/dm-subagents/src/slash/slash-bridge.js

@@ -1,3 +1,4 @@
+import { normalizePublicSubagentExecution } from "../extension/public-execution.js";
 import {
   SLASH_SUBAGENT_CANCEL_EVENT,
   SLASH_SUBAGENT_REQUEST_EVENT,
@@ -33,7 +34,22 @@ export function registerSlashSubagentBridge(options) {
     const request = data;
     if (typeof request.requestId !== "string" || !request.params)
       return;
-    const { requestId, params } = request;
+    const { requestId } = request;
+    const normalized = normalizePublicSubagentExecution(request.params);
+    if (!normalized.ok) {
+      options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
+        requestId,
+        result: {
+          content: [{ type: "text", text: normalized.error }],
+          isError: true,
+          details: { mode: normalized.mode, results: [] }
+        },
+        isError: true,
+        errorText: normalized.error
+      });
+      return;
+    }
+    const params = normalized.params;
     const ctx = request.ctx ?? options.getContext();
     if (!ctx) {
       const response = {