@ricsam/r5d-worker 0.0.107 → 0.0.109

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.107",
+  "version": "0.0.109",
   "type": "commonjs"
 }

package/dist/cjs/plan-lint.cjs

@@ -0,0 +1,165 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_lint_exports = {};
+__export(plan_lint_exports, {
+  formatPlanLintErrors: () => formatPlanLintErrors,
+  lintPlanContent: () => lintPlanContent,
+  lintPlans: () => lintPlans
+});
+module.exports = __toCommonJS(plan_lint_exports);
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_picomatch = __toESM(require("picomatch"), 1);
+var import_plan_parser = require("./plan-parser.cjs");
+var import_plan_paths = require("./plan-paths.cjs");
+var import_plan_parser2 = require("./plan-parser.cjs");
+const LEGACY_SCHEMA_FIELD_REGEX = /^\s*(type|status|parent|phase|discovered_problem)\s*:/m;
+function lintPlanContent(planId, content) {
+  const errors = [];
+  const lines = content.split(/\r?\n/);
+  if (/^---(?:\r?\n|$)/.test(content)) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "YAML frontmatter is not supported. Use plain Markdown with a ## Tasks checklist.",
+      line: 1
+    });
+  }
+  if (LEGACY_SCHEMA_FIELD_REGEX.test(content)) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "Legacy plan schema fields are not supported. Remove type/status/parent/phase/discovered_problem metadata."
+    });
+  }
+  const titleLineIndex = lines.findIndex((line) => /^# .+\S\s*$/.test(line));
+  if (titleLineIndex === -1) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "Plan must start with or contain an H1 title, for example '# Implementation Plan'."
+    });
+  }
+  const range = (0, import_plan_parser.getTasksSectionRange)(content);
+  if (!range) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "Plan is missing a ## Tasks section."
+    });
+    return errors;
+  }
+  const taskIds = /* @__PURE__ */ new Set();
+  let taskCount = 0;
+  for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
+    const line = lines[index] ?? "";
+    if (line.trim() === "") continue;
+    const match = line.match(import_plan_parser.PLAN_TASK_LINE_REGEX);
+    if (!match || !match[3].trim()) {
+      errors.push({
+        planId,
+        severity: "error",
+        line: index + 1,
+        message: 'Malformed task line. Use "- [ ] task-id: Description" or "- [x] task-id: Description".'
+      });
+      continue;
+    }
+    taskCount += 1;
+    const taskId = match[2];
+    if (taskIds.has(taskId)) {
+      errors.push({
+        planId,
+        severity: "error",
+        line: index + 1,
+        message: `Duplicate task id "${taskId}".`
+      });
+    }
+    taskIds.add(taskId);
+  }
+  if (taskCount === 0) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "Plan must include at least one task in the ## Tasks section.",
+      line: range.startIndex + 1
+    });
+  }
+  return errors;
+}
+async function lintPlans(plansDir, glob) {
+  const errors = [];
+  let entries;
+  try {
+    entries = await import_promises.default.readdir(plansDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    entries = [];
+  }
+  const matches = glob ? (0, import_picomatch.default)(glob) : null;
+  let lintedPlanCount = 0;
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(import_plan_paths.PLAN_EXTENSION)) continue;
+    const planId = entry.name.slice(0, -import_plan_paths.PLAN_EXTENSION.length);
+    if (!import_plan_parser2.PLAN_TASK_ID_REGEX.test(planId) || matches && !matches(entry.name) && !matches(planId)) continue;
+    const content = await import_promises.default.readFile(import_node_path.default.join(plansDir, entry.name), "utf8");
+    lintedPlanCount += 1;
+    errors.push(...lintPlanContent(planId, content));
+  }
+  return {
+    type: "plan_lint",
+    errors,
+    errorCount: errors.filter((error) => error.severity === "error").length,
+    warningCount: errors.filter((error) => error.severity === "warning").length,
+    lintedPlanCount
+  };
+}
+function formatPlanLintErrors(errors) {
+  if (errors.length === 0) return "";
+  const lines = ["## Plan Lint Errors", ""];
+  const byPlan = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    byPlan.set(error.planId, [...byPlan.get(error.planId) ?? [], error]);
+  }
+  for (const [planId, planErrors] of byPlan) {
+    lines.push(`### ${planId}.plan.md`);
+    for (const error of planErrors) {
+      const location = error.line ? ` line ${error.line}` : "";
+      lines.push(`- ${error.severity.toUpperCase()}${location}: ${error.message}`);
+    }
+    lines.push("");
+  }
+  lines.push("Fix these issues by editing the Markdown plan file.");
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatPlanLintErrors,
+  lintPlanContent,
+  lintPlans
+});

package/dist/cjs/plan-parser.cjs

@@ -0,0 +1,127 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_parser_exports = {};
+__export(plan_parser_exports, {
+  PLAN_TASKS_HEADING_REGEX: () => PLAN_TASKS_HEADING_REGEX,
+  PLAN_TASK_ID_REGEX: () => PLAN_TASK_ID_REGEX,
+  PLAN_TASK_LINE_REGEX: () => PLAN_TASK_LINE_REGEX,
+  createPlanMarkdown: () => createPlanMarkdown,
+  formatPlanTitle: () => formatPlanTitle,
+  getPlanMetadata: () => getPlanMetadata,
+  getTasksSectionRange: () => getTasksSectionRange,
+  parseMarkdownPlan: () => parseMarkdownPlan,
+  parsePlan: () => parsePlan,
+  updateTaskCheckbox: () => updateTaskCheckbox
+});
+module.exports = __toCommonJS(plan_parser_exports);
+const PLAN_TASK_ID_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+const PLAN_TASK_LINE_REGEX = /^- \[( |x)\] ([a-z0-9][a-z0-9-]*): (.+)$/;
+const PLAN_TASKS_HEADING_REGEX = /^## Tasks\s*$/;
+function getPlanMetadata(content) {
+  const title = content.split(/\r?\n/).map((line) => line.match(/^# (.+)$/)?.[1]?.trim()).find((value) => Boolean(value));
+  return { title: title || "Untitled Plan" };
+}
+function getTasksSectionRange(content) {
+  const lines = content.split(/\r?\n/);
+  const startIndex = lines.findIndex((line) => PLAN_TASKS_HEADING_REGEX.test(line));
+  if (startIndex === -1) return null;
+  let endIndex = lines.length;
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    if (/^##\s+/.test(lines[index] ?? "")) {
+      endIndex = index;
+      break;
+    }
+  }
+  return { startIndex, endIndex };
+}
+function parseMarkdownPlan(content, planId) {
+  const lines = content.split(/\r?\n/);
+  const { title } = getPlanMetadata(content);
+  const range = getTasksSectionRange(content);
+  const tasks = [];
+  if (range) {
+    for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
+      const line = lines[index] ?? "";
+      const match = line.match(PLAN_TASK_LINE_REGEX);
+      if (!match) continue;
+      const description = match[3].trim();
+      if (!description) continue;
+      tasks.push({
+        id: match[2],
+        description,
+        checked: match[1] === "x",
+        lineNumber: index + 1
+      });
+    }
+  }
+  const currentTask = tasks.find((task) => !task.checked) ?? null;
+  return {
+    id: planId,
+    title,
+    content,
+    tasks,
+    currentTask,
+    complete: tasks.length > 0 && tasks.every((task) => task.checked),
+    tasksStartLine: range ? range.startIndex + 1 : null,
+    tasksEndLine: range ? range.endIndex : null
+  };
+}
+const parsePlan = parseMarkdownPlan;
+function createPlanMarkdown(planId, title = formatPlanTitle(planId)) {
+  return `# ${title}
+
+Brief implementation notes.
+
+## Tasks
+`;
+}
+function updateTaskCheckbox(content, taskId, checked) {
+  if (!PLAN_TASK_ID_REGEX.test(taskId)) {
+    throw new Error(`Invalid task id: ${taskId}`);
+  }
+  const lines = content.split(/\r?\n/);
+  const range = getTasksSectionRange(content);
+  if (!range) {
+    throw new Error("Plan is missing a ## Tasks section.");
+  }
+  for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
+    const line = lines[index] ?? "";
+    const match = line.match(PLAN_TASK_LINE_REGEX);
+    if (!match || match[2] !== taskId) continue;
+    lines[index] = `- [${checked ? "x" : " "}] ${match[2]}: ${match[3].trim()}`;
+    return lines.join("\n");
+  }
+  throw new Error(`Task not found in plan: ${taskId}`);
+}
+function formatPlanTitle(planId) {
+  return planId.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PLAN_TASKS_HEADING_REGEX,
+  PLAN_TASK_ID_REGEX,
+  PLAN_TASK_LINE_REGEX,
+  createPlanMarkdown,
+  formatPlanTitle,
+  getPlanMetadata,
+  getTasksSectionRange,
+  parseMarkdownPlan,
+  parsePlan,
+  updateTaskCheckbox
+});

package/dist/cjs/plan-paths.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_paths_exports = {};
+__export(plan_paths_exports, {
+  PLAN_EXTENSION: () => PLAN_EXTENSION,
+  assertPlanTarget: () => assertPlanTarget,
+  getWorkerPlanPath: () => getWorkerPlanPath,
+  getWorkerPlansPath: () => getWorkerPlansPath,
+  validatePlanId: () => validatePlanId
+});
+module.exports = __toCommonJS(plan_paths_exports);
+var import_plan_parser = require("./plan-parser.cjs");
+const PLAN_EXTENSION = ".plan.md";
+function validatePlanId(planId) {
+  if (!import_plan_parser.PLAN_TASK_ID_REGEX.test(planId)) throw new Error(`Invalid plan id: ${planId}`);
+}
+function assertPlanTarget(target) {
+  if (target.type === "workspace" && target.rootProfile !== "visible_projects") {
+    throw new Error("Ordinary plans are unavailable in canonical synchronization sessions");
+  }
+}
+function getWorkerPlansPath(target) {
+  assertPlanTarget(target);
+  return target.type === "project" ? "$R5D_ROOT/plans/$R5D_PROJECT_ID/$R5D_BRANCH_NAME" : "$R5D_ROOT/plans/workspace";
+}
+function getWorkerPlanPath(target, planId) {
+  validatePlanId(planId);
+  return `${getWorkerPlansPath(target)}/${planId}${PLAN_EXTENSION}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PLAN_EXTENSION,
+  assertPlanTarget,
+  getWorkerPlanPath,
+  getWorkerPlansPath,
+  validatePlanId
+});

package/dist/cjs/recovery-output-window.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recovery_output_window_exports = {};
+__export(recovery_output_window_exports, {
+  WorkerOutputWindow: () => WorkerOutputWindow
+});
+module.exports = __toCommonJS(recovery_output_window_exports);
+const keyOf = (runId, stream) => `${runId}:${stream}`;
+class WorkerOutputWindow {
+  constructor(windowBytes = 1024 * 1024) {
+    this.windowBytes = windowBytes;
+  }
+  windowBytes;
+  sent = /* @__PURE__ */ new Map();
+  acknowledged = /* @__PURE__ */ new Map();
+  outstanding = 0;
+  reset(cursors) {
+    this.sent.clear();
+    this.acknowledged.clear();
+    this.outstanding = 0;
+    for (const cursor of cursors) {
+      for (const stream of ["stdout", "stderr"]) {
+        const offset = stream === "stdout" ? cursor.stdoutBytes : cursor.stderrBytes;
+        this.sent.set(keyOf(cursor.runId, stream), offset);
+        this.acknowledged.set(keyOf(cursor.runId, stream), offset);
+      }
+    }
+  }
+  send(frame, send, bufferedAmount = 0) {
+    const key = keyOf(frame.runId, frame.stream);
+    const sent = this.sent.get(key) ?? 0;
+    const bytes = Buffer.from(frame.data, "utf8");
+    const end = frame.offset + bytes.length;
+    if (end <= sent) return true;
+    if (frame.offset > sent) return false;
+    let cursor = sent;
+    while (cursor < end) {
+      let count = Math.min(end - cursor, 64 * 1024, this.windowBytes - this.outstanding);
+      while (count > 0 && ((bytes[cursor - frame.offset + count] ?? 0) & 192) === 128) count -= 1;
+      if (count <= 0 || bufferedAmount >= this.windowBytes) return false;
+      const data = bytes.subarray(cursor - frame.offset, cursor - frame.offset + count).toString("utf8");
+      if (!send({ ...frame, offset: cursor, data })) return false;
+      cursor += count;
+      this.sent.set(key, cursor);
+      this.outstanding += count;
+    }
+    return true;
+  }
+  acknowledge(runId, stream, offset) {
+    if (!Number.isSafeInteger(offset) || offset < 0) return;
+    const key = keyOf(runId, stream);
+    const previous = this.acknowledged.get(key) ?? 0;
+    const next = Math.max(previous, Math.min(this.sent.get(key) ?? 0, offset));
+    this.acknowledged.set(key, next);
+    this.outstanding = Math.max(0, this.outstanding - (next - previous));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorkerOutputWindow
+});

package/dist/cjs/recovery-protocol.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recovery_protocol_exports = {};
+__export(recovery_protocol_exports, {
+  WORKER_RECOVERY_TIMEOUT_MS: () => WORKER_RECOVERY_TIMEOUT_MS,
+  WORKER_RESUMABLE_PROTOCOL: () => WORKER_RESUMABLE_PROTOCOL
+});
+module.exports = __toCommonJS(recovery_protocol_exports);
+const WORKER_RESUMABLE_PROTOCOL = 1;
+const WORKER_RECOVERY_TIMEOUT_MS = 5 * 60 * 1e3;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKER_RECOVERY_TIMEOUT_MS,
+  WORKER_RESUMABLE_PROTOCOL
+});