mdkg 0.3.5 → 0.3.6

package/dist/commands/graph.js

@@ -20,6 +20,7 @@ const qid_1 = require("../util/qid");
 const atomic_1 = require("../util/atomic");
 const zip_1 = require("../util/zip");
 const lock_1 = require("../util/lock");
+const date_1 = require("../util/date");
 function writeJson(value) {
     console.log(JSON.stringify(value, null, 2));
 }
@@ -176,6 +177,85 @@ function writeSelectedGoal(targetRoot, qid, id, ws) {
     (0, atomic_1.atomicWriteFile)(statePath, `${JSON.stringify(state, null, 2)}\n`);
     return rel(targetRoot, statePath);
 }
+function qidForRoot(id) {
+    return `root:${id}`;
+}
+function idFromRootQid(qid) {
+    const [workspace, id] = qid.split(":");
+    if (workspace !== "root" || !id) {
+        throw new errors_1.UsageError(`invalid root qid: ${qid}`);
+    }
+    return id;
+}
+function ensureStatusAllowed(config, status) {
+    const normalized = status.toLowerCase();
+    const allowed = new Set(config.work.status_enum.map((value) => value.toLowerCase()));
+    if (!allowed.has(normalized)) {
+        throw new errors_1.UsageError(`goal status ${normalized} is not allowed by work.status_enum`);
+    }
+    return normalized;
+}
+function isActiveGoalStatus(status, goalState) {
+    return status === "progress" && goalState === "active";
+}
+function isClosedGoalStatus(status, goalState) {
+    return status === "done" || status === "archived" || goalState === "achieved" || goalState === "archived";
+}
+function activeLocalRootGoals(root) {
+    const config = (0, config_1.loadConfig)(root);
+    const index = (0, indexer_1.buildIndex)(root, config);
+    return Object.values(index.nodes)
+        .filter((node) => !node.source?.imported)
+        .filter((node) => node.ws === "root" && node.type === "goal")
+        .filter((node) => isActiveGoalStatus(node.status, String(node.attributes.goal_state ?? "")))
+        .sort((a, b) => a.qid.localeCompare(b.qid));
+}
+function localGoalLifecycleReceipt(node, status, goalState, planned) {
+    return {
+        workspace: node.ws,
+        id: node.id,
+        qid: node.qid,
+        path: node.path,
+        previous_status: node.status ?? "",
+        previous_goal_state: String(node.attributes.goal_state ?? ""),
+        status,
+        goal_state: goalState,
+        source: "local",
+        planned,
+    };
+}
+function importedGoalLifecycleReceipt(plan, status, goalState, planned) {
+    return {
+        workspace: "root",
+        id: plan.to_id,
+        qid: qidForRoot(plan.to_id),
+        path: plan.target_path,
+        previous_status: plan.status ?? "",
+        previous_goal_state: plan.goal_state ?? "",
+        status,
+        goal_state: goalState,
+        source: "imported",
+        planned,
+    };
+}
+function readNodeFile(root, nodePath) {
+    const filePath = path_1.default.join(root, nodePath);
+    const parsed = (0, frontmatter_1.parseFrontmatter)(fs_1.default.readFileSync(filePath, "utf8"), nodePath);
+    return { filePath, frontmatter: { ...parsed.frontmatter }, body: parsed.body };
+}
+function writeRenderedNodeFile(filePath, frontmatter, body) {
+    (0, atomic_1.atomicWriteFile)(filePath, renderNode(frontmatter, body));
+}
+function pauseLocalGoals(root, goals, config) {
+    const today = (0, date_1.formatDate)(new Date());
+    for (const goal of goals.filter((item) => item.source === "local")) {
+        const loaded = readNodeFile(root, goal.path);
+        loaded.frontmatter.status = ensureStatusAllowed(config, "blocked");
+        loaded.frontmatter.goal_state = "paused";
+        loaded.frontmatter.updated = today;
+        writeRenderedNodeFile(loaded.filePath, loaded.frontmatter, loaded.body);
+    }
+}
 function isWorkMarkdownPath(value) {
     const normalized = value.replace(/\\/g, "/");
     return normalized.startsWith(".mdkg/work/") && normalized.endsWith(".md");
@@ -340,14 +420,41 @@ function planImportTemplate(options) {
             from_id: node.id,
             to_id: toId,
             type: node.type,
+            status: typeof frontmatter.status === "string" ? frontmatter.status : undefined,
+            goal_state: typeof frontmatter.goal_state === "string" ? frontmatter.goal_state : undefined,
             title: typeof frontmatter.title === "string" ? frontmatter.title : undefined,
             content: renderNode(frontmatter, body),
         };
     });
     const startGoalToId = options.startGoal ? (idMap.get(options.startGoal) ?? options.startGoal) : undefined;
-    if (options.startGoal && !plans.some((plan) => plan.to_id === startGoalToId && plan.type === "goal")) {
+    const startGoalPlan = startGoalToId
+        ? plans.find((plan) => plan.to_id === startGoalToId && plan.type === "goal")
+        : undefined;
+    if (options.startGoal && !startGoalPlan) {
         throw new errors_1.NotFoundError(`start goal not found in imported template graph: ${options.startGoal}`);
     }
+    if (options.selectGoal && startGoalPlan && isClosedGoalStatus(startGoalPlan.status, startGoalPlan.goal_state)) {
+        throw new errors_1.UsageError(`cannot select achieved or archived imported start goal: ${options.startGoal}`);
+    }
+    const localActiveGoals = activeLocalRootGoals(options.root);
+    const importedActiveGoals = plans
+        .filter((plan) => plan.type === "goal")
+        .filter((plan) => isActiveGoalStatus(plan.status, plan.goal_state));
+    if (!options.selectGoal && localActiveGoals.length + importedActiveGoals.length > 1) {
+        throw new errors_1.UsageError("import-template would create multiple active root goals; use --select-goal --start-goal <goal-id> or pause active goals before importing");
+    }
+    const activatedGoal = options.selectGoal && startGoalPlan
+        ? importedGoalLifecycleReceipt(startGoalPlan, "progress", "active", !options.apply)
+        : undefined;
+    const pausedGoals = options.selectGoal && startGoalPlan
+        ? [
+            ...localActiveGoals.map((node) => localGoalLifecycleReceipt(node, "blocked", "paused", !options.apply)),
+            ...importedActiveGoals
+                .filter((plan) => plan.to_id !== startGoalPlan.to_id)
+                .map((plan) => importedGoalLifecycleReceipt(plan, "blocked", "paused", !options.apply)),
+        ]
+        : [];
+    const warnings = pausedGoals.length > 0 ? [`paused ${pausedGoals.length} competing active goal(s)`] : [];
     const mode = options.apply ? "import_template_applied" : "import_template_dry_run";
     return {
         action: "graph.import_template",
@@ -383,7 +490,9 @@ function planImportTemplate(options) {
         ...(options.selectGoal && startGoalToId
             ? { selected_goal: { qid: `root:${startGoalToId}`, path: ".mdkg/state/selected-goal.json", planned: !options.apply } }
             : {}),
-        warnings: [],
+        ...(activatedGoal ? { activated_goal: activatedGoal } : {}),
+        paused_goals: pausedGoals,
+        warnings,
     };
 }
 function applyImportTemplate(options, receipt) {
@@ -439,6 +548,17 @@ function applyImportTemplate(options, receipt) {
                 frontmatter[field] = rewriteFrontmatterValue(value, idMap, node.sourcePath, field, ignoredRewrites);
             }
             const body = rewriteStringValue(node.parsed.body, idMap, node.sourcePath, "body", ignoredRewrites);
+            if (frontmatter.type === "goal" && options.selectGoal) {
+                if (qidForRoot(toId) === applyPlan.activated_goal?.qid) {
+                    frontmatter.status = ensureStatusAllowed(config, "progress");
+                    frontmatter.goal_state = "active";
+                }
+                else if (isActiveGoalStatus(String(frontmatter.status ?? ""), String(frontmatter.goal_state ?? ""))) {
+                    frontmatter.status = ensureStatusAllowed(config, "blocked");
+                    frontmatter.goal_state = "paused";
+                }
+                frontmatter.updated = (0, date_1.formatDate)(new Date());
+            }
             const targetPath = targetPathForImport(node.sourcePath, node.id, toId, usedPaths);
             contentByTarget.set(targetPath, renderNode(frontmatter, body));
         }
@@ -451,22 +571,24 @@ function applyImportTemplate(options, receipt) {
             fs_1.default.mkdirSync(path_1.default.dirname(targetAbs), { recursive: true });
             (0, atomic_1.atomicWriteFile)(targetAbs, content);
         }
+        pauseLocalGoals(options.root, applyPlan.paused_goals, config);
         const indexReceipt = (0, index_1.rebuildDerivedIndexCaches)({ root: options.root });
+        const validation = (0, validate_1.collectValidateReceipt)({ root: options.root, quiet: true });
+        if (validation.error_count > 0) {
+            throw new errors_1.ValidationError(`imported graph validation failed with ${validation.error_count} error(s)`);
+        }
         if (options.selectGoal && options.startGoal) {
             const selected = applyPlan.selected_goal?.qid;
             if (!selected) {
                 throw new errors_1.UsageError("--select-goal could not resolve imported start goal");
             }
-            const [, id] = selected.split(":");
-            if (!id) {
-                throw new errors_1.UsageError(`invalid selected goal qid: ${selected}`);
-            }
+            const id = idFromRootQid(selected);
             writeSelectedGoal(options.root, selected, id, "root");
             applyPlan.selected_goal = { qid: selected, path: ".mdkg/state/selected-goal.json", planned: false };
-        }
-        const validation = (0, validate_1.collectValidateReceipt)({ root: options.root, quiet: true });
-        if (validation.error_count > 0) {
-            throw new errors_1.ValidationError(`imported graph validation failed with ${validation.error_count} error(s)`);
+            if (applyPlan.activated_goal) {
+                applyPlan.activated_goal.planned = false;
+            }
+            applyPlan.paused_goals = applyPlan.paused_goals.map((goal) => ({ ...goal, planned: false }));
         }
         return {
             ...applyPlan,