codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/plan-status.js

@@ -0,0 +1,113 @@
+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_status_exports = {};
+__export(plan_status_exports, {
+  planStatus: () => planStatus,
+  planStatusFresh: () => planStatusFresh
+});
+module.exports = __toCommonJS(plan_status_exports);
+var import_plan_service = require("./plan-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_plan_event_service = require("./plan-event-service");
+var import_criteria_service = require("./criteria-service");
+var import_external_refs_service = require("./external-refs-service");
+var import_external_intake_service = require("./external-intake-service");
+var import_item_git_state = require("./item-git-state");
+var import_heads = require("./task-records/heads");
+var import_item_status = require("../../shared/lib/item-status");
+function statusRecords(planUid) {
+  const out = /* @__PURE__ */ new Map();
+  const checks = (0, import_heads.allHeadChecks)();
+  for (const e of (0, import_plan_event_service.listPlanEvents)(planUid, { eventTypes: ["status_changed"], limit: 1e4 })) {
+    if (!e.itemUid || out.has(e.itemUid)) continue;
+    const check = e.authorType === "record" ? checks.get(e.itemUid) ?? null : null;
+    const by = check ? check.verified && check.author ? check.author : check.claimed : e.author;
+    out.set(e.itemUid, { by, byType: e.authorType, at: e.createdAt, ...check ? { check } : {} });
+  }
+  return out;
+}
+function criteriaOf(itemUid) {
+  let list;
+  try {
+    list = (0, import_criteria_service.listCriteria)(itemUid);
+  } catch {
+    return null;
+  }
+  if (list.length === 0) return null;
+  const met = list.filter((c) => c.state === "met");
+  const awaiting = list.filter((c) => c.state === "submitted").length;
+  let signedOffBy = null;
+  if (met.length === list.length) {
+    const last = met.map((c) => c.latestSignoff).filter((s) => !!s && s.decision === "approved").sort((a, b) => b.createdAt - a.createdAt)[0];
+    signedOffBy = last?.actor ?? null;
+  }
+  return { met: met.length, total: list.length, awaiting, signedOffBy };
+}
+function ticketsOf(planUid) {
+  const keys = [];
+  try {
+    keys.push(...(0, import_external_intake_service.getPlanExternalRefs)(planUid).map((r) => r.externalKey).filter((k) => !!k));
+  } catch {
+  }
+  try {
+    keys.push(...(0, import_external_refs_service.getExternalRefsByPlan)(planUid).map((r) => r.externalKey).filter((k) => !!k));
+  } catch {
+  }
+  return [...new Set(keys)];
+}
+function build(planUid, git) {
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  if (!plan) return null;
+  const records = statusRecords(planUid);
+  const items = (0, import_plan_item_service.listAllItems)(planUid);
+  const splits = (0, import_heads.allSplits)();
+  const facts = items.map((i) => ({
+    uid: i.uid,
+    title: i.title,
+    kind: i.kind,
+    parentUid: i.parentUid,
+    status: i.status ?? null,
+    assignee: i.assignee ?? null,
+    progressPercent: i.progressPercent ?? null,
+    blockedReason: i.blockedReason ?? null,
+    criteria: i.kind === "action" ? criteriaOf(i.uid) : null,
+    recorded: records.get(i.uid) ?? null,
+    atOnce: splits.get(i.uid) ?? null
+  }));
+  const byItem = new Map((git?.items ?? []).map((s) => [s.itemUid, s]));
+  const statuses = (0, import_item_status.itemStatuses)(facts, byItem);
+  const newest = Math.max(0, ...[...records.values()].map((r) => r.at), ...items.map((i) => i.updatedAt ?? 0));
+  return {
+    planUid,
+    title: plan.title,
+    base: git?.base ?? null,
+    items: statuses,
+    ...(0, import_item_status.planStatusView)(statuses, ticketsOf(planUid), newest || null)
+  };
+}
+function planStatus(planUid) {
+  return build(planUid, (0, import_item_git_state.planGitStates)(planUid));
+}
+async function planStatusFresh(planUid) {
+  return build(planUid, await (0, import_item_git_state.planGitStatesFresh)(planUid));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  planStatus,
+  planStatusFresh
+});

package/src/backend/services/plan-template-publish-service.js

@@ -0,0 +1,217 @@
+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_template_publish_service_exports = {};
+__export(plan_template_publish_service_exports, {
+  publishPlanAsTemplate: () => publishPlanAsTemplate
+});
+module.exports = __toCommonJS(plan_template_publish_service_exports);
+var import_criteria_service = require("./criteria-service");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var planService = __toESM(require("./plan-service"));
+var planPhasesService = __toESM(require("./plan-phases-service"));
+var planDocsService = __toESM(require("./plan-documents-service"));
+var planItemService = __toESM(require("./plan-item-service"));
+function publishPlanAsTemplate(input) {
+  if (!input.templateId || !/^[a-z0-9][a-z0-9-]*$/.test(input.templateId)) {
+    throw new Error(`Invalid templateId: ${input.templateId} (lowercase, alphanumeric + hyphens, must start with a letter or digit)`);
+  }
+  const plan = planService.getPlan(input.planUid);
+  if (!plan) throw new Error(`Plan ${input.planUid} not found`);
+  const v2Items = planItemService.listAllItems(input.planUid);
+  if (v2Items.length > 0) {
+    return publishV2Template(input, plan, v2Items);
+  }
+  return publishV1Template(input, plan);
+}
+function publishV2Template(input, plan, allItems) {
+  const templateDir = import_node_path.default.join(input.projectRoot, ".codetrellis", "templates", input.templateId);
+  ensureDir(templateDir);
+  ensureDir(import_node_path.default.join(templateDir, "docs"));
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const item of allItems) {
+    const list = childrenOf.get(item.parentUid) ?? [];
+    list.push(item);
+    childrenOf.set(item.parentUid, list);
+  }
+  for (const list of childrenOf.values()) {
+    list.sort((a, b) => a.sortOrder - b.sortOrder || a.createdAt - b.createdAt);
+  }
+  const files = [];
+  function serializeItemForTemplate(item) {
+    const obj = {
+      kind: item.kind,
+      title: item.title
+    };
+    if (item.body && item.body.length > 500) {
+      const bodySlug = slugify(item.title) || item.kind;
+      const bodyPath = `docs/${bodySlug}.md`;
+      writeFileAtomic(import_node_path.default.join(templateDir, bodyPath), item.body);
+      files.push(import_node_path.default.join(templateDir, bodyPath));
+      obj.bodyPath = bodyPath;
+    } else if (item.body) {
+      obj.body = item.body;
+    }
+    if (item.template) obj.template = item.template;
+    if (item.scopePath) obj.scopePath = item.scopePath;
+    if (item.fileSpecs?.length) obj.fileSpecs = item.fileSpecs;
+    if (item.symbolSpecs?.length) obj.symbolSpecs = item.symbolSpecs;
+    if (item.dependencies?.length) obj.dependencies = item.dependencies;
+    if (item.skills?.length) {
+      obj.skills = item.skills;
+      if (item.skillsMode && item.skillsMode !== "inherit") obj.skillsMode = item.skillsMode;
+    }
+    if (item.claimPolicy) {
+      obj.claimPolicy = item.claimPolicy;
+      if (item.claimPolicyMode && item.claimPolicyMode !== "inherit") obj.claimPolicyMode = item.claimPolicyMode;
+    }
+    if (item.executionConfig) {
+      obj.executionConfig = item.executionConfig;
+      if (item.executionConfigMode && item.executionConfigMode !== "inherit") obj.executionConfigMode = item.executionConfigMode;
+    }
+    if (item.constraints) {
+      obj.constraints = item.constraints;
+      if (item.constraintsMode && item.constraintsMode !== "inherit") obj.constraintsMode = item.constraintsMode;
+    }
+    if (item.requiresApproval) obj.requiresApproval = true;
+    const criteria = (0, import_criteria_service.criteriaForTemplate)(item.uid);
+    if (criteria.length > 0) obj.criteria = criteria;
+    const children = childrenOf.get(item.uid) ?? [];
+    if (children.length > 0) {
+      obj.children = children.map(serializeItemForTemplate);
+    }
+    return obj;
+  }
+  const roots = childrenOf.get(null) ?? [];
+  const yamlBody = {
+    id: input.templateId,
+    version: 2,
+    label: input.label ?? plan.title,
+    shortDescription: input.shortDescription ?? plan.description.split("\n")[0].slice(0, 140),
+    longDescription: input.longDescription ?? plan.description,
+    defaultTitle: input.defaultTitle ?? plan.title,
+    defaultPlanDescription: input.defaultPlanDescription ?? plan.description,
+    placeholders: input.placeholders?.length ? input.placeholders : void 0,
+    items: roots.map(serializeItemForTemplate)
+  };
+  const yamlPath = import_node_path.default.join(templateDir, "template.yaml");
+  writeFileAtomic(yamlPath, (0, import_yaml.stringify)(yamlBody));
+  files.unshift(yamlPath);
+  return { templateDir, files };
+}
+function publishV1Template(input, plan) {
+  const phases = planPhasesService.listPhases(input.planUid);
+  const tasks = plan.tasks;
+  const docs = planDocsService.listPlanDocuments(input.planUid);
+  const templateDir = import_node_path.default.join(input.projectRoot, ".codetrellis", "templates", input.templateId);
+  ensureDir(templateDir);
+  ensureDir(import_node_path.default.join(templateDir, "docs"));
+  const tasksByPhase = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    if (!t.phaseUid) continue;
+    const bucket = tasksByPhase.get(t.phaseUid) ?? [];
+    bucket.push(t);
+    tasksByPhase.set(t.phaseUid, bucket);
+  }
+  const docEntries = [];
+  const docKeyByUid = /* @__PURE__ */ new Map();
+  for (const d of docs) {
+    const key = slugify(d.title) || d.docType || d.uid.slice(0, 6);
+    docKeyByUid.set(d.uid, key);
+    const orderPrefix = d.orderHint ? `${d.orderHint}-` : "";
+    const fname = `${orderPrefix}${slugify(d.title) || d.docType}.md`;
+    const bodyPath = import_node_path.default.join("docs", fname);
+    writeFileAtomic(import_node_path.default.join(templateDir, bodyPath), d.body || "");
+    docEntries.push({
+      key,
+      docType: d.docType,
+      title: d.title,
+      orderHint: d.orderHint,
+      parentKey: null,
+      bodyPath: bodyPath.replace(/\\/g, "/")
+    });
+  }
+  for (let i = 0; i < docEntries.length; i++) {
+    const d = docs[i];
+    if (d.parentDocUid) {
+      docEntries[i].parentKey = docKeyByUid.get(d.parentDocUid) ?? null;
+    }
+  }
+  const yamlBody = {
+    id: input.templateId,
+    label: input.label ?? plan.title,
+    shortDescription: input.shortDescription ?? plan.description.split("\n")[0].slice(0, 140),
+    longDescription: input.longDescription ?? plan.description,
+    defaultTitle: input.defaultTitle ?? plan.title,
+    defaultPlanDescription: input.defaultPlanDescription ?? plan.description,
+    placeholders: input.placeholders?.length ? input.placeholders : void 0,
+    phases: phases.map((p) => {
+      const phaseTasks = (tasksByPhase.get(p.uid) ?? []).map((t) => ({
+        description: t.description,
+        affectedFiles: t.affectedFiles ?? []
+      }));
+      return {
+        phaseNumber: p.phaseNumber,
+        title: p.title,
+        scope: p.scope || void 0,
+        prerequisites: p.prerequisites || void 0,
+        acceptanceCriteria: p.acceptanceCriteria || void 0,
+        tasks: phaseTasks.length ? phaseTasks : void 0
+      };
+    }),
+    docs: docEntries.map((d) => ({
+      key: d.key,
+      docType: d.docType,
+      title: d.title,
+      orderHint: d.orderHint || void 0,
+      parentKey: d.parentKey || void 0,
+      bodyPath: d.bodyPath
+    }))
+  };
+  const yamlPath = import_node_path.default.join(templateDir, "template.yaml");
+  writeFileAtomic(yamlPath, (0, import_yaml.stringify)(yamlBody));
+  const files = [yamlPath, ...docEntries.map((d) => import_node_path.default.join(templateDir, d.bodyPath))];
+  return { templateDir, files };
+}
+function ensureDir(dir) {
+  if (!import_node_fs.default.existsSync(dir)) import_node_fs.default.mkdirSync(dir, { recursive: true });
+}
+function writeFileAtomic(filePath, content) {
+  ensureDir(import_node_path.default.dirname(filePath));
+  const tmp = `${filePath}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, content, "utf-8");
+  import_node_fs.default.renameSync(tmp, filePath);
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  publishPlanAsTemplate
+});

package/src/backend/services/plan-templates-service.js

@@ -0,0 +1,242 @@
+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_templates_service_exports = {};
+__export(plan_templates_service_exports, {
+  applyTemplate: () => applyTemplate,
+  applyTemplateToPlan: () => applyTemplateToPlan
+});
+module.exports = __toCommonJS(plan_templates_service_exports);
+var import_plan_service = require("./plan-service");
+var import_plan_phases_service = require("./plan-phases-service");
+var import_plan_documents_service = require("./plan-documents-service");
+var import_plan_service2 = require("./plan-service");
+var import_plan_service3 = require("./plan-service");
+var planItemService = __toESM(require("./plan-item-service"));
+var import_plan_migrate_service = require("./plan-migrate-service");
+var import_plan_templates = require("./plan-templates");
+var import_criteria_service = require("./criteria-service");
+function applyTemplate(input) {
+  const template = resolveTemplate(input.templateId, input.projectPath, input.placeholderValues);
+  const author = input.author ?? "human";
+  const authorType = input.authorType ?? "human";
+  const title = (input.title ?? template.defaultTitle).replace("{name}", input.title ?? "").replace(/[:\-–—]\s*$/, "").trim();
+  const description = input.description ?? template.defaultPlanDescription;
+  const templateAny = template;
+  if (Array.isArray(templateAny.items) && templateAny.items.length > 0) {
+    return applyV2Template(templateAny, title, description, author, authorType, input);
+  }
+  return applyV1Template(template, title, description, author, authorType, input);
+}
+function resolveTemplate(templateId, projectPath, placeholderValues) {
+  const rawTemplate = (0, import_plan_templates.getTemplate)(templateId, projectPath);
+  if (!rawTemplate) throw new Error(`Unknown plan template: ${templateId}`);
+  const values = {};
+  for (const p of rawTemplate.placeholders ?? []) {
+    if (placeholderValues && placeholderValues[p.key] !== void 0) {
+      values[p.key] = placeholderValues[p.key];
+    } else if (p.default !== void 0) {
+      values[p.key] = p.default;
+    }
+  }
+  return (0, import_plan_templates.substitutePlaceholders)(rawTemplate, values);
+}
+function createTemplateItems(planUid, items, opts) {
+  const created = [];
+  const walk = (templateItems, parentUid, sortBase) => {
+    for (let i = 0; i < templateItems.length; i++) {
+      const t = templateItems[i];
+      const kind = t.kind === "object" ? "object" : "action";
+      const item = planItemService.createItem({
+        planUid,
+        parentUid,
+        sortOrder: sortBase + i,
+        kind,
+        title: String(t.title ?? ""),
+        // A disk template's `bodyPath` was read, confined, by the loader.
+        body: t.body ?? "",
+        template: t.template ?? null,
+        // Action defaults — template items start as pending
+        status: kind === "action" ? "pending" : void 0,
+        scopePath: t.scopePath ?? null,
+        fileSpecs: Array.isArray(t.fileSpecs) ? t.fileSpecs : [],
+        symbolSpecs: Array.isArray(t.symbolSpecs) ? t.symbolSpecs : [],
+        dependencies: Array.isArray(t.dependencies) ? t.dependencies : [],
+        // Cascading properties from template
+        skills: Array.isArray(t.skills) ? t.skills : [],
+        skillsMode: t.skillsMode ?? "inherit",
+        claimPolicy: t.claimPolicy ?? null,
+        claimPolicyMode: t.claimPolicyMode ?? "inherit",
+        executionConfig: t.executionConfig ?? null,
+        executionConfigMode: t.executionConfigMode ?? "inherit",
+        constraints: t.constraints ?? null,
+        constraintsMode: t.constraintsMode ?? "inherit",
+        requiresApproval: t.requiresApproval === true,
+        author: opts.author,
+        authorType: opts.authorType
+      });
+      created.push(item);
+      (0, import_criteria_service.seedTemplateCriteria)(item.uid, t.criteria, opts.templateId);
+      if (Array.isArray(t.children) && t.children.length > 0) walk(t.children, item.uid, 0);
+    }
+  };
+  walk(items, null, opts.sortStart ?? 0);
+  return created;
+}
+function applyTemplateToPlan(input) {
+  const plan = (0, import_plan_service.getPlan)(input.planUid);
+  if (!plan) throw new Error(`Plan ${input.planUid} not found`);
+  if (!plan.projectPath) throw new Error("This plan is not associated with a project");
+  if (planItemService.listAllItems(plan.uid).length > 0) {
+    throw new Error("This plan already has items \u2014 a template starts an empty plan");
+  }
+  const template = resolveTemplate(input.templateId, plan.projectPath, input.placeholderValues);
+  const author = input.author ?? "human";
+  const authorType = input.authorType ?? "human";
+  if (!plan.description?.trim() && template.defaultPlanDescription) {
+    (0, import_plan_service.updatePlan)(plan.uid, { description: template.defaultPlanDescription }, author, authorType);
+  }
+  const templateAny = template;
+  if (Array.isArray(templateAny.items) && templateAny.items.length > 0) {
+    return {
+      items: createTemplateItems(plan.uid, templateAny.items, { author, authorType, templateId: input.templateId }),
+      version: 2
+    };
+  }
+  if (template.phases.some((p) => (p.tasks ?? []).length > 0)) {
+    throw new Error('This template seeds tasks, so it starts a new plan \u2014 use it from "New plan"');
+  }
+  seedPhasesAndDocs(plan.uid, template, author, authorType);
+  (0, import_plan_migrate_service.migratePlan)(plan.uid, { dryRun: false, author, authorType });
+  return { items: planItemService.listAllItems(plan.uid), version: 1 };
+}
+function applyV2Template(template, title, description, author, authorType, input) {
+  const plan = (0, import_plan_service.createPlan)(
+    { title, description, tasks: [], uid: input.uid },
+    author,
+    authorType,
+    input.projectPath
+  );
+  const createdItems = createTemplateItems(plan.uid, template.items, {
+    author,
+    authorType,
+    templateId: input.templateId
+  });
+  return {
+    plan,
+    phases: [],
+    docs: [],
+    tasks: [],
+    items: createdItems,
+    version: 2
+  };
+}
+function applyV1Template(template, title, description, author, authorType, input) {
+  const seedTasks = [];
+  for (const phase of template.phases) {
+    for (const t of phase.tasks ?? []) {
+      seedTasks.push({
+        description: t.description,
+        affectedFiles: t.affectedFiles ?? [],
+        phaseRef: phase.phaseNumber
+      });
+    }
+  }
+  const plan = (0, import_plan_service.createPlan)(
+    {
+      title,
+      description,
+      tasks: seedTasks.map((t) => ({
+        description: t.description,
+        affectedFiles: t.affectedFiles
+      })),
+      uid: input.uid
+    },
+    author,
+    authorType,
+    input.projectPath
+  );
+  const { phases, docs, phaseByNumber } = seedPhasesAndDocs(plan.uid, template, author, authorType);
+  const dbTasks = (0, import_plan_service3.getTasksByPlan)(plan.uid);
+  for (let i = 0; i < seedTasks.length && i < dbTasks.length; i++) {
+    const seed = seedTasks[i];
+    const dbTask = dbTasks[i];
+    const phase = phaseByNumber.get(seed.phaseRef);
+    if (phase && dbTask) {
+      (0, import_plan_service2.updateTask)(dbTask.uid, { phaseUid: phase.uid });
+    }
+  }
+  (0, import_plan_migrate_service.migratePlan)(plan.uid, { dryRun: false, author, authorType });
+  return {
+    plan,
+    phases,
+    docs,
+    tasks: (0, import_plan_service3.getTasksByPlan)(plan.uid),
+    items: planItemService.listAllItems(plan.uid),
+    version: 1
+  };
+}
+function seedPhasesAndDocs(planUid, template, author, authorType) {
+  const phases = [];
+  const phaseByNumber = /* @__PURE__ */ new Map();
+  for (const p of template.phases) {
+    const created = (0, import_plan_phases_service.createPhase)({
+      planUid,
+      phaseNumber: p.phaseNumber,
+      title: p.title,
+      scope: p.scope,
+      prerequisites: p.prerequisites,
+      acceptanceCriteria: p.acceptanceCriteria,
+      status: p.status ?? "pending"
+    });
+    phases.push(created);
+    phaseByNumber.set(p.phaseNumber, created);
+  }
+  const docs = [];
+  const docByKey = /* @__PURE__ */ new Map();
+  for (const d of template.docs) {
+    const parent = d.parentKey ? docByKey.get(d.parentKey) ?? null : null;
+    const created = (0, import_plan_documents_service.createPlanDocument)({
+      planUid,
+      docType: d.docType,
+      title: d.title,
+      body: d.body,
+      author,
+      authorType,
+      orderHint: d.orderHint ?? null,
+      parentDocUid: parent?.uid ?? null
+    });
+    docs.push(created);
+    if (d.key) docByKey.set(d.key, created);
+  }
+  return { phases, docs, phaseByNumber };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyTemplate,
+  applyTemplateToPlan
+});