onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/learning/usage-tracker.test.js

@@ -1,176 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { stringify } from "yaml";
-import { collectLearningUsage, computeAggregate } from "./usage-tracker.js";
-// ─── Fixture helpers ───
-function makeManifest(overrides = {}) {
-    return {
-        session_domain: "none",
-        agents_loaded: 2,
-        total_items_loaded: 90,
-        total_items_parsed: 200,
-        total_items_skipped: 10,
-        degraded: false,
-        degradation_reason: null,
-        per_agent: [
-            {
-                agent_id: "logic",
-                loaded: 46,
-                parsed: 120,
-                skipped: 4,
-                truncated: 74,
-                role_distribution: { guardrail: 15, foundation: 21, convention: 1, unclassified: 9 },
-                tier_distribution: { "1": 15, "2": 11, "3": 19, "4": 1 },
-                cross_domain_included: 0,
-                cross_domain_excluded: 0,
-                tokens_used: 6259,
-                tokens_budget: 4000,
-                budget_truncated_count: 48,
-            },
-            {
-                agent_id: "structure",
-                loaded: 44,
-                parsed: 80,
-                skipped: 6,
-                truncated: 36,
-                role_distribution: { guardrail: 12, foundation: 4, convention: 0, unclassified: 28 },
-                tier_distribution: { "1": 12, "2": 16, "3": 4, "4": 12 },
-                cross_domain_included: 0,
-                cross_domain_excluded: 0,
-                tokens_used: 5666,
-                tokens_budget: 4000,
-                budget_truncated_count: 32,
-            },
-        ],
-        learning_file_paths: [],
-        ...overrides,
-    };
-}
-let testDir;
-function createSessionManifest(reviewRoot, sessionId, manifestOverrides = {}) {
-    const prepDir = join(reviewRoot, sessionId, "execution-preparation");
-    mkdirSync(prepDir, { recursive: true });
-    writeFileSync(join(prepDir, "learning-manifest.yaml"), stringify(makeManifest(manifestOverrides)));
-}
-// ─── Tests ───
-describe("usage-tracker", () => {
-    beforeEach(() => {
-        testDir = join(tmpdir(), `usage-tracker-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        mkdirSync(testDir, { recursive: true });
-    });
-    afterEach(() => {
-        rmSync(testDir, { recursive: true, force: true });
-    });
-    describe("collectLearningUsage", () => {
-        it("빈 디렉터리에서 빈 summary 를 반환한다", () => {
-            const result = collectLearningUsage(testDir);
-            expect(result.total_sessions).toBe(0);
-            expect(result.entries).toHaveLength(0);
-        });
-        it("존재하지 않는 경로에서 빈 summary 를 반환한다", () => {
-            const result = collectLearningUsage("/nonexistent/path");
-            expect(result.total_sessions).toBe(0);
-        });
-        it("단일 세션의 learning manifest 를 수집한다", () => {
-            createSessionManifest(testDir, "20260413-aaa00001");
-            const result = collectLearningUsage(testDir);
-            expect(result.total_sessions).toBe(1);
-            const entry = result.entries[0];
-            expect(entry.session_id).toBe("20260413-aaa00001");
-            expect(entry.total_items_loaded).toBe(90);
-            expect(entry.total_items_parsed).toBe(200);
-            expect(entry.agents_loaded).toBe(2);
-        });
-        it("per-agent tier/role 분포를 합산한다", () => {
-            createSessionManifest(testDir, "20260413-aaa00001");
-            const result = collectLearningUsage(testDir);
-            const entry = result.entries[0];
-            // logic t1:15 + structure t1:12 = 27
-            expect(entry.tier_distribution.t1).toBe(27);
-            // logic guardrail:15 + structure guardrail:12 = 27
-            expect(entry.role_distribution.guardrail).toBe(27);
-        });
-        it("tokens_used 와 budget_truncated 를 합산한다", () => {
-            createSessionManifest(testDir, "20260413-aaa00001");
-            const result = collectLearningUsage(testDir);
-            const entry = result.entries[0];
-            expect(entry.total_tokens_used).toBe(6259 + 5666);
-            expect(entry.total_budget_truncated).toBe(48 + 32);
-        });
-        it("learning-manifest.yaml 없는 세션은 건너뛴다", () => {
-            const sessionDir = join(testDir, "20260413-bbb00002");
-            mkdirSync(sessionDir, { recursive: true });
-            const result = collectLearningUsage(testDir);
-            expect(result.total_sessions).toBe(0);
-        });
-        it("여러 세션을 session_id 순 정렬한다", () => {
-            createSessionManifest(testDir, "20260413-bbb00002");
-            createSessionManifest(testDir, "20260413-aaa00001");
-            const result = collectLearningUsage(testDir);
-            expect(result.entries[0].session_id).toBe("20260413-aaa00001");
-            expect(result.entries[1].session_id).toBe("20260413-bbb00002");
-        });
-    });
-    describe("computeAggregate", () => {
-        it("빈 entries 에서 zero aggregate 를 반환한다", () => {
-            const agg = computeAggregate([]);
-            expect(agg.avg_items_loaded).toBe(0);
-            expect(agg.supply_ratio).toBe(0);
-        });
-        it("단일 세션의 supply_ratio 를 정확히 산출한다", () => {
-            const entries = [
-                makeUsageEntry("s1", { loaded: 90, parsed: 200 }),
-            ];
-            const agg = computeAggregate(entries);
-            expect(agg.supply_ratio).toBe(0.45); // 90/200
-            expect(agg.avg_items_loaded).toBe(90);
-        });
-        it("여러 세션의 평균을 산출한다", () => {
-            const entries = [
-                makeUsageEntry("s1", { loaded: 100, parsed: 200, tokens: 10000 }),
-                makeUsageEntry("s2", { loaded: 200, parsed: 400, tokens: 20000 }),
-            ];
-            const agg = computeAggregate(entries);
-            expect(agg.avg_items_loaded).toBe(150);
-            expect(agg.avg_items_parsed).toBe(300);
-            expect(agg.supply_ratio).toBe(0.5); // 300/600
-            expect(agg.avg_tokens_used).toBe(15000);
-        });
-        it("degradation_ratio 를 정확히 산출한다", () => {
-            const entries = [
-                makeUsageEntry("s1", { degraded: true }),
-                makeUsageEntry("s2", { degraded: false }),
-                makeUsageEntry("s3", { degraded: false }),
-            ];
-            const agg = computeAggregate(entries);
-            expect(agg.degradation_ratio).toBe(0.333);
-        });
-        it("tier/role 분포를 합산한다", () => {
-            const entries = [
-                makeUsageEntry("s1", { tier: { t1: 10, t2: 5, t3: 3, t4: 2 } }),
-                makeUsageEntry("s2", { tier: { t1: 8, t2: 4, t3: 2, t4: 1 } }),
-            ];
-            const agg = computeAggregate(entries);
-            expect(agg.total_tier_distribution.t1).toBe(18);
-            expect(agg.total_tier_distribution.t2).toBe(9);
-        });
-    });
-});
-// ─── Test helper ───
-function makeUsageEntry(session_id, overrides = {}) {
-    return {
-        session_id,
-        session_domain: "none",
-        agents_loaded: 9,
-        total_items_loaded: overrides.loaded ?? 100,
-        total_items_parsed: overrides.parsed ?? 200,
-        total_items_skipped: 10,
-        total_tokens_used: overrides.tokens ?? 10000,
-        total_budget_truncated: 5,
-        degraded: overrides.degraded ?? false,
-        tier_distribution: overrides.tier ?? { t1: 10, t2: 5, t3: 3, t4: 2 },
-        role_distribution: { guardrail: 10, foundation: 5, convention: 2, unclassified: 3 },
-    };
-}

package/dist/core-runtime/onboard/detect-review-axes.js

@@ -1,122 +0,0 @@
-/**
- * Review UX Redesign P4 — onboard-time detection of review axes.
- *
- * # What this module is
- *
- * A small pure function that aggregates the environmental signals relevant
- * to the review execution configuration (design doc §5.2, stages 1–4) into
- * a single `DetectedReviewAxes` result. The onboard prose flow
- * (`.onto/processes/onboard.md`) invokes this via `npm run onboard:detect-review-axes`
- * and uses the printed JSON as the input to the subsequent interactive
- * questions (stages 5–7).
- *
- * # Why it exists
- *
- * Onboard is prose-driven: the LLM session reads `.onto/processes/onboard.md` and
- * executes each stage textually. Stages 1–4 are purely automatic environment
- * probes, so pulling them into a single deterministic TS entry point keeps
- * the prose stage short ("run this script and read the JSON") and avoids
- * duplicating env-var + binary checks in natural-language instructions. The
- * detection logic itself is reused from
- * `src/core-runtime/discovery/host-detection.ts` — this module is a thin
- * projection into the P4 axis vocabulary (host, agent_teams_available,
- * codex_available).
- *
- * # How it relates
- *
- * - Inputs: process.env (read via the detection helpers from discovery/).
- * - Output: pure data (`DetectedReviewAxes`) — onboard prose renders it and
- *   asks the user axis-by-axis questions.
- * - Write-back seat: `write-review-block.ts` (sibling module).
- * - Consumed by: `.onto/processes/onboard.md` §§ 3.7/3.8 (added in P4).
- */
-import { detectClaudeCodeEnvSignal, detectCodexBinaryAvailable, detectCodexEnvSignal, } from "../discovery/host-detection.js";
-// ---------------------------------------------------------------------------
-// Core detection
-// ---------------------------------------------------------------------------
-const ENV_AGENT_TEAMS = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS";
-/**
- * Map the discovery-layer env signals into the onboard host vocabulary.
- *
- * Priority: Claude Code > Codex CLI > plain terminal. Same ordering as
- * `detectHostRuntime` but projected into the simpler three-value domain.
- * Claude Code takes precedence because an inner Codex process inside a
- * Claude Code session still reports CLAUDECODE=1 — in that case the onboard
- * context is the Claude Code session, and codex availability is surfaced
- * separately as a subagent option.
- */
-function detectHost() {
-    if (detectClaudeCodeEnvSignal())
-        return "claude-code";
-    if (detectCodexEnvSignal())
-        return "codex-cli";
-    return "plain-terminal";
-}
-/**
- * Detect the four review axes observable from environment alone.
- *
- * Pure w.r.t. process.env — no file writes, no network. Deterministic given
- * the same env snapshot + filesystem state (codex binary + auth.json).
- */
-export function detectReviewAxes() {
-    const host = detectHost();
-    // Exact-match against `"1"` to stay consistent with the resolver's strict
-    // check (`execution-topology-resolver.ts:506`). A loose `Boolean(...)` here
-    // would disagree with the resolver when the user sets the variable to
-    // `"0"` / `"false"` / `""`. Both layers must read the same signal the
-    // same way so the onboard UX promise survives the runtime.
-    const agent_teams_available = process.env[ENV_AGENT_TEAMS] === "1";
-    const codex_available = detectCodexBinaryAvailable();
-    return {
-        detected: {
-            host,
-            agent_teams_available,
-            codex_available,
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// CLI entry — `npm run onboard:detect-review-axes`
-// ---------------------------------------------------------------------------
-function isMainModule() {
-    // tsx executes this module directly; the ESM equivalent of
-    // `require.main === module` is comparing import.meta.url to argv[1].
-    const entry = process.argv[1];
-    if (typeof entry !== "string" || entry.length === 0)
-        return false;
-    try {
-        const entryUrl = new URL(`file://${entry}`).href;
-        return import.meta.url === entryUrl;
-    }
-    catch {
-        return false;
-    }
-}
-function printHelp() {
-    const lines = [
-        "onboard:detect-review-axes",
-        "",
-        "Detects the environmental axes consumed by the onboard prose flow:",
-        "  - host            (claude-code | codex-cli | plain-terminal)",
-        "  - agent_teams     (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1)",
-        "  - codex_available (codex on PATH + ~/.codex/auth.json)",
-        "",
-        "Usage:",
-        "  npm run onboard:detect-review-axes",
-        "  npm run onboard:detect-review-axes -- --help",
-        "",
-        "Output: single-line JSON { detected: { ... } } on stdout.",
-    ];
-    console.log(lines.join("\n"));
-}
-if (isMainModule()) {
-    const argv = process.argv.slice(2);
-    if (argv.includes("--help") || argv.includes("-h")) {
-        printHelp();
-        process.exit(0);
-    }
-    const result = detectReviewAxes();
-    // Compact single-line JSON so the prose caller can forward it as-is into
-    // the LLM context without re-parsing.
-    console.log(JSON.stringify(result));
-}

package/dist/core-runtime/onboard/detect-review-axes.test.js

@@ -1,127 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { detectReviewAxes } from "./detect-review-axes.js";
-// ---------------------------------------------------------------------------
-// detectReviewAxes — Review UX Redesign P4 (2026-04-21)
-// ---------------------------------------------------------------------------
-//
-// These tests exercise the projection of env signals into the onboard
-// axis vocabulary. The underlying detection helpers (from discovery/) are
-// covered by their own suite; here we only verify:
-//
-//   (1) Host priority ordering — Claude Code > Codex CLI > plain.
-//   (2) agent_teams_available reads CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS.
-//   (3) litellm_endpoint returns the URL string (not just a boolean).
-//   (4) codex_available is sourced from the shared discovery helper.
-//
-// The codex binary / auth.json probe is filesystem-backed, so we mock
-// `detectCodexBinaryAvailable` from the discovery module to keep the tests
-// hermetic.
-// ---------------------------------------------------------------------------
-vi.mock("../discovery/host-detection.js", async (importOriginal) => {
-    const actual = (await importOriginal());
-    return {
-        ...actual,
-        // Override only the filesystem-dependent probe. The env-signal helpers
-        // remain real so we can control behaviour via process.env.
-        detectCodexBinaryAvailable: vi.fn(() => false),
-    };
-});
-const savedEnv = {};
-const VOLATILE_ENV_KEYS = [
-    "CLAUDECODE",
-    "CLAUDE_PROJECT_DIR",
-    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
-    "CODEX_THREAD_ID",
-    "CODEX_CI",
-    "LITELLM_BASE_URL",
-];
-beforeEach(() => {
-    for (const key of VOLATILE_ENV_KEYS) {
-        savedEnv[key] = process.env[key];
-        delete process.env[key];
-    }
-});
-afterEach(() => {
-    for (const key of VOLATILE_ENV_KEYS) {
-        const original = savedEnv[key];
-        if (original === undefined) {
-            delete process.env[key];
-        }
-        else {
-            process.env[key] = original;
-        }
-    }
-    vi.resetAllMocks();
-});
-describe("detectReviewAxes — host category", () => {
-    it("returns plain-terminal when no host signal is present", () => {
-        const result = detectReviewAxes();
-        expect(result.detected.host).toBe("plain-terminal");
-    });
-    it("returns claude-code when CLAUDECODE=1", () => {
-        process.env.CLAUDECODE = "1";
-        expect(detectReviewAxes().detected.host).toBe("claude-code");
-    });
-    it("returns claude-code when CLAUDE_PROJECT_DIR is set", () => {
-        process.env.CLAUDE_PROJECT_DIR = "/tmp/proj";
-        expect(detectReviewAxes().detected.host).toBe("claude-code");
-    });
-    it("returns codex-cli when CODEX_THREAD_ID is set", () => {
-        process.env.CODEX_THREAD_ID = "thr-123";
-        expect(detectReviewAxes().detected.host).toBe("codex-cli");
-    });
-    it("prefers claude-code over codex-cli when both signals are present", () => {
-        // An inner Codex exec inside a Claude Code session — onboard context
-        // is Claude Code; codex availability is surfaced separately.
-        process.env.CLAUDECODE = "1";
-        process.env.CODEX_THREAD_ID = "thr-123";
-        expect(detectReviewAxes().detected.host).toBe("claude-code");
-    });
-});
-describe("detectReviewAxes — agent_teams_available (strict =1)", () => {
-    // The resolver uses `env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === "1"`.
-    // Onboard MUST use the same check so the two layers never disagree on
-    // whether teams are available — otherwise onboard writes a config the
-    // runtime silently rejects (P3 would degrade it, violating the UX
-    // promise that "what onboard accepts is what runs").
-    it("is false when env var is absent", () => {
-        expect(detectReviewAxes().detected.agent_teams_available).toBe(false);
-    });
-    it('is true only when CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === "1"', () => {
-        process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
-        expect(detectReviewAxes().detected.agent_teams_available).toBe(true);
-    });
-    it('is false for truthy-looking strings that are not "1"', () => {
-        // These would pass a naive Boolean() check but must NOT activate teams.
-        // The resolver rejects them; onboard must match.
-        for (const value of ["true", "yes", "on", "enabled", "TRUE", "2"]) {
-            process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = value;
-            expect(detectReviewAxes().detected.agent_teams_available).toBe(false);
-        }
-    });
-    it('is false for falsy-looking strings ("0", "false", empty)', () => {
-        for (const value of ["0", "false", ""]) {
-            process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = value;
-            expect(detectReviewAxes().detected.agent_teams_available).toBe(false);
-        }
-    });
-});
-describe("detectReviewAxes — litellm_endpoint", () => {
-    it("is null when LITELLM_BASE_URL is unset", () => {
-        expect(detectReviewAxes().detected.litellm_endpoint).toBeNull();
-    });
-    it("returns the URL string when LITELLM_BASE_URL is set", () => {
-        process.env.LITELLM_BASE_URL = "http://localhost:4000";
-        expect(detectReviewAxes().detected.litellm_endpoint).toBe("http://localhost:4000");
-    });
-});
-describe("detectReviewAxes — codex_available", () => {
-    it("surfaces the discovery helper verdict (mocked false by default)", async () => {
-        const mod = await import("../discovery/host-detection.js");
-        const spy = vi.mocked(mod.detectCodexBinaryAvailable);
-        spy.mockReturnValue(false);
-        expect(detectReviewAxes().detected.codex_available).toBe(false);
-        spy.mockReturnValue(true);
-        expect(detectReviewAxes().detected.codex_available).toBe(true);
-    });
-});

package/dist/core-runtime/onboard/write-review-block.js

@@ -1,188 +0,0 @@
-/**
- * Review UX Redesign P4 — write/update the `review:` block in `.onto/config.yml`.
- *
- * # What this module is
- *
- * A small helper that takes a validated `OntoReviewConfig` plus a path to
- * an `.onto/config.yml` file and either (a) adds a `review:` block to the
- * file or (b) replaces an existing one.
- *
- * # Why it exists
- *
- * Onboard stage 7 (design doc §5.2) writes the user's chosen review axes
- * into `.onto/config.yml`. Without a dedicated seat this would require the
- * prose to embed YAML serialization instructions, which is error-prone — a
- * stray indent produces a silently invalid config. Centralizing the write
- * path means the onboard prose can describe the intent ("record the user's
- * answers in the review block") and delegate formatting to this helper.
- *
- * We use `yaml`'s `parseDocument` / `Document` API (not `parse` +
- * `stringify`) because the document round-trip preserves comments and
- * formatting where the existing file has them. That matters for configs
- * authored by humans — they often annotate fields with rationale.
- *
- * # How it relates
- *
- * - Consumes: `OntoReviewConfig` type from `discovery/config-chain.ts`.
- * - Validates with: `validateReviewConfig` from
- *   `review/review-config-validator.ts` — we re-validate to catch caller
- *   errors early (the onboard prose is a weak integrator).
- * - Exposed via: `npm run onboard:write-review-block -- <path> <json>`.
- *
- * # Guarantees
- *
- * 1. Existing top-level fields are preserved in order.
- * 2. Comments attached to preserved fields survive the round-trip.
- * 3. If the file does not exist, it is created with a minimal document
- *    containing only the `review:` block.
- * 4. If the input is not a valid `OntoReviewConfig`, the function returns a
- *    result object with `ok: false` and no write is performed.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { Document, parseDocument } from "yaml";
-import { validateReviewConfig, } from "../review/review-config-validator.js";
-/**
- * Write (or update) the `review:` block in the given config file.
- *
- * The function re-validates `review` with `validateReviewConfig` before
- * touching the file — if validation fails, nothing is written and the
- * caller receives the structured error list.
- */
-export function writeReviewBlock(configPath, review) {
-    // Re-validate. The type system alone cannot catch callers who constructed
-    // the object manually from JSON input (the most common P4 path — the
-    // onboard prose builds the object from interactive answers).
-    const validation = validateReviewConfig(review);
-    if (!validation.ok) {
-        return { ok: false, errors: validation.errors };
-    }
-    const absolute = path.resolve(configPath);
-    const exists = fs.existsSync(absolute);
-    // Load the existing document (or a fresh empty one). `parseDocument`
-    // returns a `Document` node the YAML library can mutate and re-serialize
-    // while preserving source formatting where practical.
-    let doc;
-    if (exists) {
-        const raw = fs.readFileSync(absolute, "utf8");
-        doc = parseDocument(raw, { keepSourceTokens: false });
-    }
-    else {
-        // Ensure the parent directory exists — `.onto/` may not be present on
-        // a brand-new project until onboard creates it.
-        fs.mkdirSync(path.dirname(absolute), { recursive: true });
-        doc = new Document({});
-    }
-    // Detect the prior state of the document so we can report it back to the
-    // onboard prose (for the user-facing summary).
-    const replacedExistingBlock = exists && doc.has("review");
-    // The yaml library accepts a plain object for `set` — it converts that
-    // into the internal Node graph. We filter out undefined leaves so the
-    // output does not carry `key: null` artifacts for absent axes.
-    const serializable = pruneUndefined(review);
-    doc.set("review", serializable);
-    const serialized = doc.toString();
-    fs.writeFileSync(absolute, serialized, "utf8");
-    return {
-        ok: true,
-        path: absolute,
-        created: !exists,
-        replacedExistingBlock,
-    };
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-/**
- * Strip `undefined` leaves from a nested object. The `yaml` library would
- * otherwise serialize them as `null`, which is semantically different from
- * "absent" in the review block (an absent key = use review defaults).
- */
-function pruneUndefined(input) {
-    if (input === null || input === undefined)
-        return input;
-    if (Array.isArray(input)) {
-        return input.map((v) => pruneUndefined(v));
-    }
-    if (typeof input !== "object")
-        return input;
-    const out = {};
-    for (const [key, value] of Object.entries(input)) {
-        if (value === undefined)
-            continue;
-        out[key] = pruneUndefined(value);
-    }
-    return out;
-}
-// ---------------------------------------------------------------------------
-// CLI entry — `npm run onboard:write-review-block -- <path> <json>`
-// ---------------------------------------------------------------------------
-function printHelp() {
-    const lines = [
-        "onboard:write-review-block",
-        "",
-        "Write or update the `review:` block in a .onto/config.yml file.",
-        "",
-        "Usage:",
-        "  npm run onboard:write-review-block -- <config-path> <review-json>",
-        "  npm run onboard:write-review-block -- --help",
-        "",
-        "Arguments:",
-        "  <config-path>  Path to .onto/config.yml (created if missing).",
-        "  <review-json>  JSON string representing an OntoReviewConfig.",
-        "",
-        "Example:",
-        "  npm run onboard:write-review-block -- .onto/config.yml \\",
-        "    '{\"teamlead\":{\"model\":\"main\"},\"subagent\":{\"provider\":\"main-native\"}}'",
-        "",
-        "Output: single-line JSON describing the write result on stdout.",
-        "Exit code 0 on success, 1 on validation/IO failure.",
-    ];
-    console.log(lines.join("\n"));
-}
-function isMainModule() {
-    const entry = process.argv[1];
-    if (typeof entry !== "string" || entry.length === 0)
-        return false;
-    try {
-        const entryUrl = new URL(`file://${entry}`).href;
-        return import.meta.url === entryUrl;
-    }
-    catch {
-        return false;
-    }
-}
-function runCli(argv) {
-    if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
-        printHelp();
-        return argv.length === 0 ? 1 : 0;
-    }
-    const unsupportedFlags = argv.filter((a) => a.startsWith("--"));
-    if (unsupportedFlags.length > 0) {
-        console.error(`error: unsupported option(s): ${unsupportedFlags.join(", ")}`);
-        return 1;
-    }
-    const positional = argv.filter((a) => !a.startsWith("--"));
-    if (positional.length < 2) {
-        console.error("error: two positional arguments required: <config-path> <review-json>. " +
-            "Run with --help for usage.");
-        return 1;
-    }
-    const [configPath, reviewJson] = positional;
-    let parsed;
-    try {
-        parsed = JSON.parse(reviewJson);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`error: <review-json> is not valid JSON: ${message}`);
-        return 1;
-    }
-    const result = writeReviewBlock(configPath, parsed);
-    console.log(JSON.stringify(result));
-    return result.ok ? 0 : 1;
-}
-if (isMainModule()) {
-    const exitCode = runCli(process.argv.slice(2));
-    process.exit(exitCode);
-}