codetrellis 0.0.0-stage → 0.3.0

package/src/shared/lib/matcher.js

@@ -0,0 +1,120 @@
+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 matcher_exports = {};
+__export(matcher_exports, {
+  MATCH_KINDS: () => MATCH_KINDS,
+  globSource: () => globSource,
+  lineMatches: () => lineMatches,
+  matcherOf: () => matcherOf,
+  regexProblem: () => regexProblem,
+  splitTarget: () => splitTarget,
+  thresholdProblem: () => thresholdProblem,
+  underPattern: () => underPattern,
+  wholly: () => wholly
+});
+module.exports = __toCommonJS(matcher_exports);
+var import_fuzzy = require("./fuzzy");
+const MATCH_KINDS = ["glob", "regex", "fuzzy"];
+const MAX_PATTERN = 200;
+const escapeRe = (s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+function globSource(glob) {
+  let out = "";
+  for (let i = 0; i < glob.length; ) {
+    if (glob.startsWith("**", i)) {
+      const wholeFolder = (i === 0 || glob[i - 1] === "/") && glob[i + 2] === "/";
+      out += wholeFolder ? "(?:.*/)?" : ".*";
+      i += wholeFolder ? 3 : 2;
+    } else if (glob[i] === "*") {
+      out += "[^/]*";
+      i += 1;
+    } else {
+      out += escapeRe(glob[i]);
+      i += 1;
+    }
+  }
+  return out;
+}
+function regexProblem(source) {
+  if (source.length > MAX_PATTERN) return `a regex is at most ${MAX_PATTERN} characters`;
+  if (/\((?:[^()\\]|\\.)*[+*}](?:[^()\\]|\\.)*\)\s*[+*{]/.test(source)) return "a regex may not repeat a group that itself repeats, like (a+)+: it can run without end";
+  try {
+    new RegExp(source);
+  } catch (err) {
+    return `the regex does not compile: ${err.message}`;
+  }
+  return null;
+}
+const compiled = /* @__PURE__ */ new Map();
+function wholly(kind, pattern, text) {
+  const key = `${kind}\0${pattern}`;
+  let re = compiled.get(key);
+  if (!re) {
+    re = new RegExp(`^(?:${kind === "glob" ? globSource(pattern) : pattern})$`);
+    if (compiled.size > 500) compiled.clear();
+    compiled.set(key, re);
+  }
+  return re.test(text);
+}
+function underPattern(kind, pattern, text) {
+  if (wholly(kind, pattern, text)) return true;
+  for (let i = text.indexOf("/"); i >= 0; i = text.indexOf("/", i + 1)) {
+    if (wholly(kind, pattern, text.slice(0, i))) return true;
+  }
+  return false;
+}
+function matcherOf(match, value) {
+  if (match === void 0 || match === null || match === "exact") return value.includes("*") ? "glob" : null;
+  return MATCH_KINDS.includes(match) ? match : "bad";
+}
+function thresholdProblem(t) {
+  return typeof t === "number" && t > 0.5 && t < 1 ? null : "threshold is how alike, above 0.5 and below 1, like 0.85";
+}
+function splitTarget(v) {
+  if (v && typeof v === "object" && !Array.isArray(v) && "value" in v) {
+    const o = v;
+    return { value: o.value, match: o.match, ...o.threshold !== void 0 ? { threshold: o.threshold } : {} };
+  }
+  return { value: v, match: void 0 };
+}
+const lineCompiled = /* @__PURE__ */ new Map();
+const MAX_LINE = 2e3;
+function lineMatches(kind, pattern, line, ignoreCase = false, threshold = import_fuzzy.DEFAULT_THRESHOLD) {
+  const text = line.length > MAX_LINE ? line.slice(0, MAX_LINE) : line;
+  if (kind === null) return ignoreCase ? text.toLowerCase().includes(pattern.toLowerCase()) : text.includes(pattern);
+  if (kind === "fuzzy") return (0, import_fuzzy.wordsOf)(text).some((w) => w.toLowerCase() !== pattern.toLowerCase() && (0, import_fuzzy.similarity)(w, pattern) >= threshold);
+  const key = `${kind}\0${ignoreCase ? "i" : ""}\0${pattern}`;
+  let re = lineCompiled.get(key);
+  if (!re) {
+    re = new RegExp(kind === "glob" ? pattern.split("*").map(escapeRe).join(".*") : pattern, ignoreCase ? "i" : "");
+    if (lineCompiled.size > 500) lineCompiled.clear();
+    lineCompiled.set(key, re);
+  }
+  return re.test(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MATCH_KINDS,
+  globSource,
+  lineMatches,
+  matcherOf,
+  regexProblem,
+  splitTarget,
+  thresholdProblem,
+  underPattern,
+  wholly
+});

package/src/shared/lib/merge-order.js

@@ -0,0 +1,65 @@
+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 merge_order_exports = {};
+__export(merge_order_exports, {
+  mergeOrder: () => mergeOrder
+});
+module.exports = __toCommonJS(merge_order_exports);
+const list = (xs) => xs.length <= 1 ? xs.join("") : `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}`;
+function mergeOrder(lines, deps) {
+  const byKey = new Map(lines.map((l) => [l.key, l]));
+  const real = deps.filter((d) => d.first !== d.then && byKey.has(d.first) && byKey.has(d.then));
+  const incoming = new Map(lines.map((l) => [l.key, /* @__PURE__ */ new Set()]));
+  for (const d of real) incoming.get(d.then).add(d.first);
+  const rank = (a, b) => Number(b.ready) - Number(a.ready) || a.name.localeCompare(b.name);
+  const placed = [];
+  const done = /* @__PURE__ */ new Set();
+  const cycle = [];
+  while (done.size < lines.length) {
+    const waiting = lines.filter((l) => !done.has(l.key)).sort(rank);
+    const free = waiting.filter((l) => [...incoming.get(l.key)].every((k) => done.has(k)));
+    const next = free[0] ?? waiting[0];
+    if (!free.length) cycle.push(next.key);
+    placed.push(next.key);
+    done.add(next.key);
+  }
+  const name = (k) => byKey.get(k).name;
+  const reasonFor = (key) => {
+    if (cycle.includes(key)) {
+      const partners = [...new Set(real.filter((d) => d.then === key && placed.indexOf(d.first) > placed.indexOf(key)).map((d) => name(d.first)))];
+      return `${name(key)} and ${list(partners)} each change something the other imports: merge ${name(key)} first, then update ${list(partners)} to it.`;
+    }
+    const after = real.filter((d) => d.then === key);
+    const before = real.filter((d) => d.first === key);
+    const parts = [];
+    if (after.length) {
+      parts.push(`After ${list([...new Set(after.map((d) => name(d.first)))])}: it changes ${list([...new Set(after.map((d) => d.symbol))])}, which this imports, so update to it first.`);
+    }
+    if (before.length) {
+      const who = [...new Set(before.map((d) => name(d.then)))];
+      parts.push(`Before ${list(who)}: ${who.length > 1 ? "they import" : "it imports"} ${list([...new Set(before.map((d) => d.symbol))])}, which this changes, and will need updating after.`);
+    }
+    if (parts.length === 0) return "No other line of work depends on this one.";
+    return parts.join(" ");
+  };
+  return placed.map((key, i) => ({ key, position: i + 1, reason: reasonFor(key) }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeOrder
+});

package/src/shared/lib/open-findings.js

@@ -0,0 +1,68 @@
+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 open_findings_exports = {};
+__export(open_findings_exports, {
+  blockingRuns: () => blockingRuns,
+  findingHover: () => findingHover,
+  latestRun: () => latestRun,
+  openFindings: () => openFindings,
+  placeFindings: () => placeFindings
+});
+module.exports = __toCommonJS(open_findings_exports);
+var import_import_line = require("./import-line");
+function latestRun(runs) {
+  let best = null;
+  for (const r of runs) if (!best || r.at > best.at) best = r;
+  return best;
+}
+function openFindings(runs, files) {
+  const run = latestRun(runs);
+  if (!run) return null;
+  const here = new Set(files);
+  return { run, findings: run.findings.filter((f) => here.has(f.path)) };
+}
+function placeFindings(findings, runId, text, startLine = 1) {
+  const out = [];
+  for (const f of findings) {
+    const at = (0, import_import_line.importLine)(text, f.imports);
+    if (at !== null) out.push({ ...f, line: at + startLine - 1, runId });
+  }
+  return out;
+}
+function findingHover(f) {
+  return `${f.failing ? "\u2717" : "\u26A0"} ${f.rule} (${f.strength}): ${f.words}${f.fix ? ` \u2192 ${f.fix}` : ""}`;
+}
+function blockingRuns(runs, max = 5) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const r of runs) {
+    const key = `${r.who}
+${r.ranIn}
+${r.scope ?? ""}`;
+    const had = latest.get(key);
+    if (!had || r.at > had.at) latest.set(key, r);
+  }
+  return [...latest.values()].filter((r) => !r.outcome.ok).sort((a, b) => b.at - a.at).slice(0, max);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blockingRuns,
+  findingHover,
+  latestRun,
+  openFindings,
+  placeFindings
+});

package/src/shared/lib/other-work.js

@@ -0,0 +1,108 @@
+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 other_work_exports = {};
+__export(other_work_exports, {
+  otherWorkInFlight: () => otherWorkInFlight,
+  otherWorkMarkdown: () => otherWorkMarkdown
+});
+module.exports = __toCommonJS(other_work_exports);
+var import_signal_words = require("./signal-words");
+const RANK = { open: 0, acknowledged: 1, intended: 2, dismissed: 3, fixed: 4 };
+const SEVERITY = { high: 0, medium: 1, low: 2 };
+const MAX_FIXED = 5;
+function who(by) {
+  if (!by) return "someone";
+  if (by.actorType === "unverified") return "someone through the local API, not verified as the person";
+  return by.channel === "phone" ? "the person, from their phone" : "the person";
+}
+function outcomeOf(s) {
+  if (s.state === "resolved") return "fixed";
+  return s.state;
+}
+function outcomeWords(s, outcome) {
+  switch (outcome) {
+    case "fixed":
+      return "Fixed: what caused it is gone.";
+    case "acknowledged":
+      return `Acknowledged by ${who(s.stateBy)}.`;
+    case "intended":
+      return `Marked intended by ${who(s.stateBy)}: a decision, not an accident.`;
+    case "dismissed":
+      return `Set aside by ${who(s.stateBy)}.`;
+    default:
+      return s.reopened ? `Open again: it changed since it was ${s.reopened.from === "intended" ? "marked intended" : "acknowledged"}.` : "Open: nobody has answered it yet.";
+  }
+}
+function mergeWords(s, target, label, same) {
+  if (s.kind !== "contract" || !s.subject.by) return void 0;
+  const symbol = s.subject.symbol ?? "an export";
+  const others = (0, import_signal_words.sideRootsOf)(s).filter((r) => !same(r, target)).map(label);
+  if (same(s.subject.by, target)) {
+    const verb = s.subject.change === "removed" ? "removes" : "changes";
+    const who2 = others.join(" and ") || "another line of work";
+    return `Merging this ${verb} ${symbol}; ${who2} ${others.length > 1 ? "import" : "imports"} it and will need updating.`;
+  }
+  return `This imports ${symbol}, which ${label(s.subject.by)} ${s.subject.change === "removed" ? "removes" : "changes"}: merge after it and update, or ask it to keep the old form.`;
+}
+function otherWorkInFlight(target, signals, label, same = (a, b) => a === b) {
+  const mine = signals.filter((s) => s.workstreams.some((w) => same(w, target.root)));
+  const entries = mine.map((s) => {
+    const outcome = outcomeOf(s);
+    const merge = mergeWords(s, target.root, label, same);
+    return {
+      signalId: s.id,
+      kind: s.kind,
+      severity: s.severity,
+      heading: (0, import_signal_words.kindWords)(s),
+      sides: (0, import_signal_words.sideWords)(s, label).map(({ name, words }) => ({ name, words })),
+      outcome,
+      outcomeWords: outcomeWords(s, outcome),
+      notes: (s.told ?? []).filter((t) => t.note).map((t) => `${t.agentType}: ${t.note}`),
+      ...merge ? { merge } : {}
+    };
+  });
+  entries.sort((a, b) => RANK[a.outcome] - RANK[b.outcome] || SEVERITY[a.severity] - SEVERITY[b.severity]);
+  const fixed = entries.filter((e) => e.outcome === "fixed");
+  const kept = [...entries.filter((e) => e.outcome !== "fixed"), ...fixed.slice(0, MAX_FIXED)];
+  return {
+    workstream: target,
+    entries: kept,
+    openHigh: entries.filter((e) => e.outcome === "open" && e.severity === "high").length
+  };
+}
+function otherWorkMarkdown(o) {
+  const lines = ["### Other work in flight", ""];
+  if (o.entries.length === 0) {
+    lines.push(`No other line of work overlaps with \`${o.workstream.name}\`.`, "");
+    return lines.join("\n");
+  }
+  lines.push(`How \`${o.workstream.name}\` meets the other lines of work, and what happened to each overlap.`, "");
+  for (const e of o.entries) {
+    lines.push(`- **${e.severity.toUpperCase()} \xB7 ${e.heading}.** ${e.sides.map((s) => s.words).join(" ")}`);
+    if (e.merge) lines.push(`  ${e.merge}`);
+    lines.push(`  ${e.outcomeWords}`);
+    for (const n of e.notes) lines.push(`  > ${n}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  otherWorkInFlight,
+  otherWorkMarkdown
+});

package/src/shared/lib/package-entry.js

@@ -0,0 +1,142 @@
+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 package_entry_exports = {};
+__export(package_entry_exports, {
+  PACKAGE_ECOSYSTEMS: () => PACKAGE_ECOSYSTEMS,
+  ecosystemOfPath: () => ecosystemOfPath,
+  isPackageEntry: () => isPackageEntry,
+  packageApplies: () => packageApplies,
+  packageEntry: () => packageEntry,
+  packageMatches: () => packageMatches,
+  packageProblem: () => packageProblem
+});
+module.exports = __toCommonJS(package_entry_exports);
+const PACKAGE_ECOSYSTEMS = ["npm", "pypi", "go", "cargo", "maven", "nuget", "gem", "composer", "swift"];
+const ECOSYSTEM_RE = new RegExp(`^(${PACKAGE_ECOSYSTEMS.join("|")}):(.+)$`);
+function isPackageEntry(s) {
+  return ECOSYSTEM_RE.test(s);
+}
+function packageProblem(s) {
+  if (typeof s !== "string" || !ECOSYSTEM_RE.test(s.trim())) {
+    return `package must be an ecosystem and a name, like npm:stripe (one of ${PACKAGE_ECOSYSTEMS.join(", ")})`;
+  }
+  return null;
+}
+const ecosystemOf = {
+  typescript: "npm",
+  javascript: "npm",
+  tsx: "npm",
+  jsx: "npm",
+  python: "pypi",
+  go: "go",
+  rust: "cargo",
+  ruby: "gem",
+  java: "maven",
+  kotlin: "maven",
+  csharp: "nuget",
+  php: "composer",
+  swift: "swift"
+};
+const ecosystemOfExt = {
+  ts: "npm",
+  tsx: "npm",
+  mts: "npm",
+  cts: "npm",
+  js: "npm",
+  jsx: "npm",
+  mjs: "npm",
+  cjs: "npm",
+  py: "pypi",
+  go: "go",
+  rs: "cargo",
+  rb: "gem",
+  java: "maven",
+  kt: "maven",
+  kts: "maven",
+  cs: "nuget",
+  php: "composer",
+  swift: "swift"
+};
+function ecosystemOfPath(file) {
+  const dot = file.lastIndexOf(".");
+  return dot > file.lastIndexOf("/") ? ecosystemOfExt[file.slice(dot + 1).toLowerCase()] ?? null : null;
+}
+function packageApplies(rulePackage, file) {
+  const eco = ecosystemOfPath(file);
+  return eco !== null && rulePackage.startsWith(`${eco}:`);
+}
+const RUST_LOCAL = /* @__PURE__ */ new Set(["crate", "self", "super", "std", "core", "alloc"]);
+const GO_MODULE_SEGMENTS = [
+  [/^golang\.org\/x\//, 3],
+  [/^gopkg\.in\//, 2],
+  [/^(github\.com|gitlab\.com|bitbucket\.org)\//, 3]
+];
+function packageEntry(language, source, isRelative = false) {
+  const eco = ecosystemOf[language];
+  const s = source.trim();
+  if (!eco || !s || isRelative) return null;
+  switch (eco) {
+    case "npm": {
+      if (s.startsWith(".") || s.startsWith("/") || s.startsWith("node:") || s.startsWith("#")) return null;
+      const parts = s.split("/");
+      const name = s.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+      return name ? `npm:${name}` : null;
+    }
+    case "pypi": {
+      if (s.startsWith(".")) return null;
+      return `pypi:${s.split(".")[0]}`;
+    }
+    case "go": {
+      const first = s.split("/")[0];
+      if (!first.includes(".")) return null;
+      const keep = GO_MODULE_SEGMENTS.find(([re]) => re.test(s))?.[1] ?? 3;
+      return `go:${s.split("/").slice(0, keep).join("/")}`;
+    }
+    case "cargo": {
+      const head = s.replace(/^::/, "").split("::")[0];
+      return RUST_LOCAL.has(head) ? null : `cargo:${head}`;
+    }
+    case "gem":
+      return s.startsWith(".") ? null : `gem:${s.split("/")[0]}`;
+    case "maven":
+    case "nuget":
+    case "swift":
+      return `${eco}:${s}`;
+    case "composer":
+      return `composer:${s.replace(/^\\/, "")}`;
+  }
+  return null;
+}
+const SEPARATORS = ["/", ".", "\\", "::"];
+function packageMatches(rulePackage, entry) {
+  if (rulePackage === entry) return true;
+  const r = ECOSYSTEM_RE.exec(rulePackage);
+  const e = ECOSYSTEM_RE.exec(entry);
+  if (!r || !e || r[1] !== e[1]) return false;
+  return SEPARATORS.some((sep) => e[2].startsWith(r[2] + sep));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PACKAGE_ECOSYSTEMS,
+  ecosystemOfPath,
+  isPackageEntry,
+  packageApplies,
+  packageEntry,
+  packageMatches,
+  packageProblem
+});

package/src/shared/lib/plan-vocab.js

@@ -0,0 +1,40 @@
+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_vocab_exports = {};
+__export(plan_vocab_exports, {
+  PLAN_STATUSES: () => PLAN_STATUSES,
+  TASK_STATUSES: () => TASK_STATUSES,
+  isPlanStatus: () => isPlanStatus,
+  isTaskStatus: () => isTaskStatus
+});
+module.exports = __toCommonJS(plan_vocab_exports);
+const PLAN_STATUSES = ["draft", "review", "approved", "in_progress", "completed", "archived"];
+const TASK_STATUSES = ["pending", "assigned", "in_progress", "done", "blocked", "skipped"];
+function isPlanStatus(v) {
+  return typeof v === "string" && PLAN_STATUSES.includes(v);
+}
+function isTaskStatus(v) {
+  return typeof v === "string" && TASK_STATUSES.includes(v);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PLAN_STATUSES,
+  TASK_STATUSES,
+  isPlanStatus,
+  isTaskStatus
+});

package/src/shared/lib/pptx-xml.js

@@ -0,0 +1,86 @@
+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 pptx_xml_exports = {};
+__export(pptx_xml_exports, {
+  slideOrder: () => slideOrder,
+  slideText: () => slideText,
+  thumbnailPart: () => thumbnailPart
+});
+module.exports = __toCommonJS(pptx_xml_exports);
+var import_xlsx_xml = require("./xlsx-xml");
+function slideOrder(presentationXml, relsXml, partNames) {
+  const present = new Set(partNames);
+  const targets = /* @__PURE__ */ new Map();
+  for (const m of (relsXml ?? "").matchAll(/<Relationship\b[^>]*>/g)) {
+    const id = m[0].match(/\bId="([^"]+)"/)?.[1];
+    const target = m[0].match(/\bTarget="([^"]+)"/)?.[1];
+    if (id && target) targets.set(id, resolvePart("ppt/", (0, import_xlsx_xml.decodeXml)(target)));
+  }
+  const ordered = [];
+  const list = presentationXml?.match(/<p:sldIdLst\b[^>]*>([\s\S]*?)<\/p:sldIdLst>/)?.[1] ?? "";
+  for (const m of list.matchAll(/<p:sldId\b[^>]*\br:id="([^"]+)"/g)) {
+    const part = targets.get(m[1]);
+    if (part && present.has(part) && !ordered.includes(part)) ordered.push(part);
+  }
+  if (ordered.length > 0) return ordered;
+  return partNames.filter((p) => /^ppt\/slides\/slide\d+\.xml$/.test(p)).sort((a, b) => Number(a.match(/(\d+)\.xml$/)[1]) - Number(b.match(/(\d+)\.xml$/)[1]));
+}
+function resolvePart(base, target) {
+  if (target.startsWith("/")) return target.slice(1);
+  const parts = base.split("/").filter(Boolean);
+  for (const seg of target.split("/")) {
+    if (seg === "..") parts.pop();
+    else if (seg !== "." && seg !== "") parts.push(seg);
+  }
+  return parts.join("/");
+}
+function paragraphText(p) {
+  const runs = [];
+  for (const m of p.matchAll(/<a:t>([^<]*)<\/a:t>|<a:t\s[^>]*>([^<]*)<\/a:t>|<a:br\b[^>]*\/>/g)) {
+    runs.push(m[0].startsWith("<a:br") ? " " : (0, import_xlsx_xml.decodeXml)(m[1] ?? m[2] ?? ""));
+  }
+  return runs.join("").replace(/\s+/g, " ").trim();
+}
+function slideText(n, slideXml) {
+  let title = null;
+  const paragraphs = [];
+  for (const m of slideXml.matchAll(/<p:(sp|graphicFrame)\b[\s\S]*?<\/p:\1>/g)) {
+    const shape = m[0];
+    const isTitle = /<p:ph\b[^>]*\btype="(title|ctrTitle)"/.test(shape);
+    const paragraphsOf = (xml) => Array.from(xml.matchAll(/<a:p\/>|<a:p(?:\s[^>]*[^/])?>[\s\S]*?<\/a:p>/g)).map((p) => paragraphText(p[0])).filter(Boolean);
+    const rows = Array.from(shape.matchAll(/<a:tr(?:\s[^>]*)?>[\s\S]*?<\/a:tr>/g));
+    const texts = rows.length > 0 ? rows.map((r) => Array.from(r[0].matchAll(/<a:tc(?:\s[^>]*)?\/>|<a:tc(?:\s[^>]*[^/])?>[\s\S]*?<\/a:tc>/g)).map((c) => paragraphsOf(c[0]).join(" ")).join(" \xB7 ")).filter((line) => line.replace(/[\s·]/g, "") !== "") : paragraphsOf(shape);
+    if (isTitle && title === null && texts.length > 0) title = texts.join(" ");
+    else paragraphs.push(...texts);
+  }
+  return { n, title, paragraphs };
+}
+function thumbnailPart(packageRelsXml) {
+  for (const m of (packageRelsXml ?? "").matchAll(/<Relationship\b[^>]*>/g)) {
+    if (!/\bType="[^"]*\/metadata\/thumbnail"/.test(m[0])) continue;
+    const target = m[0].match(/\bTarget="([^"]+)"/)?.[1];
+    if (target) return resolvePart("", (0, import_xlsx_xml.decodeXml)(target));
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  slideOrder,
+  slideText,
+  thumbnailPart
+});