@carljia/omd-dsh 0.1.5 → 0.1.8

package/lib/vendor/omd-plan.mjs

@@ -1,199 +1,117 @@
+// lib/plan.js
 import { mkdir, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
-import { scopeOf } from "@deepseek-ai/dsh-scope";
-/**
- * @module @carljia/omd-dsh/plan
- *
- * omd-plan: plan persistence + plan-mode activation + write scope for the OMD
- * planner mode. Three jobs, all scoped to the planner preset:
- *   1. auto-activate plan mode for the top-level agent, so the plan:policy
- *      section renders and exit_plan_mode works (DSH leaves plan state
- *      inactive until /plan or a programmatic set);
- *   2. enforce a .md-only write guard so the planner stays read-only except
- *      for markdown files;
- *   3. wrap `tools/post-execute` and intercept a successful `exit_plan_mode`
- *      approval: the approved plan text is written into the workspace's plan
- *      directory (a fixed, code-level convention -- never mentioned in any
- *      persona/prompt text), and the tool result content is enriched with the
- *      saved file name so the planner's fixed Start Work final step can hand
- *      it to the user.
- *
- * Plan directory convention (hardcoded here and in omd-start-work only):
- *   <session cwd>/.omd/plans/<slug>-<timestamp>.md
- * The slug derives from the plan's first markdown heading; a timestamp
- * suffix keeps repeated interviews from overwriting each other.
- */
-/** Cordis plugin name. */
-const name = "omd-plan";
-/** No service injection: this row only registers scoped event listeners. */
-const inject = [];
-/** Plan directory segments relative to the session workspace root (cwd). */
-const PLAN_DIR_SEGMENTS = [".omd", "plans"];
-/** The exit tool whose approved plan we persist. */
-const EXIT_PLAN_MODE = "exit_plan_mode";
-/** Maximum slug length (characters). */
-const SLUG_MAX = 48;
-/** The plan's first markdown heading (any level), or undefined when it has none. */
+var name = "omd-plan";
+var inject = [];
+var PLAN_DIR_SEGMENTS = [".omd", "plans"];
+var EXIT_PLAN_MODE = "exit_plan_mode";
+var SLUG_MAX = 48;
 function firstHeading(plan) {
-    for (const line of plan.split("\n")) {
-        const match = /^#{1,6}\s+(.+?)\s*$/.exec(line);
-        if (match)
-            return match[1];
-    }
-    return undefined;
+  for (const line of plan.split("\n")) {
+    const match = /^#{1,6}\s+(.+?)\s*$/.exec(line);
+    if (match)
+      return match[1];
+  }
+  return void 0;
 }
-/** Derive a filesystem-safe slug from the plan title. */
 function slugify(title) {
-    const slug = String(title)
-        .normalize("NFKD")
-        .toLowerCase()
-        .replace(/[^\p{L}\p{N}]+/gu, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, SLUG_MAX);
-    return slug === "" ? "plan" : slug;
+  const slug = String(title).normalize("NFKD").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, SLUG_MAX);
+  return slug === "" ? "plan" : slug;
 }
-/** Compact local-ish UTC timestamp for the file name: YYYYMMDD-HHmmss. */
 function timestamp() {
-    const d = new Date();
-    const pad = (n) => String(n).padStart(2, "0");
-    return (d.getUTCFullYear() +
-        pad(d.getUTCMonth() + 1) +
-        pad(d.getUTCDate()) +
-        "-" +
-        pad(d.getUTCHours()) +
-        pad(d.getUTCMinutes()) +
-        pad(d.getUTCSeconds()));
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return d.getUTCFullYear() + pad(d.getUTCMonth() + 1) + pad(d.getUTCDate()) + "-" + pad(d.getUTCHours()) + pad(d.getUTCMinutes()) + pad(d.getUTCSeconds());
 }
-/** Write the plan into <cwd>/.omd/plans/ and return the absolute file path. */
 async function savePlan(cwd, plan) {
-    const dir = join(cwd, ...PLAN_DIR_SEGMENTS);
-    await mkdir(dir, { recursive: true });
-    const file = join(dir, slugify(firstHeading(plan) ?? "") + "-" + timestamp() + ".md");
-    await writeFile(file, plan, "utf8");
-    return file;
+  const dir = join(cwd, ...PLAN_DIR_SEGMENTS);
+  await mkdir(dir, { recursive: true });
+  const file = join(dir, slugify(firstHeading(plan) ?? "") + "-" + timestamp() + ".md");
+  await writeFile(file, plan, "utf8");
+  return file;
 }
-/** Display path used in result enrichment and messages (forward slashes). */
 function displayPath(saved) {
-    return PLAN_DIR_SEGMENTS.join("/") + "/" + basename(saved);
+  return PLAN_DIR_SEGMENTS.join("/") + "/" + basename(saved);
 }
-/** Subagents never own the plan review -- only the top-level planner does. */
 function isSubagent(agent) {
-    return (agent !== undefined &&
-        agent !== null &&
-        agent.options !== undefined &&
-        agent.options !== null &&
-        typeof agent.options.subagentDepth === "number" &&
-        agent.options.subagentDepth > 0);
+  return agent !== void 0 && agent !== null && agent.options !== void 0 && agent.options !== null && typeof agent.options.subagentDepth === "number" && agent.options.subagentDepth > 0;
 }
-/** Fold the session's plan/mode events (last one wins); mirror mode.ts. */
 function planModeActive(events) {
-    let active = false;
-    for (const event of events ?? []) {
-        if (event !== undefined && event.type === "plan/mode") {
-            active = event.data !== undefined && event.data !== null && event.data.active === true;
-        }
+  let active = false;
+  for (const event of events ?? []) {
+    if (event !== void 0 && event.type === "plan/mode") {
+      active = event.data !== void 0 && event.data !== null && event.data.active === true;
     }
-    return active;
+  }
+  return active;
 }
 function apply(ctx) {
-    if (scopeOf(ctx) === undefined) {
-        throw new Error("omd-plan: refusing to mount outside a scoped context; mount this row inside an agent preset");
+  ctx.on("tools/pre-execute", async (exec, next) => {
+    const toolName = exec !== void 0 && exec !== null ? exec.name : void 0;
+    if (toolName !== "write" && toolName !== "edit")
+      return await next();
+    const filePath = exec.arguments !== void 0 && exec.arguments !== null && typeof exec.arguments.file_path === "string" ? exec.arguments.file_path : void 0;
+    if (filePath !== void 0 && filePath.toLowerCase().endsWith(".md"))
+      return await next();
+    return {
+      kind: "deny",
+      reason: "omd-plan: the planner preset may write or edit only .md files (refusing " + toolName + " on a non-.md path)"
+    };
+  });
+  ctx.on("agent/pre-step", async ({ agent }, next) => {
+    if (agent !== void 0 && agent !== null && !isSubagent(agent) && agent.session !== void 0 && agent.session !== null) {
+      if (!planModeActive(agent.session.events)) {
+        agent.session.append("plan/mode", { active: true });
+      }
+    }
+    return await next();
+  });
+  ctx.on("tools/post-execute", async (exec, result, next) => {
+    const decision = await next();
+    if (decision.kind !== "accept" || decision.value !== void 0)
+      return decision;
+    if (exec === void 0 || exec.name !== EXIT_PLAN_MODE)
+      return decision;
+    if (result.isError)
+      return decision;
+    const agent = exec.agent;
+    if (agent === void 0 || isSubagent(agent))
+      return decision;
+    const args = exec.arguments;
+    const plan = args !== void 0 && args !== null && typeof args.plan === "string" ? args.plan : void 0;
+    if (plan === void 0)
+      return decision;
+    const cwd = agent.session !== void 0 && agent.session.header !== void 0 && typeof agent.session.header.cwd === "string" ? agent.session.header.cwd : "";
+    if (cwd === "") {
+      return withNotice(decision, result, {
+        type: "text",
+        text: "The approved plan could NOT be saved automatically: this session has no workspace directory. Ask the user how to proceed."
+      });
     }
-    // Scoped .md-only write guard: the planner may write/edit only markdown
-    // files, keeping it read-only for every other path. The plan file itself is
-    // written by this row via node:fs (not through the model's write/edit tools),
-    // so plan persistence is unaffected by the guard. Implemented on the
-    // tools/pre-execute gate (the row's existing ctx.on style) so no service
-    // injection is required.
-    ctx.on("tools/pre-execute", async (exec, next) => {
-        const toolName = exec !== undefined && exec !== null ? exec.name : undefined;
-        if (toolName !== "write" && toolName !== "edit")
-            return await next();
-        const filePath = exec.arguments !== undefined &&
-            exec.arguments !== null &&
-            typeof exec.arguments.file_path === "string"
-            ? exec.arguments.file_path
-            : undefined;
-        if (filePath !== undefined && filePath.toLowerCase().endsWith(".md"))
-            return await next();
-        return {
-            kind: "deny",
-            reason: "omd-plan: the planner preset may write or edit only .md files (refusing " +
-                toolName +
-                " on a non-.md path)",
-        };
-    });
-    // Auto-activate plan mode for the top-level planner agent. DSH leaves plan
-    // state inactive until /plan or a programmatic set, so without this the
-    // plan:policy section never renders and exit_plan_mode fails with "only
-    // available in plan mode". Mirror mode.ts's direct log append (no narration)
-    // so the planner session is in plan mode from its first request onward.
-    ctx.on("agent/pre-step", async ({ agent }, next) => {
-        if (agent !== undefined && agent !== null && !isSubagent(agent) && agent.session !== undefined && agent.session !== null) {
-            if (!planModeActive(agent.session.events)) {
-                agent.session.append("plan/mode", { active: true });
-            }
-        }
-        return await next();
-    });
-    ctx.on("tools/post-execute", async (exec, result, next) => {
-        const decision = await next();
-        if (decision.kind !== "accept" || decision.value !== undefined)
-            return decision;
-        if (exec === undefined || exec.name !== EXIT_PLAN_MODE)
-            return decision;
-        if (result.isError)
-            return decision;
-        const agent = exec.agent;
-        if (agent === undefined || isSubagent(agent))
-            return decision;
-        const args = exec.arguments;
-        const plan = args !== undefined && args !== null && typeof args.plan === "string" ? args.plan : undefined;
-        if (plan === undefined)
-            return decision;
-        const cwd = agent.session !== undefined &&
-            agent.session.header !== undefined &&
-            typeof agent.session.header.cwd === "string"
-            ? agent.session.header.cwd
-            : "";
-        if (cwd === "") {
-            // No workspace root to save into: fail closed but tell the model, so
-            // the planner does not promise a file name it never produced.
-            return withNotice(decision, result, {
-                type: "text",
-                text: "The approved plan could NOT be saved automatically: this session has no workspace directory. Ask the user how to proceed.",
-            });
-        }
-        try {
-            const saved = await savePlan(cwd, plan);
-            return withNotice(decision, result, {
-                type: "text",
-                text: "Plan saved to " +
-                    displayPath(saved) +
-                    ". Start work: run /start-work " +
-                    basename(saved) +
-                    " in an omd-executor session, or switch this session with /mode omd-executor and continue here.",
-            });
-        }
-        catch (error) {
-            return withNotice(decision, result, {
-                type: "text",
-                text: "The approved plan could NOT be saved automatically: " +
-                    (error instanceof Error ? error.message : String(error)) +
-                    ". Ask the user how to proceed.",
-            });
-        }
-    });
+    try {
+      const saved = await savePlan(cwd, plan);
+      return withNotice(decision, result, {
+        type: "text",
+        text: "Plan saved to " + displayPath(saved) + ". Start work: run /start-work " + basename(saved) + " in an omd-executor session, or switch this session with /mode omd-executor and continue here."
+      });
+    } catch (error) {
+      return withNotice(decision, result, {
+        type: "text",
+        text: "The approved plan could NOT be saved automatically: " + (error instanceof Error ? error.message : String(error)) + ". Ask the user how to proceed."
+      });
+    }
+  });
 }
-/** Keep the accepted decision, appending one text block to its content. */
 function withNotice(decision, result, block) {
-    const base = Array.isArray(decision.content) ? decision.content : result.content ?? [];
-    return {
-        kind: "accept",
-        content: [...base, block],
-        ...(decision.additionalContexts !== undefined
-            ? { additionalContexts: decision.additionalContexts }
-            : {}),
-    };
+  const base = Array.isArray(decision.content) ? decision.content : result.content ?? [];
+  return {
+    kind: "accept",
+    content: [...base, block],
+    ...decision.additionalContexts !== void 0 ? { additionalContexts: decision.additionalContexts } : {}
+  };
 }
-export { apply, inject, name };
+export {
+  apply,
+  inject,
+  name
+};

package/lib/vendor/omd-start-work.mjs

@@ -1,147 +1,111 @@
+// lib/startwork.js
 import { access, readFile } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
-import { scopeOf } from "@deepseek-ai/dsh-scope";
-/**
- * @module @carljia/omd-dsh/startwork
- *
- * omd-start-work: human-facing `/start-work` command -- the "start work"
- * trigger at the end of the OMD planning workflow. It resolves the named
- * plan file inside the workspace's plan directory (a fixed, code-level
- * convention -- never mentioned in any persona/prompt text), arms a goal
- * whose objective references the plan's absolute path, and goal
- * auto-continuation then drives the agent to execute the plan without
- * further input.
- */
-/** Cordis plugin name. */
-const name = "omd-start-work";
-/** The goal domain is already required by tool-goal in the same preset. */
-const inject = ["goals"];
-/** Plan directory segments relative to the session workspace root (cwd). */
-const PLAN_DIR_SEGMENTS = [".omd", "plans"];
-/** The prefix accepted when a user pastes the full relative plan path. */
-const PLAN_DIR_PREFIX = ".omd/plans/";
-/** Plan directory for one workspace root. */
+var name = "omd-start-work";
+var inject = ["goals"];
+var PLAN_DIR_SEGMENTS = [".omd", "plans"];
+var PLAN_DIR_PREFIX = ".omd/plans/";
 function plansDir(cwd) {
-    return join(cwd, ...PLAN_DIR_SEGMENTS);
+  return join(cwd, ...PLAN_DIR_SEGMENTS);
 }
-/**
- * Resolve the user's file-name input to a candidate path inside the plan
- * directory. Accepts a bare file name ("foo.md" / "foo") or the full
- * relative path (".omd/plans/foo.md"); rejects absolute paths and anything
- * that would escape the plan directory.
- */
 function resolveCandidate(cwd, input) {
-    const trimmed = String(input).trim().replace(/\\/g, "/");
-    if (trimmed === "" || isAbsolute(trimmed))
-        return undefined;
-    let name = trimmed.replace(/^\.\//, "");
-    if (name.includes("/")) {
-        if (!name.startsWith(PLAN_DIR_PREFIX))
-            return undefined;
-        name = name.slice(PLAN_DIR_PREFIX.length);
-    }
-    if (name === "" || name.includes("/") || name === "." || name === "..")
-        return undefined;
-    if (name.startsWith("."))
-        return undefined; // no hidden-file tricks
-    return join(plansDir(cwd), name);
+  const trimmed = String(input).trim().replace(/\\/g, "/");
+  if (trimmed === "" || isAbsolute(trimmed))
+    return void 0;
+  let name2 = trimmed.replace(/^\.\//, "");
+  if (name2.includes("/")) {
+    if (!name2.startsWith(PLAN_DIR_PREFIX))
+      return void 0;
+    name2 = name2.slice(PLAN_DIR_PREFIX.length);
+  }
+  if (name2 === "" || name2.includes("/") || name2 === "." || name2 === "..")
+    return void 0;
+  if (name2.startsWith("."))
+    return void 0;
+  return join(plansDir(cwd), name2);
 }
-/** One /start-work invocation through the goal domain. */
 async function executeStartWork(ctx, invocation) {
-    const agent = invocation.agent;
-    const cwd = agent !== undefined &&
-        agent.session !== undefined &&
-        agent.session.header !== undefined &&
-        typeof agent.session.header.cwd === "string"
-        ? agent.session.header.cwd
-        : "";
-    if (cwd === "") {
-        return {
-            kind: "error",
-            text: "This session has no workspace directory; /start-work needs one to find the plan file.",
-        };
-    }
-    const candidate = resolveCandidate(cwd, invocation.rawInput);
-    if (candidate === undefined) {
-        return {
-            kind: "error",
-            text: "Usage: /start-work <plan file name> — the file must live inside " + PLAN_DIR_SEGMENTS.join("/") + "/.",
-        };
-    }
-    let file = candidate;
-    const usable = async (path) => {
-        try {
-            await access(path);
-            return true;
-        }
-        catch {
-            return false;
-        }
+  const agent = invocation.agent;
+  const cwd = agent !== void 0 && agent.session !== void 0 && agent.session.header !== void 0 && typeof agent.session.header.cwd === "string" ? agent.session.header.cwd : "";
+  if (cwd === "") {
+    return {
+      kind: "error",
+      text: "This session has no workspace directory; /start-work needs one to find the plan file."
     };
-    if (!(await usable(file)) && !file.endsWith(".md") && (await usable(file + ".md"))) {
-        file = file + ".md";
-    }
-    else if (!(await usable(file))) {
-        return {
-            kind: "error",
-            text: "Plan file not found: " + PLAN_DIR_SEGMENTS.join("/") + "/" + file.slice(plansDir(cwd).length + 1),
-        };
-    }
-    let text;
-    try {
-        text = await readFile(file, "utf8");
-    }
-    catch (error) {
-        return {
-            kind: "error",
-            text: "Cannot read the plan file: " + (error instanceof Error ? error.message : String(error)),
-        };
-    }
-    if (text.trim() === "") {
-        return { kind: "error", text: "The plan file is empty." };
-    }
+  }
+  const candidate = resolveCandidate(cwd, invocation.rawInput);
+  if (candidate === void 0) {
+    return {
+      kind: "error",
+      text: "Usage: /start-work <plan file name> \u2014 the file must live inside " + PLAN_DIR_SEGMENTS.join("/") + "/."
+    };
+  }
+  let file = candidate;
+  const usable = async (path) => {
     try {
-        const current = ctx.goals.get(agent);
-        if (current !== undefined && current.phase !== "complete") {
-            return {
-                kind: "error",
-                text: `A goal is already ${current.phase}. Run /goal clear first, then /start-work <plan file name>.`,
-            };
-        }
-        ctx.goals.create(agent, {
-            objective: "Execute the approved plan file at " +
-                file +
-                ". Read the file in full, then carry out every step autonomously: implement, verify, and iterate until the plan's goal and success criteria are met. Work through goal continuation rounds until done.",
-        });
-        return {
-            kind: "success",
-            text: "Start work armed — executing the plan to completion.\nPlan: " +
-                PLAN_DIR_SEGMENTS.join("/") +
-                "/" +
-                file.slice(plansDir(cwd).length + 1),
-        };
+      await access(path);
+      return true;
+    } catch {
+      return false;
     }
-    catch (error) {
-        return {
-            kind: "error",
-            text: "start-work failed: " + (error instanceof Error ? error.message : String(error)),
-        };
+  };
+  if (!await usable(file) && !file.endsWith(".md") && await usable(file + ".md")) {
+    file = file + ".md";
+  } else if (!await usable(file)) {
+    return {
+      kind: "error",
+      text: "Plan file not found: " + PLAN_DIR_SEGMENTS.join("/") + "/" + file.slice(plansDir(cwd).length + 1)
+    };
+  }
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (error) {
+    return {
+      kind: "error",
+      text: "Cannot read the plan file: " + (error instanceof Error ? error.message : String(error))
+    };
+  }
+  if (text.trim() === "") {
+    return { kind: "error", text: "The plan file is empty." };
+  }
+  try {
+    const current = ctx.goals.get(agent);
+    if (current !== void 0 && current.phase !== "complete") {
+      return {
+        kind: "error",
+        text: `A goal is already ${current.phase}. Run /goal clear first, then /start-work <plan file name>.`
+      };
     }
+    ctx.goals.create(agent, {
+      objective: "Execute the approved plan file at " + file + ". Read the file in full, then carry out every step autonomously: implement, verify, and iterate until the plan's goal and success criteria are met. Work through goal continuation rounds until done."
+    });
+    return {
+      kind: "success",
+      text: "Start work armed \u2014 executing the plan to completion.\nPlan: " + PLAN_DIR_SEGMENTS.join("/") + "/" + file.slice(plansDir(cwd).length + 1)
+    };
+  } catch (error) {
+    return {
+      kind: "error",
+      text: "start-work failed: " + (error instanceof Error ? error.message : String(error))
+    };
+  }
 }
 function apply(ctx) {
-    if (scopeOf(ctx) === undefined) {
-        throw new Error("omd-start-work: refusing to mount outside a scoped context; mount this row inside an agent preset");
-    }
-    ctx.inject(["commands"], (commandCtx) => {
-        commandCtx.commands.register({
-            name: "start-work",
-            description: "start work: arm a goal that executes the named plan file to completion",
-            input: {
-                hint: "<plan file name>",
-                images: false,
-            },
-            handler: (invocation) => executeStartWork(ctx, invocation),
-        });
+  ctx.inject(["commands"], (commandCtx) => {
+    commandCtx.commands.register({
+      name: "start-work",
+      description: "start work: arm a goal that executes the named plan file to completion",
+      input: {
+        hint: "<plan file name>",
+        images: false
+      },
+      handler: (invocation) => executeStartWork(ctx, invocation)
     });
+  });
 }
-export { apply, inject, name };
+export {
+  apply,
+  inject,
+  name
+};