@lsctech/polaris 0.1.0

package/dist/cli/init.test.js

@@ -0,0 +1,259 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("node:fs"));
+const node_path_1 = require("node:path");
+const init_js_1 = require("./init.js");
+vitest_1.vi.mock("node:fs", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        existsSync: vitest_1.vi.fn(),
+        readFileSync: vitest_1.vi.fn(),
+        writeFileSync: vitest_1.vi.fn(),
+    };
+});
+const mockedExistsSync = vitest_1.vi.mocked(fs.existsSync);
+const mockedReadFileSync = vitest_1.vi.mocked(fs.readFileSync);
+const mockedWriteFileSync = vitest_1.vi.mocked(fs.writeFileSync);
+let stdoutOutput = "";
+const originalWrite = process.stdout.write.bind(process.stdout);
+(0, vitest_1.beforeEach)(() => {
+    vitest_1.vi.resetAllMocks();
+    stdoutOutput = "";
+    vitest_1.vi.spyOn(process.stdout, "write").mockImplementation((data) => {
+        stdoutOutput += String(data);
+        return true;
+    });
+});
+(0, vitest_1.afterEach)(() => {
+    vitest_1.vi.restoreAllMocks();
+});
+const REPO_ROOT = "/fake-repo";
+const CONFIG_PATH = (0, node_path_1.join)(REPO_ROOT, "polaris.config.json");
+(0, vitest_1.describe)("runInit — no existing config", () => {
+    (0, vitest_1.it)("writes a new config with compactionProviders when providers are detected", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const detect = vitest_1.vi.fn().mockReturnValue(["caveman"]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        (0, vitest_1.expect)(mockedWriteFileSync).toHaveBeenCalledOnce();
+        const [path, content] = mockedWriteFileSync.mock.calls[0];
+        (0, vitest_1.expect)(path).toBe(CONFIG_PATH);
+        const written = JSON.parse(content);
+        (0, vitest_1.expect)(written).toMatchObject({
+            version: "1.0",
+            providers: { compactionProviders: ["caveman"] },
+        });
+    });
+    (0, vitest_1.it)("writes config WITHOUT compactionProviders when no providers detected", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const detect = vitest_1.vi.fn().mockReturnValue([]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        (0, vitest_1.expect)(mockedWriteFileSync).toHaveBeenCalledOnce();
+        const [, content] = mockedWriteFileSync.mock.calls[0];
+        const written = JSON.parse(content);
+        (0, vitest_1.expect)(written).not.toHaveProperty("providers.compactionProviders");
+    });
+    (0, vitest_1.it)("includes both caveman and gitnexus when both detected", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const detect = vitest_1.vi.fn().mockReturnValue(["caveman", "gitnexus"]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        const [, content] = mockedWriteFileSync.mock.calls[0];
+        const written = JSON.parse(content);
+        (0, vitest_1.expect)(written.providers.compactionProviders).toEqual([
+            "caveman",
+            "gitnexus",
+        ]);
+    });
+    (0, vitest_1.it)("writes repoAnalysis.preferred when a repo-analysis provider is detected", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const detectCompaction = vitest_1.vi.fn().mockReturnValue([]);
+        const detectRepoAnalysis = vitest_1.vi.fn().mockReturnValue(["gitnexus"]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detectCompaction,
+            detectRepoAnalysisProviders: detectRepoAnalysis,
+        });
+        const [, content] = mockedWriteFileSync.mock.calls[0];
+        const written = JSON.parse(content);
+        (0, vitest_1.expect)(written).toMatchObject({
+            providers: { repoAnalysis: { preferred: "gitnexus" } },
+        });
+    });
+});
+(0, vitest_1.describe)("runInit — existing config", () => {
+    (0, vitest_1.it)("preserves existing fields when merging", () => {
+        const existingConfig = {
+            version: "1.0",
+            repo: { name: "my-repo" },
+        };
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue(JSON.stringify(existingConfig));
+        const detect = vitest_1.vi.fn().mockReturnValue(["gitnexus"]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        const [, content] = mockedWriteFileSync.mock.calls[0];
+        const written = JSON.parse(content);
+        (0, vitest_1.expect)(written).toMatchObject({
+            version: "1.0",
+            repo: { name: "my-repo" },
+            providers: { compactionProviders: ["gitnexus"] },
+        });
+    });
+    (0, vitest_1.it)("preserves existing providers.repoAnalysis while adding compactionProviders", () => {
+        const existingConfig = {
+            version: "1.0",
+            providers: { repoAnalysis: { preferred: "polaris-map" } },
+        };
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue(JSON.stringify(existingConfig));
+        const detect = vitest_1.vi.fn().mockReturnValue(["caveman"]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue(["gitnexus"]),
+        });
+        const [, content] = mockedWriteFileSync.mock.calls[0];
+        const written = JSON.parse(content);
+        const providers = written.providers;
+        (0, vitest_1.expect)(providers.repoAnalysis).toEqual({ preferred: "gitnexus" });
+        (0, vitest_1.expect)(providers.compactionProviders).toEqual(["caveman"]);
+    });
+    (0, vitest_1.it)("preserves repoAnalysis fallback while omitting preferred when no repo-analysis provider is detected", () => {
+        const existingConfig = {
+            version: "1.0",
+            providers: {
+                repoAnalysis: { preferred: "gitnexus", fallback: ["polaris-map", "ripgrep"] },
+            },
+        };
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue(JSON.stringify(existingConfig));
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: vitest_1.vi.fn().mockReturnValue([]),
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        const [, content] = mockedWriteFileSync.mock.calls[0];
+        const written = JSON.parse(content);
+        const providers = written.providers;
+        (0, vitest_1.expect)(providers.repoAnalysis).toEqual({ fallback: ["polaris-map", "ripgrep"] });
+    });
+    (0, vitest_1.it)("removes compactionProviders from existing config when none detected", () => {
+        const existingConfig = {
+            version: "1.0",
+            providers: { compactionProviders: ["caveman"] },
+        };
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue(JSON.stringify(existingConfig));
+        const detect = vitest_1.vi.fn().mockReturnValue([]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        const [, content] = mockedWriteFileSync.mock.calls[0];
+        const written = JSON.parse(content);
+        // providers key may be absent or present but without compactionProviders
+        if ("providers" in written && written.providers !== undefined) {
+            (0, vitest_1.expect)(written.providers).not.toHaveProperty("compactionProviders");
+        }
+    });
+});
+(0, vitest_1.describe)("runInit — dry-run", () => {
+    (0, vitest_1.it)("does not write the file in dry-run mode", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const detect = vitest_1.vi.fn().mockReturnValue(["caveman"]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            dryRun: true,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        (0, vitest_1.expect)(mockedWriteFileSync).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("prints the JSON to stdout in dry-run mode", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const detect = vitest_1.vi.fn().mockReturnValue(["caveman"]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            dryRun: true,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        const parsed = JSON.parse(stdoutOutput);
+        (0, vitest_1.expect)(parsed).toMatchObject({
+            providers: { compactionProviders: ["caveman"] },
+        });
+    });
+});
+(0, vitest_1.describe)("runInit — stdout messaging", () => {
+    (0, vitest_1.it)("prints detected providers in success message", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const detect = vitest_1.vi.fn().mockReturnValue(["caveman", "gitnexus"]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        (0, vitest_1.expect)(stdoutOutput).toContain("caveman");
+        (0, vitest_1.expect)(stdoutOutput).toContain("gitnexus");
+    });
+    (0, vitest_1.it)("reports no providers when none detected", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const detect = vitest_1.vi.fn().mockReturnValue([]);
+        (0, init_js_1.runInit)({
+            repoRoot: REPO_ROOT,
+            detectProviders: detect,
+            detectRepoAnalysisProviders: vitest_1.vi.fn().mockReturnValue([]),
+        });
+        (0, vitest_1.expect)(stdoutOutput).toContain("No compaction providers detected");
+    });
+});

package/dist/cli/librarian.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLibrarianCommand = createLibrarianCommand;
+const commander_1 = require("commander");
+const node_path_1 = require("node:path");
+const librarian_packet_js_1 = require("../cognition/librarian-packet.js");
+function createLibrarianCommand(options = {}) {
+    const repoRootDefault = options.repoRoot ?? (0, node_path_1.resolve)(process.cwd());
+    const librarian = new commander_1.Command("librarian")
+        .description("Closeout Librarian tools")
+        .showHelpAfterError()
+        .showSuggestionAfterError();
+    librarian
+        .command("packet <cluster-id>")
+        .description("generate Closeout Librarian packet for a completed cluster")
+        .option("-r, --repo-root <path>", "Repository root", repoRootDefault)
+        .option("--state-file <path>", "Path to current-state.json (canonical path preferred)")
+        .action((clusterId, cmdOptions) => {
+        try {
+            (0, librarian_packet_js_1.generateLibrarianPacket)({
+                repoRoot: cmdOptions.repoRoot,
+                clusterId,
+                stateFile: cmdOptions.stateFile,
+            });
+        }
+        catch (err) {
+            process.stderr.write(`librarian packet error: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    });
+    return librarian;
+}

package/dist/cli/medic.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMedicCommand = createMedicCommand;
+const commander_1 = require("commander");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const chart_id_js_1 = require("../medic/chart-id.js");
+function createMedicCommand(options = {}) {
+    const repoRootDefault = options.repoRoot ?? (0, node_path_1.resolve)(process.cwd());
+    const medic = new commander_1.Command("medic")
+        .description("Medic role tools")
+        .showHelpAfterError()
+        .showSuggestionAfterError();
+    medic
+        .command("chart")
+        .description("Chart management commands")
+        .addCommand(new commander_1.Command("create")
+        .description("Scaffold a new chart with a valid Chart ID")
+        .option("-r, --repo-root <path>", "Repository root", repoRootDefault)
+        .option("--cluster-id <id>", "Cluster ID for this chart", "UNKNOWN")
+        .option("--route <path>", "Route path for this chart", "UNKNOWN")
+        .option("--status <status>", "Chart status", "draft")
+        .action((cmdOptions) => {
+        try {
+            createChart({
+                repoRoot: cmdOptions.repoRoot,
+                clusterId: cmdOptions.clusterId,
+                route: cmdOptions.route,
+                status: cmdOptions.status,
+            });
+        }
+        catch (err) {
+            process.stderr.write(`medic chart create error: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }));
+    return medic;
+}
+function createChart(options) {
+    const { repoRoot, clusterId, route, status } = options;
+    // Ensure charts directory exists
+    const chartsDir = (0, node_path_1.resolve)(repoRoot, "smartdocs/medic/charts");
+    (0, node_fs_1.mkdirSync)(chartsDir, { recursive: true });
+    // Generate next Chart ID
+    const chartId = (0, chart_id_js_1.generateNextChartId)(chartsDir);
+    // Get current timestamp
+    const now = new Date().toISOString();
+    // Create chart content
+    const chartContent = `---
+chart_id: ${chartId.full}
+cluster_id: ${clusterId}
+route: ${route}
+status: ${status}
+related_charts: []
+created: ${now}
+updated: ${now}
+---
+
+## Problem
+
+Describe the problem diagnosed by the Medic.
+
+## Symptoms
+
+List the symptoms that led to this diagnosis.
+
+## Root Cause
+
+Explain the root cause of the failure.
+
+## Affected Files
+
+List the files affected by this issue.
+
+## Treatment
+
+Describe the treatment applied to fix the issue.
+
+## Validation
+
+Describe how the fix was validated.
+
+## Prevention
+
+Describe how to prevent this issue from recurring.
+
+## When To Read This Chart
+
+Describe the conditions under which this chart should be retrieved.
+`;
+    // Write chart file
+    const chartPath = (0, node_path_1.resolve)(chartsDir, `${chartId.full}.md`);
+    (0, node_fs_1.writeFileSync)(chartPath, chartContent, "utf-8");
+    process.stdout.write(`Created chart: ${chartPath}\n`);
+    process.stdout.write(`Chart ID: ${chartId.full}\n`);
+}

package/dist/cli/startup.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)("CLI startup", () => {
+    (0, vitest_1.it)("config show does not import @tool-server/linear", async () => {
+        vitest_1.vi.resetModules();
+        const importedToolServer = vitest_1.vi.fn();
+        vitest_1.vi.doMock("@tool-server/linear", () => {
+            importedToolServer();
+            throw new Error("unexpected @tool-server/linear import");
+        });
+        const { createPolarisCommand } = await import("./index.js");
+        const runConfigShow = vitest_1.vi.fn();
+        const program = createPolarisCommand({
+            repoRoot: "/repo",
+            runConfigShow,
+        });
+        await (0, vitest_1.expect)(program.parseAsync(["node", "polaris", "config", "show"], { from: "node" })).resolves.toBeDefined();
+        (0, vitest_1.expect)(runConfigShow).toHaveBeenCalledWith({ repoRoot: "/repo" });
+        (0, vitest_1.expect)(importedToolServer).not.toHaveBeenCalled();
+        vitest_1.vi.doUnmock("@tool-server/linear");
+    });
+});

package/dist/cli/tracker.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrackerCommand = createTrackerCommand;
+const commander_1 = require("commander");
+const node_path_1 = require("node:path");
+const local_graph_js_1 = require("../tracker/local-graph.js");
+const index_js_1 = require("../tracker/sync/index.js");
+const index_js_2 = require("../tracker/adapters/linear/index.js");
+const loader_js_1 = require("../config/loader.js");
+function createTrackerCommand(options) {
+    const trackerCommand = new commander_1.Command('tracker')
+        .description('Manage tracker synchronization and reconciliation');
+    trackerCommand
+        .command('sync-in [trackerId]')
+        .description('Synchronize data from a tracker into the local graph.')
+        .option('--adapter <adapterName>', 'Specify the tracker adapter to use (e.g., linear, mcp-bridge)')
+        .option('-r, --repo-root <path>', 'Repository root', options.repoRoot)
+        .action(async (trackerId, commandOptions) => {
+        const repoRoot = (0, node_path_1.resolve)(commandOptions.repoRoot ?? options.repoRoot);
+        const config = (0, loader_js_1.loadConfig)(repoRoot);
+        const adapterName = commandOptions.adapter ?? config.tracker?.adapter ?? 'linear';
+        if (!trackerId) {
+            console.error("Error: trackerId is required (e.g., 'polaris tracker sync-in POL-198').");
+            process.exit(1);
+        }
+        console.log(`Executing 'tracker sync-in' for tracker: ${trackerId} using adapter: ${adapterName}`);
+        if (adapterName === 'linear') {
+            // LinearAdapter is a pull-only sync-in adapter — use it directly
+            const adapter = new index_js_2.LinearAdapter(config);
+            let graph;
+            try {
+                graph = await adapter.syncIn(trackerId);
+            }
+            catch (err) {
+                console.error(`sync-in failed: ${err instanceof Error ? err.message : String(err)}`);
+                process.exit(1);
+            }
+            let writtenPath;
+            try {
+                writtenPath = await graph.save(trackerId, repoRoot);
+            }
+            catch (err) {
+                console.error(`sync-in: failed to persist graph: ${err instanceof Error ? err.message : String(err)}`);
+                process.exit(1);
+            }
+            console.log(`sync-in complete. Active cluster: ${graph.fullGraph.activeCluster}`);
+            console.log(`Written: ${writtenPath}`);
+            return;
+        }
+        if (adapterName === 'mcp-bridge') {
+            let localGraph;
+            try {
+                localGraph = await local_graph_js_1.LocalGraph.load(trackerId, repoRoot);
+            }
+            catch (err) {
+                console.error(`Failed to load local graph for cluster '${trackerId}': ${err instanceof Error ? err.message : String(err)}`);
+                process.exit(1);
+            }
+            const { McpBridgeAdapter } = await import('../tracker/adapters/mcp-bridge.js');
+            const adapter = new McpBridgeAdapter();
+            const service = new index_js_1.TrackerSyncService(adapter, localGraph, {
+                repoRoot,
+                clusterId: trackerId,
+            });
+            await service.ready;
+            const report = await service.syncIn({ trackerId });
+            console.log('Sync-in Report:', report);
+            // Persist graph state changes
+            let writtenPath;
+            try {
+                writtenPath = await localGraph.save(trackerId, repoRoot);
+            }
+            catch (err) {
+                console.error(`sync-in: failed to persist graph: ${err instanceof Error ? err.message : String(err)}`);
+                process.exit(1);
+            }
+            console.log(`Graph persisted: ${writtenPath}`);
+            return;
+        }
+        console.error(`Unknown adapter: ${adapterName}`);
+        process.exit(1);
+    });
+    trackerCommand
+        .command('reconcile <trackerId>')
+        .description('Reconcile local mutations with the remote tracker.')
+        .option('--dry-run', 'Perform a dry run without applying changes to the remote tracker.')
+        .option('--adapter <adapterName>', 'Specify the tracker adapter to use (e.g., mcp-bridge)')
+        .option('-r, --repo-root <path>', 'Repository root', options.repoRoot)
+        .action(async (trackerId, commandOptions) => {
+        const repoRoot = (0, node_path_1.resolve)(commandOptions.repoRoot ?? options.repoRoot);
+        const config = (0, loader_js_1.loadConfig)(repoRoot);
+        const adapterName = commandOptions.adapter ?? config.tracker?.adapter ?? 'mcp-bridge';
+        if (adapterName === 'linear') {
+            console.error("The 'linear' adapter is sync-in only and does not support reconciliation. Use 'mcp-bridge' for reconciliation.");
+            process.exit(1);
+        }
+        else if (adapterName !== 'mcp-bridge') {
+            console.error(`Unknown adapter: ${adapterName}`);
+            process.exit(1);
+        }
+        console.log(`Executing 'tracker reconcile' for cluster '${trackerId}' (dryRun: ${commandOptions.dryRun}) using adapter: ${adapterName}`);
+        let localGraph;
+        try {
+            localGraph = await local_graph_js_1.LocalGraph.load(trackerId, repoRoot);
+        }
+        catch (err) {
+            console.error(`Failed to load local graph for cluster '${trackerId}': ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+        const { McpBridgeAdapter } = await import('../tracker/adapters/mcp-bridge.js');
+        const adapter = new McpBridgeAdapter();
+        const service = new index_js_1.TrackerSyncService(adapter, localGraph, {
+            repoRoot,
+            clusterId: trackerId,
+        });
+        await service.ready;
+        const report = await service.reconcile(commandOptions.dryRun);
+        console.log('Reconciliation Report:', report);
+        // Persist graph state changes after reconciliation
+        try {
+            const writtenPath = await localGraph.save(trackerId, repoRoot);
+            console.log(`Graph persisted: ${writtenPath}`);
+        }
+        catch (err) {
+            console.error(`reconcile: failed to persist graph: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
+    return trackerCommand;
+}

package/dist/cli/tracker.test.js

@@ -0,0 +1,126 @@
+"use strict";
+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_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const tracker_js_1 = require("./tracker.js");
+const local_graph_js_1 = require("../tracker/local-graph.js");
+const linearModule = __importStar(require("../tracker/adapters/linear/index.js"));
+const configLoader = __importStar(require("../config/loader.js"));
+(0, vitest_1.describe)("tracker CLI", () => {
+    (0, vitest_1.it)("sync-in without trackerId exits with a clear usage error", async () => {
+        const command = (0, tracker_js_1.createTrackerCommand)({ repoRoot: "/repo" });
+        const errorSpy = vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+        const exitSpy = vitest_1.vi.spyOn(process, "exit").mockImplementation(((code) => {
+            throw new Error(`process.exit:${code}`);
+        }));
+        try {
+            await (0, vitest_1.expect)(command.parseAsync(["node", "tracker", "sync-in"], { from: "node" })).rejects.toThrow("process.exit:1");
+            (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith("Error: trackerId is required (e.g., 'polaris tracker sync-in POL-198').");
+        }
+        finally {
+            exitSpy.mockRestore();
+            errorSpy.mockRestore();
+        }
+    });
+    (0, vitest_1.describe)("sync-in persistence", () => {
+        let tmpDir;
+        let consoleSpy;
+        let consoleLogSpy;
+        (0, vitest_1.beforeEach)(async () => {
+            tmpDir = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), "polaris-test-"));
+            consoleSpy = vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+            consoleLogSpy = vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+        });
+        (0, vitest_1.afterEach)(async () => {
+            consoleSpy.mockRestore();
+            consoleLogSpy.mockRestore();
+            await (0, promises_1.rm)(tmpDir, { recursive: true, force: true });
+            vitest_1.vi.restoreAllMocks();
+        });
+        (0, vitest_1.it)("tracker sync-in POL-198 writes .polaris/clusters/POL-198/clusters.json", async () => {
+            const fakeGraph = {
+                schemaVersion: "v2",
+                source: { id: "POL-198", type: "Linear" },
+                nodes: {
+                    "POL-198": { id: "POL-198", title: "Root issue", status: "Todo" },
+                },
+                dependencies: {},
+                clusters: {
+                    "POL-198": { id: "POL-198", title: "Linear Issue: POL-198", children: ["POL-198"] },
+                },
+                activeCluster: "POL-198",
+            };
+            const fakeLocalGraph = local_graph_js_1.LocalGraph.fromGraph(fakeGraph);
+            vitest_1.vi.spyOn(linearModule.LinearAdapter.prototype, "syncIn").mockResolvedValue(fakeLocalGraph);
+            vitest_1.vi.spyOn(configLoader, "loadConfig").mockReturnValue({ tracker: { adapter: "linear", linear: { enabled: true } } });
+            const command = (0, tracker_js_1.createTrackerCommand)({ repoRoot: tmpDir });
+            await command.parseAsync(["node", "tracker", "sync-in", "POL-198"], { from: "node" });
+            const expectedPath = node_path_1.default.join(tmpDir, ".polaris", "clusters", "POL-198", "clusters.json");
+            const contents = await (0, promises_1.readFile)(expectedPath, "utf-8");
+            const parsed = JSON.parse(contents);
+            (0, vitest_1.expect)(parsed.schemaVersion).toBe("v2");
+            (0, vitest_1.expect)(parsed.activeCluster).toBe("POL-198");
+            (0, vitest_1.expect)(parsed.nodes["POL-198"]).toEqual({ id: "POL-198", title: "Root issue", status: "Todo" });
+            (0, vitest_1.expect)(consoleLogSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("sync-in complete. Active cluster: POL-198"));
+            (0, vitest_1.expect)(consoleLogSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining(expectedPath));
+        });
+        (0, vitest_1.it)("tracker sync-in creates the cluster directory if it does not exist", async () => {
+            const fakeGraph = {
+                schemaVersion: "v2",
+                source: { id: "POL-999", type: "Linear" },
+                nodes: {},
+                dependencies: {},
+                clusters: {
+                    "POL-999": { id: "POL-999", title: "Linear Issue: POL-999", children: [] },
+                },
+                activeCluster: "POL-999",
+            };
+            const fakeLocalGraph = local_graph_js_1.LocalGraph.fromGraph(fakeGraph);
+            vitest_1.vi.spyOn(linearModule.LinearAdapter.prototype, "syncIn").mockResolvedValue(fakeLocalGraph);
+            vitest_1.vi.spyOn(configLoader, "loadConfig").mockReturnValue({ tracker: { adapter: "linear", linear: { enabled: true } } });
+            const command = (0, tracker_js_1.createTrackerCommand)({ repoRoot: tmpDir });
+            await command.parseAsync(["node", "tracker", "sync-in", "POL-999"], { from: "node" });
+            const expectedPath = node_path_1.default.join(tmpDir, ".polaris", "clusters", "POL-999", "clusters.json");
+            const contents = await (0, promises_1.readFile)(expectedPath, "utf-8");
+            (0, vitest_1.expect)(JSON.parse(contents).schemaVersion).toBe("v2");
+        });
+    });
+});