poe-code 3.0.103 → 3.0.104

package/dist/index.js

@@ -13344,12 +13344,56 @@ var init_pipeline2 = __esm({
   }
 });
 
+// packages/ralph/src/frontmatter/frontmatter.ts
+import { stringify, parse as parse6 } from "yaml";
+function parseFrontmatter(content) {
+  const defaults = { status: "pending", iteration: 0 };
+  if (!content.startsWith(`${FENCE}
+`)) {
+    return { data: defaults, body: content };
+  }
+  const closingIndex = content.indexOf(`
+${FENCE}
+`, FENCE.length);
+  if (closingIndex === -1) {
+    return { data: defaults, body: content };
+  }
+  const yamlBlock = content.slice(FENCE.length + 1, closingIndex);
+  const body = content.slice(closingIndex + FENCE.length + 2);
+  const parsed = parse6(yamlBlock);
+  return {
+    data: {
+      status: isValidStatus(parsed?.status) ? parsed.status : defaults.status,
+      iteration: typeof parsed?.iteration === "number" ? parsed.iteration : defaults.iteration
+    },
+    body
+  };
+}
+function writeFrontmatter(data, body) {
+  const yaml = stringify(data).trimEnd();
+  return `${FENCE}
+${yaml}
+${FENCE}
+${body}`;
+}
+function isValidStatus(value) {
+  return typeof value === "string" && ["pending", "in_progress", "completed", "overbake_abort", "cancelled"].includes(
+    value
+  );
+}
+var FENCE;
+var init_frontmatter = __esm({
+  "packages/ralph/src/frontmatter/frontmatter.ts"() {
+    "use strict";
+    FENCE = "---";
+  }
+});
+
 // packages/ralph/src/discovery/discovery.ts
 import path17 from "node:path";
 import * as fsPromises6 from "node:fs/promises";
 function createDefaultFs4() {
   return {
-    readFile: fsPromises6.readFile,
     readdir: fsPromises6.readdir,
     stat: async (filePath) => {
       const stat8 = await fsPromises6.stat(filePath);
@@ -13472,10 +13516,31 @@ async function runRalph(options) {
     options.cwd,
     options.homeDir
   );
-  const prompt = await fs3.readFile(absoluteDocPath, "utf8");
+  const rawContent = await fs3.readFile(absoluteDocPath, "utf8");
+  const { body: prompt } = parseFrontmatter(rawContent);
   const detector = new OverbakingDetector(threshold);
   const startTime = Date.now();
   let iterationsCompleted = 0;
+  await updateFrontmatter(fs3, absoluteDocPath, prompt, "in_progress", 0);
+  async function finalize2(stopReason) {
+    const status = stopReasonToStatus(stopReason);
+    await updateFrontmatter(
+      fs3,
+      absoluteDocPath,
+      prompt,
+      status,
+      iterationsCompleted
+    );
+    if (stopReason === "max_iterations" && iterationsCompleted > 0) {
+      await archivePlan2(fs3, absoluteDocPath);
+    }
+    return {
+      stopReason,
+      docPath: options.docPath,
+      iterationsCompleted,
+      totalDurationMs: Date.now() - startTime
+    };
+  }
   try {
     for (let iteration = 1; iteration <= options.maxIterations; iteration += 1) {
       assertNotAborted5(options.signal);
@@ -13492,17 +13557,19 @@ async function runRalph(options) {
         });
       } catch (error2) {
         if (isAbortError2(error2)) {
-          return {
-            stopReason: "cancelled",
-            docPath: options.docPath,
-            iterationsCompleted,
-            totalDurationMs: Date.now() - startTime
-          };
+          return finalize2("cancelled");
         }
         throw error2;
       }
       const success2 = result.exitCode === 0;
       iterationsCompleted += 1;
+      await updateFrontmatter(
+        fs3,
+        absoluteDocPath,
+        prompt,
+        "in_progress",
+        iterationsCompleted
+      );
       options.onIterationComplete?.(
         iteration,
         Date.now() - iterationStart,
@@ -13521,35 +13588,21 @@ async function runRalph(options) {
         threshold
       }) : "abort";
       if (action === "abort") {
-        return {
-          stopReason: "overbake_abort",
-          docPath: options.docPath,
-          iterationsCompleted,
-          totalDurationMs: Date.now() - startTime
-        };
+        return finalize2("overbake_abort");
       }
     }
   } catch (error2) {
     if (isAbortError2(error2)) {
-      return {
-        stopReason: "cancelled",
-        docPath: options.docPath,
-        iterationsCompleted,
-        totalDurationMs: Date.now() - startTime
-      };
+      return finalize2("cancelled");
     }
     throw error2;
   }
-  return {
-    stopReason: "max_iterations",
-    docPath: options.docPath,
-    iterationsCompleted,
-    totalDurationMs: Date.now() - startTime
-  };
+  return finalize2("max_iterations");
 }
 function createDefaultFs5() {
   return {
     readFile: fsPromises7.readFile,
+    writeFile: (filePath, content) => fsPromises7.writeFile(filePath, content, "utf8"),
     readdir: fsPromises7.readdir,
     stat: async (filePath) => {
       const stat8 = await fsPromises7.stat(filePath);
@@ -13557,7 +13610,11 @@ function createDefaultFs5() {
         isFile: () => stat8.isFile(),
         mtimeMs: stat8.mtimeMs
       };
-    }
+    },
+    mkdir: async (filePath, options) => {
+      await fsPromises7.mkdir(filePath, options);
+    },
+    rename: fsPromises7.rename
   };
 }
 function resolveAbsoluteDocPath(docPath, cwd, homeDir) {
@@ -13580,10 +13637,33 @@ function createAbortError4() {
 function isAbortError2(error2) {
   return error2 instanceof Error && error2.name === "AbortError";
 }
+async function updateFrontmatter(fs3, absoluteDocPath, body, status, iteration) {
+  const content = writeFrontmatter({ status, iteration }, body);
+  await fs3.writeFile(absoluteDocPath, content);
+}
+async function archivePlan2(fs3, absoluteDocPath) {
+  const dir = path18.dirname(absoluteDocPath);
+  const archiveDir = path18.join(dir, "archive");
+  const archivePath = path18.join(archiveDir, path18.basename(absoluteDocPath));
+  await fs3.mkdir(archiveDir, { recursive: true });
+  await fs3.rename(absoluteDocPath, archivePath);
+}
+function stopReasonToStatus(stopReason) {
+  switch (stopReason) {
+    case "completed":
+    case "max_iterations":
+      return "completed";
+    case "overbake_abort":
+      return "overbake_abort";
+    case "cancelled":
+      return "cancelled";
+  }
+}
 var init_ralph = __esm({
   "packages/ralph/src/run/ralph.ts"() {
     "use strict";
     init_detector();
+    init_frontmatter();
   }
 });
 
@@ -13591,6 +13671,7 @@ var init_ralph = __esm({
 var init_src12 = __esm({
   "packages/ralph/src/index.ts"() {
     "use strict";
+    init_frontmatter();
     init_discovery2();
     init_detector();
     init_ralph();
@@ -21676,7 +21757,7 @@ var init_errors4 = __esm({
 });
 
 // node_modules/zod/v4/core/parse.js
-var _parse, parse6, _parseAsync, parseAsync, _safeParse, safeParse, _safeParseAsync, safeParseAsync, _encode, _decode, _encodeAsync, _decodeAsync, _safeEncode, _safeDecode, _safeEncodeAsync, _safeDecodeAsync;
+var _parse, parse7, _parseAsync, parseAsync, _safeParse, safeParse, _safeParseAsync, safeParseAsync, _encode, _decode, _encodeAsync, _decodeAsync, _safeEncode, _safeDecode, _safeEncodeAsync, _safeDecodeAsync;
 var init_parse = __esm({
   "node_modules/zod/v4/core/parse.js"() {
     init_core();
@@ -21695,7 +21776,7 @@ var init_parse = __esm({
       }
       return result.value;
     };
-    parse6 = /* @__PURE__ */ _parse($ZodRealError);
+    parse7 = /* @__PURE__ */ _parse($ZodRealError);
     _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
       let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -24414,10 +24495,10 @@ var init_schemas = __esm({
           throw new Error("implement() must be called with a function");
         }
         return function(...args) {
-          const parsedArgs = inst._def.input ? parse6(inst._def.input, args) : args;
+          const parsedArgs = inst._def.input ? parse7(inst._def.input, args) : args;
           const result = Reflect.apply(func, this, parsedArgs);
           if (inst._def.output) {
-            return parse6(inst._def.output, result);
+            return parse7(inst._def.output, result);
           }
           return result;
         };
@@ -26973,12 +27054,12 @@ var init_errors5 = __esm({
 });
 
 // node_modules/zod/v4/classic/parse.js
-var parse7, parseAsync2, safeParse2, safeParseAsync2, encode2, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
+var parse8, parseAsync2, safeParse2, safeParseAsync2, encode2, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
 var init_parse3 = __esm({
   "node_modules/zod/v4/classic/parse.js"() {
     init_core2();
     init_errors5();
-    parse7 = /* @__PURE__ */ _parse(ZodRealError);
+    parse8 = /* @__PURE__ */ _parse(ZodRealError);
     parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
     safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
     safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -27654,7 +27735,7 @@ var init_schemas3 = __esm({
         reg.add(inst, meta3);
         return inst;
       });
-      inst.parse = (data, params) => parse7(inst, data, params, { callee: inst.parse });
+      inst.parse = (data, params) => parse8(inst, data, params, { callee: inst.parse });
       inst.safeParse = (data, params) => safeParse2(inst, data, params);
       inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
       inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
@@ -30505,10 +30586,10 @@ var require_code = __commonJS({
     function interpolate2(x) {
       return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify2(Array.isArray(x) ? x.join(",") : x);
     }
-    function stringify(x) {
+    function stringify2(x) {
       return new _Code(safeStringify2(x));
     }
-    exports.stringify = stringify;
+    exports.stringify = stringify2;
     function safeStringify2(x) {
       return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
     }
@@ -33923,24 +34004,24 @@ var require_fast_uri = __commonJS({
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize3(parse8(uri, options), options);
+        serialize3(parse9(uri, options), options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse8(serialize3(uri, options), options);
+        parse9(serialize3(uri, options), options);
       }
       return uri;
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse8(baseURI, schemelessOptions), parse8(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved = resolveComponent(parse9(baseURI, schemelessOptions), parse9(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize3(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse8(serialize3(base, options), options);
-        relative = parse8(serialize3(relative, options), options);
+        base = parse9(serialize3(base, options), options);
+        relative = parse9(serialize3(relative, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative.scheme) {
@@ -33992,13 +34073,13 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       if (typeof uriA === "string") {
         uriA = unescape(uriA);
-        uriA = serialize3(normalizeComponentEncoding(parse8(uriA, options), true), { ...options, skipEscape: true });
+        uriA = serialize3(normalizeComponentEncoding(parse9(uriA, options), true), { ...options, skipEscape: true });
       } else if (typeof uriA === "object") {
         uriA = serialize3(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
       }
       if (typeof uriB === "string") {
         uriB = unescape(uriB);
-        uriB = serialize3(normalizeComponentEncoding(parse8(uriB, options), true), { ...options, skipEscape: true });
+        uriB = serialize3(normalizeComponentEncoding(parse9(uriB, options), true), { ...options, skipEscape: true });
       } else if (typeof uriB === "object") {
         uriB = serialize3(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
       }
@@ -34067,7 +34148,7 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse8(uri, opts) {
+    function parse9(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -34161,7 +34242,7 @@ var require_fast_uri = __commonJS({
       resolveComponent,
       equal,
       serialize: serialize3,
-      parse: parse8
+      parse: parse9
     };
     module.exports = fastUri;
     module.exports.default = fastUri;
@@ -38042,7 +38123,7 @@ var init_configs3 = __esm({
 });
 
 // packages/agent-skill-config/src/templates.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 async function getTemplates() {
   if (templatesCache) {
     return templatesCache;
@@ -38051,7 +38132,7 @@ async function getTemplates() {
     "./templates/poe-generate.md",
     import.meta.url
   );
-  const poeGenerateTemplate = await readFile7(poeGenerateTemplateUrl, "utf8");
+  const poeGenerateTemplate = await readFile6(poeGenerateTemplateUrl, "utf8");
   templatesCache = {
     "poe-generate.md": poeGenerateTemplate
   };
@@ -39018,7 +39099,7 @@ var init_models = __esm({
 
 // src/cli/commands/pipeline.ts
 import path26 from "node:path";
-import { readFile as readFile8, stat as stat7 } from "node:fs/promises";
+import { readFile as readFile7, stat as stat7 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function formatDuration(ms) {
   const totalSeconds = Math.round(ms / 1e3);
@@ -39072,8 +39153,8 @@ async function loadPipelineTemplates() {
       continue;
     }
     const [skillPlan, steps] = await Promise.all([
-      readFile8(path26.join(templateRoot, "SKILL_plan.md"), "utf8"),
-      readFile8(path26.join(templateRoot, "steps.yaml.hbs"), "utf8")
+      readFile7(path26.join(templateRoot, "SKILL_plan.md"), "utf8"),
+      readFile7(path26.join(templateRoot, "steps.yaml.hbs"), "utf8")
     ]);
     pipelineTemplatesCache = { skillPlan, steps };
     return pipelineTemplatesCache;
@@ -39637,7 +39718,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.103",
+      version: "3.0.104",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",