poe-code 3.0.361 → 3.0.362

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.361",
+  "version": "3.0.362",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/agent-harness-tools/dist/runner.js

@@ -230,7 +230,7 @@ export async function runDocumentWorkflow(options) {
             return;
         }
         let shouldStop = false;
-        for (let iteration = 0; iteration < initialWorkflow.maxIterations; iteration += 1) {
+        for (let iteration = 0;; iteration += 1) {
             throwIfAborted(options.signal);
             currentWorkflow = iteration === 0 ? initialWorkflow : await readWorkflow();
             if (iteration >= currentWorkflow.maxIterations) {
@@ -266,6 +266,9 @@ export async function runDocumentWorkflow(options) {
             if (shouldStop) {
                 break;
             }
+            if (iteration + 1 >= currentWorkflow.maxIterations) {
+                break;
+            }
         }
     }
     catch (error) {

package/packages/package-lint/dist/rules/no-published-to-private-dep.js

@@ -15,9 +15,20 @@ export const noPublishedToPrivateDep = {
                 continue;
             for (const edge of dependencyEdges(consumer)) {
                 const dep = model.byName.get(edge.name);
-                if (!dep || !dep.private)
+                if (!dep)
                     continue;
                 if (edge.field !== "peerDependencies" && consumer.bundledDependencies.includes(dep.name)) {
+                    violations.push(...collectBundledPrivateDependencyViolations({
+                        consumer,
+                        bundledRoot: dep,
+                        modelByName: model.byName,
+                        consumerBundled: new Set(consumer.bundledDependencies),
+                        via: [dep.name]
+                    }));
+                    if (dep.private)
+                        continue;
+                }
+                if (!dep.private) {
                     continue;
                 }
                 violations.push({
@@ -34,3 +45,45 @@ export const noPublishedToPrivateDep = {
         return violations;
     }
 };
+function collectBundledPrivateDependencyViolations(options) {
+    const violations = [];
+    const visited = new Set();
+    const pending = [
+        { pkg: options.bundledRoot, via: options.via }
+    ];
+    while (pending.length > 0) {
+        const current = pending.shift();
+        if (visited.has(current.pkg.name)) {
+            continue;
+        }
+        visited.add(current.pkg.name);
+        for (const edge of dependencyEdges(current.pkg)) {
+            const dep = options.modelByName.get(edge.name);
+            if (!dep || !dep.private) {
+                continue;
+            }
+            if (isBundledRuntimeEdge(current.pkg, edge, dep, options.consumerBundled)) {
+                pending.push({ pkg: dep, via: [...current.via, dep.name] });
+                continue;
+            }
+            violations.push({
+                rule: id,
+                package: options.consumer.name,
+                severity: "error",
+                via: edge.field,
+                detail: {
+                    dependency: dep.name,
+                    field: edge.field,
+                    bundledVia: current.via
+                },
+                message: `published package bundles ${current.via.join(" -> ")}, whose ${edge.field} requires private workspace package ${dep.name}`,
+                fix: `Bundle ${dep.name} into ${current.pkg.name}, publish ${dep.name}, or remove the ${edge.field} edge from the bundled package manifest.`
+            });
+        }
+    }
+    return violations;
+}
+function isBundledRuntimeEdge(pkg, edge, dep, consumerBundled) {
+    return (edge.field !== "peerDependencies" &&
+        (pkg.bundledDependencies.includes(dep.name) || consumerBundled.has(dep.name)));
+}

package/packages/package-lint/dist/rules/published-dep-needs-version-range.js

@@ -1,3 +1,4 @@
+import semver from "semver";
 import { allPackages, dependencyEdges, isPublishedNpm } from "../model.js";
 const id = "published-dep-needs-version-range";
 /** A `*` / `workspace:*`-style range that does not pin to a bounded set of versions. */
@@ -36,13 +37,30 @@ export const publishedDepNeedsVersionRange = {
                 const dep = model.byName.get(edge.name);
                 if (!dep || !isPublishedNpm(dep))
                     continue;
-                if (!isLooseRange(edge.spec))
-                    continue;
                 if (edge.field !== "peerDependencies" && consumer.bundledDependencies.includes(dep.name)) {
                     continue;
                 }
+                if (!isLooseRange(edge.spec) && !semver.satisfies(dep.version, edge.spec)) {
+                    violations.push({
+                        rule: id,
+                        package: consumer.name,
+                        severity: "error",
+                        via: edge.field,
+                        detail: {
+                            dependency: dep.name,
+                            field: edge.field,
+                            range: edge.spec,
+                            version: dep.version
+                        },
+                        message: `published dependency ${dep.name}@${edge.spec} does not include workspace version ${dep.version}`,
+                        fix: `Replace "${edge.spec}" with a concrete range that includes ${dep.version}, such as "^${dep.version}".`
+                    });
+                    continue;
+                }
                 if (isDeclaredLockstepDependency(model, consumer.dir, dep.dir))
                     continue;
+                if (!isLooseRange(edge.spec))
+                    continue;
                 violations.push({
                     rule: id,
                     package: consumer.name,

package/packages/ralph/dist/frontmatter/frontmatter.js

@@ -146,17 +146,18 @@ export function parseFrontmatterData(value) {
             throw new Error('Invalid Ralph frontmatter: "kind" must be "ralph".');
         }
     }
-    const statusValue = parsed ? getOwnEntry(parsed, "status") : undefined;
-    const parsedStatus = isRecord(statusValue) ? statusValue : undefined;
-    const state = parsePlanStatus(parsedStatus ? getOwnEntry(parsedStatus, "state") : undefined) ??
-        parseLegacyStatus(statusValue) ??
-        defaults.status.state;
-    const iteration = parseNonNegativeInteger(parsedStatus ? getOwnEntry(parsedStatus, "iteration") : undefined) ??
-        parseNonNegativeInteger(parsed ? getOwnEntry(parsed, "iteration") : undefined) ??
-        defaults.status.iteration;
-    const agent = parseAgent(parsed ? getOwnEntry(parsed, "agent") : undefined);
+    const { state, iteration } = parseStatusFields(parsed, defaults.status);
+    const agentValue = parsed ? getOwnEntry(parsed, "agent") : undefined;
+    const agent = parseAgent(agentValue);
+    if (parsed !== undefined && hasOwnEntry(parsed, "agent") && agent === undefined) {
+        throw new Error('Invalid Ralph frontmatter: "agent" must be a non-empty string or non-empty string array.');
+    }
     const extendsValue = parseBoolean(parsed ? getOwnEntry(parsed, "extends") : undefined);
-    const iterations = parsePositiveInteger(parsed ? getOwnEntry(parsed, "iterations") : undefined);
+    const iterationsValue = parsed ? getOwnEntry(parsed, "iterations") : undefined;
+    const iterations = parsePositiveInteger(iterationsValue);
+    if (parsed !== undefined && hasOwnEntry(parsed, "iterations") && iterations === undefined) {
+        throw new Error('Invalid Ralph frontmatter: "iterations" must be a positive integer.');
+    }
     const skills = parseSkills(parsed ? getOwnEntry(parsed, "skills") : undefined);
     const hooks = parseHooks(parsed ? getOwnEntry(parsed, "hooks") : undefined);
     return {
@@ -171,6 +172,44 @@ export function parseFrontmatterData(value) {
         }
     };
 }
+function parseStatusFields(parsed, defaults) {
+    if (parsed === undefined) {
+        return defaults;
+    }
+    const statusValue = getOwnEntry(parsed, "status");
+    const legacyIterationValue = getOwnEntry(parsed, "iteration");
+    const hasStatus = hasOwnEntry(parsed, "status");
+    const hasLegacyIteration = hasOwnEntry(parsed, "iteration");
+    const parsedStatus = isRecord(statusValue) ? statusValue : undefined;
+    if (hasLegacyIteration && parseNonNegativeInteger(legacyIterationValue) === undefined) {
+        throw new Error('Invalid Ralph frontmatter: "iteration" must be a non-negative integer.');
+    }
+    if (parsedStatus !== undefined) {
+        rejectUnknownKeys(parsedStatus, ["state", "iteration"], "status");
+        const statusStateValue = getOwnEntry(parsedStatus, "state");
+        const statusIterationValue = getOwnEntry(parsedStatus, "iteration");
+        const state = parsePlanStatus(statusStateValue);
+        const iteration = parseNonNegativeInteger(statusIterationValue);
+        if (hasOwnEntry(parsedStatus, "state") && state === undefined) {
+            throw new Error('Invalid Ralph frontmatter: "status.state" must be "open", "in_progress", "completed", or "failed".');
+        }
+        if (hasOwnEntry(parsedStatus, "iteration") && iteration === undefined) {
+            throw new Error('Invalid Ralph frontmatter: "status.iteration" must be a non-negative integer.');
+        }
+        return {
+            state: state ?? defaults.state,
+            iteration: iteration ?? parseNonNegativeInteger(legacyIterationValue) ?? defaults.iteration
+        };
+    }
+    const legacyState = parseLegacyStatus(statusValue);
+    if (hasStatus && legacyState === undefined) {
+        throw new Error('Invalid Ralph frontmatter: "status" must be "open", "pending", "cancelled", "overbake_abort", "in_progress", or "completed".');
+    }
+    return {
+        state: legacyState ?? defaults.state,
+        iteration: parseNonNegativeInteger(legacyIterationValue) ?? defaults.iteration
+    };
+}
 function parseAgent(value) {
     if (typeof value === "string") {
         const trimmed = value.trim();
@@ -180,7 +219,7 @@ function parseAgent(value) {
         return undefined;
     }
     if (value.length === 0) {
-        return [];
+        return undefined;
     }
     const agents = [];
     for (const item of value) {
@@ -281,6 +320,9 @@ function parseBoolean(value) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function hasOwnEntry(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
 function getOwnEntry(record, key) {
-    return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+    return hasOwnEntry(record, key) ? record[key] : undefined;
 }

package/packages/ralph/dist/run/ralph.js

@@ -143,7 +143,7 @@ export async function runRalph(options) {
                     await updateFrontmatter(fs, absoluteDocPath, "open", iterationsCompleted);
                     return;
                 }
-                if (iterationNumber === config.maxIterations) {
+                if (iterationNumber === currentConfig.maxIterations) {
                     await updateFrontmatter(fs, absoluteDocPath, "completed", iterationsCompleted);
                     stopReason = "max_iterations";
                     return;