@lsctech/polaris 0.1.0

package/dist/mcp/tools/loop-continue.js

@@ -0,0 +1,159 @@
+"use strict";
+// HARD CONSTRAINTS — do not remove these comments:
+// DO NOT implement unrestricted continuation (no open-ended "run everything" path)
+// DO NOT implement arbitrary shell passthrough (no exec/spawn of user-provided commands)
+// DO NOT implement direct git operations (no git commit/push from this handler)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleLoopContinueConfirmed = handleLoopContinueConfirmed;
+const envelope_js_1 = require("../../runtime/verification/envelope.js");
+const logger_js_1 = require("../../runtime/audit/logger.js");
+const state_js_1 = require("../../runtime/state.js");
+const confirmed_js_1 = require("../../runtime/continuation/confirmed.js");
+// Per-artifact-dir lock: prevents two concurrent confirmations from both passing
+// validation before either writes active_child to disk. Set operations are
+// synchronous so the check-and-add is atomic within a single Node.js event loop tick.
+const pendingConfirmations = new Set();
+function parseEnvelope(args) {
+    const artifact_dir = typeof args["artifact_dir"] === "string" ? args["artifact_dir"] : "polaris-run";
+    const required = [
+        "run_id",
+        "expected_step_cursor",
+        "fingerprint",
+        "nonce",
+        "issued_at",
+        "expires_at",
+        "requested_action",
+    ];
+    for (const key of required) {
+        if (typeof args[key] !== "string") {
+            throw new Error(`missing_or_invalid_field: ${key} must be a string`);
+        }
+    }
+    if (typeof args["runtime_generation"] !== "number") {
+        throw new Error("missing_or_invalid_field: runtime_generation must be a number");
+    }
+    if (args["requested_action"] !== "loop_continue") {
+        throw new Error(`invalid_field: requested_action must be "loop_continue", got "${String(args["requested_action"])}"`);
+    }
+    return {
+        artifact_dir,
+        run_id: args["run_id"],
+        expected_step_cursor: args["expected_step_cursor"],
+        fingerprint: args["fingerprint"],
+        runtime_generation: args["runtime_generation"],
+        issued_at: args["issued_at"],
+        expires_at: args["expires_at"],
+        nonce: args["nonce"],
+        requested_action: "loop_continue",
+    };
+}
+/**
+ * Handle a polaris_loop_continue_confirmed MCP tool call.
+ *
+ * Validates the supplied ContinuationApprovalEnvelope against the current live
+ * state (fresh disk read — never cached). On success, dispatches the next child
+ * via the confirmed continuation service and returns the dispatch result.
+ *
+ * Returns `{ ok: true, child_id, compact_return }` on success, or
+ * `{ ok: false, rejection: { check, reason, ... } }` on any failure.
+ */
+async function handleLoopContinueConfirmed(args) {
+    // Parse and validate input shape
+    let parsed;
+    try {
+        parsed = parseEnvelope(args);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: "invalid_input",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+    const { artifact_dir, ...envelope } = parsed;
+    // Load state first — needed for audit events even if we reject early.
+    // Always a fresh read, never cached.
+    const state = await (0, state_js_1.loadState)(artifact_dir);
+    if (state === null) {
+        return {
+            ok: false,
+            error: "state_not_found",
+            message: `No current-state.json found for artifact_dir="${artifact_dir}"`,
+        };
+    }
+    // In-memory lock: if another confirmation is in flight for this artifact_dir,
+    // reject immediately. Load state first so we can write a proper audit event.
+    // Set operations are synchronous, so check+add is atomic within one event-loop tick.
+    if (pendingConfirmations.has(artifact_dir)) {
+        await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+            event_type: "mutation_rejected",
+            run_id: state.run_id,
+            step_cursor: state.step_cursor,
+            operator: "mcp",
+            operation: "loop_continue_confirmed",
+            approval_fingerprint: envelope.fingerprint,
+            result: "rejected",
+            rejection_reason: "active_child: concurrent_execution",
+        });
+        return {
+            ok: false,
+            rejection: { check: "active_child", reason: "concurrent_execution" },
+        };
+    }
+    pendingConfirmations.add(artifact_dir);
+    try {
+        // Validate envelope against live state (all 9 structural checks)
+        const validation = (0, envelope_js_1.validateEnvelope)(state, envelope);
+        if (!validation.ok) {
+            await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+                event_type: "mutation_rejected",
+                run_id: state.run_id,
+                step_cursor: state.step_cursor,
+                operator: "mcp",
+                operation: "loop_continue_confirmed",
+                approval_fingerprint: envelope.fingerprint,
+                result: "rejected",
+                rejection_reason: `${validation.failure.check}: ${validation.failure.reason}`,
+            });
+            return {
+                ok: false,
+                rejection: {
+                    check: validation.failure.check,
+                    reason: validation.failure.reason,
+                    ...(validation.failure.expected !== undefined && { expected: validation.failure.expected }),
+                    ...(validation.failure.actual !== undefined && { actual: validation.failure.actual }),
+                },
+            };
+        }
+        // Validation passed — record mutation_requested
+        await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+            event_type: "mutation_requested",
+            run_id: state.run_id,
+            step_cursor: state.step_cursor,
+            operator: "mcp",
+            operation: "loop_continue_confirmed",
+            approval_fingerprint: envelope.fingerprint,
+            result: "ok",
+        });
+        // Delegate checkpoint, active_child lease write, and mutation_approved audit to
+        // the confirmed continuation service.
+        const adapterOverride = typeof args["adapterOverride"] === "string"
+            ? args["adapterOverride"]
+            : undefined;
+        const _adapterFactory = typeof args["_adapterFactory"] === "function"
+            ? args["_adapterFactory"]
+            : undefined;
+        const dispatchResult = await (0, confirmed_js_1.dispatchConfirmedContinuation)({ artifact_dir, envelope, adapterOverride, _adapterFactory });
+        if (!dispatchResult.ok) {
+            return { ok: false, rejection: dispatchResult.rejection };
+        }
+        return {
+            ok: true,
+            child_id: dispatchResult.child_id,
+            compact_return: dispatchResult.compact_return,
+        };
+    }
+    finally {
+        pendingConfirmations.delete(artifact_dir);
+    }
+}

package/dist/mcp/tools/loop-continue.test.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * POL-96: End-to-end tests for handleLoopContinueConfirmed MCP response shape.
+ *
+ * Covers:
+ *   1. Full success path — response includes ok, child_id, compact_return
+ *   2. Dispatch failure path (adapter_mode / terminal-cli) — response includes ok: false, rejection
+ *   3. pendingConfirmations lock released on error (state_not_found)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const dry_run_js_1 = require("../../runtime/continuation/dry-run.js");
+const loop_continue_js_1 = require("./loop-continue.js");
+const confirmedModule = __importStar(require("../../runtime/continuation/confirmed.js"));
+// Mock the confirmed module so we can control dispatchConfirmedContinuation in Test 1
+vitest_1.vi.mock("../../runtime/continuation/confirmed.js", async (importOriginal) => {
+    const original = await importOriginal();
+    return {
+        ...original,
+        dispatchConfirmedContinuation: vitest_1.vi.fn(original.dispatchConfirmedContinuation),
+    };
+});
+const ARTIFACTS_ROOT = node_path_1.default.join(process.cwd(), ".taskchain_artifacts");
+function makeRunningState(overrides = {}) {
+    return {
+        schema_version: "1.0",
+        run_id: "polaris-run-test-pol96",
+        cluster_id: "POL-88",
+        active_child: null,
+        completed_children: ["POL-91", "POL-92", "POL-93"],
+        open_children: ["POL-96"],
+        step_cursor: "06-decide-continuation",
+        context_budget: { children_completed: 3, max_children_per_session: 4 },
+        status: "running",
+        runtime_generation: 1,
+        orchestration_mode: "bootstrap",
+        continuation_epoch: 0,
+        ...overrides,
+    };
+}
+async function writeStateFile(artifactDir, state) {
+    const dir = node_path_1.default.join(ARTIFACTS_ROOT, artifactDir);
+    await (0, promises_1.mkdir)(dir, { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(dir, "current-state.json"), JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+function buildEnvelope(template, overrides = {}) {
+    const now = new Date();
+    return {
+        ...template,
+        issued_at: now.toISOString(),
+        expires_at: new Date(now.getTime() + 5 * 60 * 1000).toISOString(),
+        ...overrides,
+    };
+}
+let testArtifactDir;
+(0, vitest_1.beforeEach)(() => {
+    testArtifactDir = `test-pol96-${(0, node_crypto_1.randomUUID)().slice(0, 8)}`;
+    vitest_1.vi.mocked(confirmedModule.dispatchConfirmedContinuation).mockRestore();
+});
+(0, vitest_1.afterEach)(async () => {
+    const dir = node_path_1.default.join(ARTIFACTS_ROOT, testArtifactDir);
+    await (0, promises_1.rm)(dir, { recursive: true, force: true });
+});
+(0, vitest_1.describe)("handleLoopContinueConfirmed — MCP response shape", () => {
+    (0, vitest_1.it)("Test 1: full success path returns ok, child_id, and compact_return", async () => {
+        await writeStateFile(testArtifactDir, makeRunningState());
+        const dryRunResult = await (0, dry_run_js_1.executeDryRun)({
+            artifact_dir: testArtifactDir,
+            expected_step_cursor: "06-decide-continuation",
+        });
+        (0, vitest_1.expect)(dryRunResult.ok).toBe(true);
+        if (!dryRunResult.ok)
+            return;
+        const envelope = buildEnvelope(dryRunResult.preview.approval_template);
+        // Override dispatch to return a controlled success result (avoids AgentSubtaskAdapter I/O)
+        vitest_1.vi.mocked(confirmedModule.dispatchConfirmedContinuation).mockResolvedValueOnce({
+            ok: true,
+            child_id: "POL-96",
+            compact_return: { status: "done", state_updated: true, exit_code: 0 },
+        });
+        const result = await (0, loop_continue_js_1.handleLoopContinueConfirmed)({
+            artifact_dir: testArtifactDir,
+            ...envelope,
+        });
+        (0, vitest_1.expect)(result["ok"]).toBe(true);
+        (0, vitest_1.expect)(result["child_id"]).toBe("POL-96");
+        (0, vitest_1.expect)(result["compact_return"]).toBeDefined();
+        const compactReturn = result["compact_return"];
+        (0, vitest_1.expect)(compactReturn["status"]).toBe("done");
+        (0, vitest_1.expect)(compactReturn["state_updated"]).toBe(true);
+        (0, vitest_1.expect)(vitest_1.vi.mocked(confirmedModule.dispatchConfirmedContinuation)).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)("Test 2: dispatch failure (terminal-cli adapter) returns ok: false with rejection", async () => {
+        await writeStateFile(testArtifactDir, makeRunningState());
+        const dryRunResult = await (0, dry_run_js_1.executeDryRun)({
+            artifact_dir: testArtifactDir,
+            expected_step_cursor: "06-decide-continuation",
+        });
+        (0, vitest_1.expect)(dryRunResult.ok).toBe(true);
+        if (!dryRunResult.ok)
+            return;
+        const envelope = buildEnvelope(dryRunResult.preview.approval_template);
+        // Use adapterOverride: "terminal-cli" via args to trigger manual_dispatch_required
+        // (real code path — no mock needed)
+        const result = await (0, loop_continue_js_1.handleLoopContinueConfirmed)({
+            artifact_dir: testArtifactDir,
+            adapterOverride: "terminal-cli",
+            ...envelope,
+        });
+        (0, vitest_1.expect)(result["ok"]).toBe(false);
+        (0, vitest_1.expect)(result["rejection"]).toBeDefined();
+        const rejection = result["rejection"];
+        (0, vitest_1.expect)(rejection["check"]).toBe("adapter_mode");
+        (0, vitest_1.expect)(rejection["reason"]).toBe("manual_dispatch_required");
+    });
+    (0, vitest_1.it)("Test 3: pendingConfirmations lock released on state_not_found error", async () => {
+        // No state written — triggers state_not_found path
+        const result = await (0, loop_continue_js_1.handleLoopContinueConfirmed)({
+            artifact_dir: testArtifactDir,
+            run_id: "polaris-run-test-pol96",
+            expected_step_cursor: "06-decide-continuation",
+            fingerprint: "dummy-fingerprint",
+            nonce: (0, node_crypto_1.randomUUID)(),
+            issued_at: new Date().toISOString(),
+            expires_at: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+            requested_action: "loop_continue",
+            runtime_generation: 1,
+        });
+        (0, vitest_1.expect)(result["ok"]).toBe(false);
+        (0, vitest_1.expect)(result["error"]).toBe("state_not_found");
+        // Verify lock is released: a subsequent call for the same artifact_dir should
+        // return state_not_found again, not concurrent_execution
+        const result2 = await (0, loop_continue_js_1.handleLoopContinueConfirmed)({
+            artifact_dir: testArtifactDir,
+            run_id: "polaris-run-test-pol96",
+            expected_step_cursor: "06-decide-continuation",
+            fingerprint: "dummy-fingerprint",
+            nonce: (0, node_crypto_1.randomUUID)(),
+            issued_at: new Date().toISOString(),
+            expires_at: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+            requested_action: "loop_continue",
+            runtime_generation: 1,
+        });
+        (0, vitest_1.expect)(result2["ok"]).toBe(false);
+        (0, vitest_1.expect)(result2["error"]).toBe("state_not_found");
+    });
+});

package/dist/mcp/tools/loop-dry-run.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DryRunInputSchema = void 0;
+exports.handleLoopContinueDryRun = handleLoopContinueDryRun;
+const zod_1 = require("zod");
+const dry_run_js_1 = require("../../runtime/continuation/dry-run.js");
+exports.DryRunInputSchema = zod_1.z.object({
+    artifact_dir: zod_1.z.string().default("polaris-run"),
+    expected_step_cursor: zod_1.z.string(),
+});
+async function handleLoopContinueDryRun(args) {
+    const input = exports.DryRunInputSchema.parse(args);
+    const result = await (0, dry_run_js_1.executeDryRun)(input);
+    return result;
+}

package/dist/mcp/tools/status.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePolarisStatus = handlePolarisStatus;
+exports.handlePolarisLoopStatus = handlePolarisLoopStatus;
+const invoke_js_1 = require("../lib/invoke.js");
+const root_js_1 = require("../lib/root.js");
+function normalizeBudget(budget) {
+    if (!budget)
+        return undefined;
+    const completed = typeof budget.children_completed === "number" ? budget.children_completed : 0;
+    const max = typeof budget.max_children_per_session === "number" ? budget.max_children_per_session : 3;
+    return {
+        children_completed: completed,
+        max_children_per_session: max,
+        remaining: Math.max(0, max - completed),
+    };
+}
+function buildStatusResponse(raw) {
+    const p = raw;
+    return {
+        ok: true,
+        run_id: p.run_id ?? null,
+        cluster_id: p.cluster_id ?? null,
+        status: p.status ?? null,
+        active_child: p.active_child ?? null,
+        completed_children: p.completed_children ?? [],
+        open_children: p.open_children ?? [],
+        step_cursor: p.step_cursor ?? null,
+        context_budget: normalizeBudget(p.context_budget),
+    };
+}
+function errorResponse(error, message, hint) {
+    const r = { ok: false, error, message };
+    if (hint)
+        r["hint"] = hint;
+    return r;
+}
+async function handlePolarisStatus() {
+    const repoRoot = (0, root_js_1.resolveRepoRoot)();
+    try {
+        const raw = (0, invoke_js_1.invokePolarisJson)(repoRoot, ["status", "--json"]);
+        return buildStatusResponse(raw);
+    }
+    catch (err) {
+        if (err instanceof invoke_js_1.InvokeError) {
+            const isNotFound = err.stderr.includes("cannot read state file") || err.message.includes("cannot read");
+            return errorResponse(isNotFound ? "state_not_found" : "invoke_failed", err.message, isNotFound ? "Run a polaris cluster session first to create current-state.json" : undefined);
+        }
+        return errorResponse("unknown", String(err));
+    }
+}
+async function handlePolarisLoopStatus() {
+    const repoRoot = (0, root_js_1.resolveRepoRoot)();
+    try {
+        const raw = (0, invoke_js_1.invokePolarisJson)(repoRoot, ["loop", "status", "--json"]);
+        return buildStatusResponse(raw);
+    }
+    catch (err) {
+        if (err instanceof invoke_js_1.InvokeError) {
+            const isNotFound = err.stderr.includes("cannot read state file") || err.message.includes("cannot read");
+            return errorResponse(isNotFound ? "state_not_found" : "invoke_failed", err.message, isNotFound ? "Run a polaris cluster session first to create current-state.json" : undefined);
+        }
+        return errorResponse("unknown", String(err));
+    }
+}

package/dist/medic/chart-id.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChartId = parseChartId;
+exports.formatChartId = formatChartId;
+exports.getTodayDate = getTodayDate;
+exports.getMaxSequenceForDate = getMaxSequenceForDate;
+exports.generateNextChartId = generateNextChartId;
+const node_fs_1 = require("node:fs");
+/**
+ * Parse a Chart ID string into its components
+ */
+function parseChartId(chartId) {
+    const match = chartId.match(/^CHART-(\d{4}-\d{2}-\d{2})-(\d{3})$/);
+    if (!match)
+        return null;
+    return {
+        full: chartId,
+        date: match[1],
+        sequence: parseInt(match[2], 10),
+    };
+}
+/**
+ * Format a Chart ID from its components
+ */
+function formatChartId(date, sequence) {
+    return `CHART-${date}-${sequence.toString().padStart(3, "0")}`;
+}
+/**
+ * Get today's date in YYYY-MM-DD format (UTC)
+ */
+function getTodayDate() {
+    const now = new Date();
+    const year = now.getUTCFullYear();
+    const month = String(now.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(now.getUTCDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+/**
+ * Scan the charts directory for existing chart IDs on a given date
+ * and return the maximum sequence number found
+ */
+function getMaxSequenceForDate(chartsDir, date) {
+    if (!(0, node_fs_1.existsSync)(chartsDir))
+        return 0;
+    const files = (0, node_fs_1.readdirSync)(chartsDir);
+    const prefix = `CHART-${date}-`;
+    let maxSeq = 0;
+    for (const file of files) {
+        // Strip file extension for parsing
+        const baseName = file.replace(/\.[^/.]+$/, "");
+        if (baseName.startsWith(prefix)) {
+            const parsed = parseChartId(baseName);
+            if (parsed && parsed.sequence > maxSeq) {
+                maxSeq = parsed.sequence;
+            }
+        }
+    }
+    return maxSeq;
+}
+/**
+ * Generate the next Chart ID for today
+ */
+function generateNextChartId(chartsDir) {
+    const today = getTodayDate();
+    const maxSeq = getMaxSequenceForDate(chartsDir, today);
+    const nextSeq = maxSeq + 1;
+    if (nextSeq > 999) {
+        throw new RangeError(`Chart sequence overflow for ${today}: maximum sequence is 999, cannot generate sequence ${nextSeq}`);
+    }
+    return {
+        full: formatChartId(today, nextSeq),
+        date: today,
+        sequence: nextSeq,
+    };
+}

package/dist/medic/chart-schema.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_SECTIONS = exports.ChartFrontMatter = exports.ChartRelationship = exports.ChartRelationshipType = void 0;
+exports.validateChartFrontMatter = validateChartFrontMatter;
+exports.validateChartSections = validateChartSections;
+exports.validateChart = validateChart;
+const zod_1 = require("zod");
+/**
+ * Supported chart relationship types
+ */
+exports.ChartRelationshipType = zod_1.z.enum([
+    "same_failure",
+    "edge_case_of",
+    "regression_of",
+    "caused_by",
+    "fixed_by",
+    "supersedes",
+    "duplicate_of",
+]);
+/**
+ * Chart relationship reference
+ */
+exports.ChartRelationship = zod_1.z.object({
+    chart_id: zod_1.z.string().regex(/^CHART-\d{4}-\d{2}-\d{2}-\d{3}$/, {
+        message: "chart_id must match format CHART-YYYY-MM-DD-NNN",
+    }),
+    relationship: exports.ChartRelationshipType,
+});
+/**
+ * Chart front-matter schema
+ */
+exports.ChartFrontMatter = zod_1.z.object({
+    chart_id: zod_1.z.string().regex(/^CHART-\d{4}-\d{2}-\d{2}-\d{3}$/, {
+        message: "chart_id must match format CHART-YYYY-MM-DD-NNN",
+    }),
+    cluster_id: zod_1.z.string().min(1),
+    route: zod_1.z.string().min(1),
+    status: zod_1.z.string().min(1),
+    related_charts: zod_1.z.array(exports.ChartRelationship).optional(),
+    created: zod_1.z.string().datetime(),
+    updated: zod_1.z.string().datetime(),
+    drift_observations: zod_1.z.array(zod_1.z.string()).optional(),
+});
+/**
+ * Required section headings in a chart
+ */
+exports.REQUIRED_SECTIONS = [
+    "Problem",
+    "Symptoms",
+    "Root Cause",
+    "Affected Files",
+    "Treatment",
+    "Validation",
+    "Prevention",
+    "When To Read This Chart",
+];
+/**
+ * Validate chart front-matter
+ */
+function validateChartFrontMatter(frontMatter) {
+    const result = exports.ChartFrontMatter.safeParse(frontMatter);
+    if (!result.success) {
+        return {
+            valid: false,
+            errors: result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`),
+        };
+    }
+    return { valid: true, errors: [] };
+}
+/**
+ * Check if a markdown content contains all required section headings
+ */
+function validateChartSections(content) {
+    const errors = [];
+    for (const section of exports.REQUIRED_SECTIONS) {
+        // Check for section heading (## at level 2, or # at level 1)
+        const pattern = new RegExp(`^#{1,2}\\s*${section}\\s*$`, "m");
+        if (!pattern.test(content)) {
+            errors.push(`Missing required section: ${section}`);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Validate a complete chart (front-matter and sections)
+ */
+function validateChart(content) {
+    const frontMatterErrors = [];
+    const sectionErrors = [];
+    // Extract front-matter
+    const frontMatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontMatterMatch) {
+        return {
+            valid: false,
+            errors: ["Chart must have YAML front-matter delimited by ---"],
+        };
+    }
+    // Parse YAML front-matter (simple key:value parsing)
+    const frontMatter = {};
+    const frontMatterLines = frontMatterMatch[1].split("\n");
+    for (const line of frontMatterLines) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const value = line.slice(colonIdx + 1).trim();
+        // Remove quotes if present
+        const cleanedValue = value.replace(/^["']|["']$/g, "");
+        // Handle arrays (simple comma-separated for now)
+        if (cleanedValue.startsWith("[") && cleanedValue.endsWith("]")) {
+            const arrayContent = cleanedValue.slice(1, -1);
+            if (arrayContent.trim() === "") {
+                frontMatter[key] = [];
+            }
+            else {
+                frontMatter[key] = arrayContent.split(",").map((s) => s.trim());
+            }
+        }
+        else if (key === "related_charts") {
+            // Special handling for related_charts array of objects
+            // This is a simplified parser - in production you'd use a proper YAML parser
+            frontMatter[key] = [];
+        }
+        else {
+            frontMatter[key] = cleanedValue;
+        }
+    }
+    const frontMatterResult = validateChartFrontMatter(frontMatter);
+    frontMatterErrors.push(...frontMatterResult.errors);
+    const sectionResult = validateChartSections(content);
+    sectionErrors.push(...sectionResult.errors);
+    return {
+        valid: frontMatterErrors.length === 0 && sectionErrors.length === 0,
+        errors: [...frontMatterErrors, ...sectionErrors],
+    };
+}