@lsctech/polaris 0.1.0

package/dist/cli/init-detect.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRepoState = detectRepoState;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const SOURCE_ROOT_HINTS = ["src", "lib", "app", "packages", "services", "server", "client"];
+const DOC_ROOT_HINTS = [
+    "docs",
+    "doc",
+    "wiki",
+    "adr",
+    "rfcs",
+    "architecture",
+    "design",
+    "spec",
+    "specs",
+    "guides",
+];
+const AGENT_INSTRUCTION_FILES = ["AGENTS.md", "CLAUDE.md", "POLARIS.md", "SUMMARY.md"];
+function safeReadDir(repoRoot) {
+    try {
+        return (0, node_fs_1.readdirSync)(repoRoot);
+    }
+    catch {
+        return [];
+    }
+}
+function hasAny(entries, values) {
+    return entries.some((entry) => values.includes(entry));
+}
+function hasPolarisConfig(repoRoot) {
+    return (0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "polaris.config.json"));
+}
+function hasFileRoutes(repoRoot) {
+    return (0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, ".polaris", "map", "file-routes.json"));
+}
+function detectRepoState(repoRoot) {
+    const topLevelEntries = safeReadDir(repoRoot);
+    const meaningfulEntries = topLevelEntries.filter((entry) => entry !== ".git");
+    if (meaningfulEntries.length === 0) {
+        return "empty";
+    }
+    const configExists = hasPolarisConfig(repoRoot);
+    const fileRoutesExists = hasFileRoutes(repoRoot);
+    if (configExists && fileRoutesExists) {
+        return "polaris-enabled";
+    }
+    if (configExists) {
+        return "partial";
+    }
+    const hasSourceRoots = hasAny(topLevelEntries, SOURCE_ROOT_HINTS);
+    const hasDocsRoots = hasAny(topLevelEntries, DOC_ROOT_HINTS);
+    const hasAgentInstructionFiles = hasAny(topLevelEntries, AGENT_INSTRUCTION_FILES);
+    if (hasSourceRoots || hasDocsRoots || hasAgentInstructionFiles) {
+        return "existing";
+    }
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "package.json")) || hasSourceRoots) {
+        return "new";
+    }
+    return "existing";
+}

package/dist/cli/init.js

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRepoState = void 0;
+exports.runAdoptionAtlas = runAdoptionAtlas;
+exports.finalizeAdoption = finalizeAdoption;
+exports.runInit = runInit;
+exports.createInitCommand = createInitCommand;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const commander_1 = require("commander");
+const init_detect_js_1 = require("./init-detect.js");
+const provider_detect_js_1 = require("../config/provider-detect.js");
+const adoption_plan_js_1 = require("./adoption-plan.js");
+const adopt_approve_js_1 = require("./adopt-approve.js");
+const adopt_scan_js_1 = require("./adopt-scan.js");
+const adopt_cognition_js_1 = require("./adopt-cognition.js");
+const adopt_smartdocs_js_1 = require("./adopt-smartdocs.js");
+const index_js_1 = require("../map/index.js");
+const adopt_instructions_js_1 = require("./adopt-instructions.js");
+const artifact_policy_js_1 = require("../finalize/artifact-policy.js");
+var init_detect_js_2 = require("./init-detect.js");
+Object.defineProperty(exports, "detectRepoState", { enumerable: true, get: function () { return init_detect_js_2.detectRepoState; } });
+const PLAN_COMPLETE_STATUSES = new Set(["completed", "skipped"]);
+const ADOPTION_LOCKED_EXECUTION = {
+    rotation: [],
+    allowCrossAgentFallback: false,
+    adapter: "terminal-cli",
+};
+const ADOPTION_LOCKED_ORCHESTRATION = {
+    mode: "supervised",
+};
+function applySmartDocsMigration(repoRoot, inventory) {
+    let moved = 0;
+    let skipped = 0;
+    for (const candidate of inventory.smartdocs_candidates) {
+        const sourcePath = (0, node_path_1.join)(repoRoot, candidate.path);
+        const destinationPath = (0, node_path_1.join)(repoRoot, candidate.suggested_destination);
+        if (!(0, node_fs_1.existsSync)(sourcePath) || (0, node_fs_1.existsSync)(destinationPath)) {
+            skipped += 1;
+            continue;
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destinationPath), { recursive: true });
+        (0, node_fs_1.renameSync)(sourcePath, destinationPath);
+        moved += 1;
+    }
+    return { moved, skipped };
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function isAdoptionConfigLocked(existing) {
+    const execution = asRecord(existing.execution);
+    const orchestration = asRecord(existing.orchestration);
+    return (Array.isArray(execution.rotation) &&
+        execution.rotation.length === 0 &&
+        execution.allowCrossAgentFallback === false &&
+        execution.adapter === ADOPTION_LOCKED_EXECUTION.adapter &&
+        orchestration.mode === ADOPTION_LOCKED_ORCHESTRATION.mode);
+}
+function buildInitConfig(existing, detected, detectedRepoAnalysis, adopt) {
+    const existingProviders = asRecord(existing.providers);
+    const updatedProviders = { ...existingProviders };
+    if (detected.length > 0) {
+        updatedProviders.compactionProviders = detected;
+    }
+    else {
+        delete updatedProviders.compactionProviders;
+    }
+    const existingRepoAnalysis = asRecord(existingProviders.repoAnalysis);
+    const updatedRepoAnalysis = detectedRepoAnalysis.length > 0
+        ? { ...existingRepoAnalysis, preferred: detectedRepoAnalysis[0] }
+        : Object.fromEntries(Object.entries(existingRepoAnalysis).filter(([key]) => key !== "preferred"));
+    const updated = {
+        ...existing,
+        version: typeof existing.version === "string" ? existing.version : "1.0",
+    };
+    if (adopt) {
+        const existingExecution = asRecord(existing.execution);
+        updated.execution = {
+            ...existingExecution,
+            ...ADOPTION_LOCKED_EXECUTION,
+        };
+        const existingOrchestration = asRecord(existing.orchestration);
+        updated.orchestration = {
+            ...existingOrchestration,
+            ...ADOPTION_LOCKED_ORCHESTRATION,
+        };
+    }
+    if (Object.keys(updatedProviders).length > 0) {
+        updated.providers = updatedProviders;
+    }
+    else if ("providers" in updated && Object.keys(updatedProviders).length === 0 && detected.length === 0) {
+        delete updated.providers;
+    }
+    if (Object.keys(updatedRepoAnalysis).length > 0) {
+        updatedProviders.repoAnalysis = updatedRepoAnalysis;
+        updated.providers = updatedProviders;
+    }
+    else if (updated.providers) {
+        const providers = asRecord(updated.providers);
+        delete providers.repoAnalysis;
+        if (Object.keys(providers).length > 0) {
+            updated.providers = providers;
+        }
+        else {
+            delete updated.providers;
+        }
+    }
+    return updated;
+}
+function writeAdoptionConfigLock(repoRoot, configPath, existing, detected, detectedRepoAnalysis) {
+    if (isAdoptionConfigLocked(existing)) {
+        process.stdout.write("Provider config already locked — skipping.\n");
+        return false;
+    }
+    const updated = buildInitConfig(existing, detected, detectedRepoAnalysis, true);
+    (0, node_fs_1.writeFileSync)(configPath, `${JSON.stringify(updated, null, 2)}\n`, "utf-8");
+    process.stdout.write(`polaris.config.json written to ${configPath}\n`);
+    return true;
+}
+function areAllPlanStepsComplete(plan) {
+    return plan.steps.length > 0 && plan.steps.every((step) => PLAN_COMPLETE_STATUSES.has(step.status));
+}
+function loadAdoptionPlanArtifacts(repoRoot) {
+    const jsonPath = (0, node_path_1.join)(repoRoot, ".polaris", "adoption-plan.json");
+    const markdownPath = (0, node_path_1.join)(repoRoot, ".polaris", "adoption-plan.md");
+    if (!(0, node_fs_1.existsSync)(jsonPath)) {
+        return null;
+    }
+    try {
+        const json = (0, node_fs_1.readFileSync)(jsonPath, "utf-8");
+        const plan = JSON.parse(json);
+        const markdown = (0, node_fs_1.existsSync)(markdownPath)
+            ? (0, node_fs_1.readFileSync)(markdownPath, "utf-8")
+            : (0, adoption_plan_js_1.renderAdoptionPlanMarkdown)(plan);
+        return {
+            plan,
+            json,
+            markdown,
+            jsonPath,
+            markdownPath,
+            wroteFiles: false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function ensureRuntimeArtifactExclusions(repoRoot) {
+    const gitignorePath = (0, node_path_1.join)(repoRoot, ".gitignore");
+    const existing = (0, node_fs_1.existsSync)(gitignorePath) ? (0, node_fs_1.readFileSync)(gitignorePath, "utf-8") : "";
+    const lines = existing.split(/\r?\n/);
+    const ignoreBlock = (0, artifact_policy_js_1.formatGitignoreBlock)();
+    const required = ignoreBlock.split("\n");
+    const missing = !required.every((line) => lines.includes(line));
+    if (!missing) {
+        return;
+    }
+    const trimmed = existing.trimEnd();
+    const separator = trimmed.length > 0 ? "\n\n" : "";
+    const next = `${trimmed}${separator}${ignoreBlock}\n`;
+    (0, node_fs_1.writeFileSync)(gitignorePath, next, "utf-8");
+}
+function readBaselineCoverage(repoRoot) {
+    const mapIndexPath = (0, node_path_1.join)(repoRoot, ".polaris", "map", "index.json");
+    if (!(0, node_fs_1.existsSync)(mapIndexPath)) {
+        return "n/a";
+    }
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(mapIndexPath, "utf-8"));
+        const baseline = parsed.adoption_baseline_coverage_pct;
+        if (typeof baseline === "number") {
+            return `${baseline}%`;
+        }
+        const coverage = parsed.coverage_pct;
+        if (typeof coverage === "number") {
+            return `${coverage}%`;
+        }
+    }
+    catch {
+        return "n/a";
+    }
+    return "n/a";
+}
+function runAdoptionAtlas(plan, repoRoot = (0, node_path_1.resolve)(process.cwd())) {
+    if (!plan.steps.some((step) => step.category === "atlas-generate")) {
+        return Promise.resolve();
+    }
+    try {
+        (0, index_js_1.runMapIndex)(repoRoot, false, false, { seedCognition: false, skipThreshold: true });
+        const mapDir = (0, node_path_1.join)(repoRoot, ".polaris", "map");
+        const indexPath = (0, node_path_1.join)(mapDir, "index.json");
+        if (!(0, node_fs_1.existsSync)(indexPath)) {
+            throw new Error("Adoption atlas generation did not produce .polaris/map/index.json");
+        }
+        const atlasIndex = asRecord(JSON.parse((0, node_fs_1.readFileSync)(indexPath, "utf-8")));
+        const entries = asRecord(atlasIndex.entries);
+        const hasSmartDocsRawEntry = Object.keys(entries).some((filePath) => filePath.startsWith("smartdocs/raw/"));
+        if (!hasSmartDocsRawEntry) {
+            throw new Error("Adoption atlas validation failed: no smartdocs/raw/ entries found in atlas");
+        }
+        const needsReviewPath = (0, node_path_1.join)(mapDir, "needs-review.json");
+        const needsReviewEntries = (0, node_fs_1.existsSync)(needsReviewPath)
+            ? asRecord(JSON.parse((0, node_fs_1.readFileSync)(needsReviewPath, "utf-8")))
+            : {};
+        const totalFiles = typeof atlasIndex.file_count === "number"
+            ? atlasIndex.file_count
+            : Object.keys(entries).length;
+        const needsReviewCount = Object.keys(needsReviewEntries).length;
+        const needsReviewPct = totalFiles > 0 ? (needsReviewCount / totalFiles) * 100 : 0;
+        if (needsReviewPct > 20) {
+            process.stdout.write(`[WARN] Adoption atlas needs-review debt is ${needsReviewPct.toFixed(1)}% (${needsReviewCount}/${totalFiles}); continuing.\n`);
+        }
+        const baselineCoverage = typeof atlasIndex.coverage_pct === "number" ? atlasIndex.coverage_pct : 0;
+        (0, node_fs_1.writeFileSync)(indexPath, `${JSON.stringify({
+            ...atlasIndex,
+            adoption_baseline_coverage_pct: baselineCoverage,
+        }, null, 2)}\n`, "utf-8");
+        return Promise.resolve();
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+}
+function updatePlanForFinalization(repoRoot, plan, now) {
+    const completedAt = now.toISOString();
+    const updatedPlan = {
+        ...plan,
+        approved: true,
+        approved_at: plan.approved_at ?? completedAt,
+        steps: plan.steps.map((step) => PLAN_COMPLETE_STATUSES.has(step.status)
+            ? step
+            : {
+                ...step,
+                status: "completed",
+                completed_at: completedAt,
+                error: undefined,
+            }),
+    };
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".polaris", "adoption-plan.json"), `${JSON.stringify(updatedPlan, null, 2)}\n`, "utf-8");
+    return updatedPlan;
+}
+function stageAdoptionOutputs(repoRoot, plan) {
+    const stagePaths = new Set([
+        ".polaris/adoption-plan.json",
+        ".polaris/adoption-inventory.json",
+        ".polaris/adoption-provenance.json",
+        "polaris.config.json",
+        ".polaris/map",
+        "POLARIS.md",
+        "SUMMARY.md",
+        ".gitignore",
+    ]);
+    for (const step of plan.steps) {
+        if (step.source_path) {
+            stagePaths.add(step.source_path);
+        }
+        if (step.dest_path) {
+            stagePaths.add(step.dest_path);
+        }
+    }
+    const existingPaths = [...stagePaths].filter((p) => (0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, p)));
+    if (existingPaths.length > 0) {
+        (0, node_child_process_1.execFileSync)("git", ["add", "-A", "--", ...existingPaths], { cwd: repoRoot, stdio: "pipe" });
+    }
+}
+function unstageRuntimeArtifacts(repoRoot) {
+    const stagedPaths = (0, node_child_process_1.execFileSync)("git", ["diff", "--cached", "--name-only"], {
+        cwd: repoRoot,
+        encoding: "utf-8",
+    })
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const blocked = stagedPaths.filter((path) => (0, artifact_policy_js_1.isPathBlockedFromStaging)(path));
+    if (blocked.length === 0) {
+        return;
+    }
+    (0, node_child_process_1.execFileSync)("git", ["restore", "--staged", "--", ...blocked], { cwd: repoRoot, stdio: "pipe" });
+}
+function createAdoptionCommitMessage(plan) {
+    const moved = plan.impact_summary.smartdocs_candidates_moved;
+    const cognition = plan.impact_summary.cognition_files_to_generate;
+    return `chore: adopt Polaris init — ${moved} files moved, ${cognition} cognition files generated`;
+}
+function printAdoptionSummary(repoRoot, plan) {
+    const baselineCoverage = readBaselineCoverage(repoRoot);
+    process.stdout.write(`Adoption summary: moved=${plan.impact_summary.smartdocs_candidates_moved}, cognition=${plan.impact_summary.cognition_files_to_generate}, instruction_files=${plan.impact_summary.instruction_files_affected}, baseline_coverage=${baselineCoverage}\n`);
+}
+function finalizeAdoption(plan, options = {}) {
+    if (areAllPlanStepsComplete(plan)) {
+        process.stdout.write("Adoption already complete.\n");
+        return Promise.resolve();
+    }
+    const repoRoot = options.repoRoot ?? (0, node_path_1.resolve)(process.cwd());
+    ensureRuntimeArtifactExclusions(repoRoot);
+    return runAdoptionAtlas(plan, repoRoot).then(() => {
+        const updatedPlan = updatePlanForFinalization(repoRoot, plan, options.now ?? new Date());
+        stageAdoptionOutputs(repoRoot, updatedPlan);
+        unstageRuntimeArtifacts(repoRoot);
+        printAdoptionSummary(repoRoot, updatedPlan);
+        if (options.commit) {
+            const message = options.commitMessage ?? createAdoptionCommitMessage(updatedPlan);
+            (0, node_child_process_1.execFileSync)("git", ["commit", "-m", message], { cwd: repoRoot, stdio: "pipe" });
+            process.stdout.write(`Adoption commit created: ${message}\n`);
+        }
+        else {
+            process.stdout.write("Adoption changes staged. Review with `git diff --cached` and commit when ready.\n");
+        }
+    });
+}
+/**
+ * Generates (or updates) `polaris.config.json` in the repo root.
+ *
+ * Compaction provider detection:
+ *   - Caveman: detected when `.polaris/skills/caveman/SKILL.md` is present (falls back to `.codex/skills/caveman/SKILL.md`).
+ *   - GitNexus: detected when `gitnexus` is on PATH.
+ *
+ * The `providers.compactionProviders` field is written only when at least
+ * one provider is detected; it is omitted entirely otherwise.
+ *
+ * Repo-analysis provider detection writes `providers.repoAnalysis.preferred`
+ * only when an external provider is detected.
+ */
+async function runInit(options = {}) {
+    const repoRoot = options.repoRoot ?? (0, node_path_1.resolve)(process.cwd());
+    const configPath = (0, node_path_1.join)(repoRoot, "polaris.config.json");
+    const detectCompaction = options.detectProviders ?? provider_detect_js_1.detectCompactionProviders;
+    const detectRepoAnalysis = options.detectRepoAnalysisProviders ?? provider_detect_js_1.detectRepoAnalysisProviders;
+    const repoState = (options.detectRepoState ?? init_detect_js_1.detectRepoState)(repoRoot);
+    if (options.status) {
+        process.stdout.write(`Repository state: ${repoState}\n`);
+        return;
+    }
+    if (!options.adopt && repoState === "existing") {
+        process.stdout.write("This repo has existing content. Run `polaris init --adopt` to begin adoption.\nThis repo has existing content. Run polaris init --adopt to begin adoption.\n");
+        return;
+    }
+    // Load existing config (if any) so we preserve user-authored fields.
+    let existing = {};
+    if ((0, node_fs_1.existsSync)(configPath)) {
+        try {
+            existing = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+        }
+        catch {
+            // Malformed JSON — start fresh rather than aborting.
+            existing = {};
+        }
+    }
+    const detected = detectCompaction(repoRoot);
+    const detectedRepoAnalysis = detectRepoAnalysis(repoRoot);
+    const updated = buildInitConfig(existing, detected, detectedRepoAnalysis, Boolean(options.adopt));
+    if (options.dryRun && !options.adopt) {
+        process.stdout.write(`${JSON.stringify(updated, null, 2)}\n`);
+        return;
+    }
+    if (options.adopt) {
+        if (!options.dryRun) {
+            writeAdoptionConfigLock(repoRoot, configPath, existing, detected, detectedRepoAnalysis);
+        }
+    }
+    else {
+        (0, node_fs_1.writeFileSync)(configPath, `${JSON.stringify(updated, null, 2)}\n`, "utf-8");
+        const providerSummary = detected.length > 0
+            ? `Detected providers: ${detected.join(", ")}`
+            : "No compaction providers detected";
+        process.stdout.write(`polaris.config.json written to ${configPath}\n${providerSummary}\n`);
+    }
+    if (!options.adopt) {
+        return;
+    }
+    const adoptionPlanPath = (0, node_path_1.join)(repoRoot, ".polaris", "adoption-plan.json");
+    if ((0, node_fs_1.existsSync)(adoptionPlanPath)) {
+        try {
+            const existingPlan = JSON.parse((0, node_fs_1.readFileSync)(adoptionPlanPath, "utf-8"));
+            if (areAllPlanStepsComplete(existingPlan)) {
+                process.stdout.write("Adoption already complete.\n");
+                return;
+            }
+        }
+        catch {
+            // Fall through and regenerate adoption artifacts.
+        }
+    }
+    const now = options.now ?? new Date();
+    const scanAdoptionInventory = options.scanAdoptionInventory ??
+        ((root) => (0, adopt_scan_js_1.scanRepo)(root, { now, rescan: options.rescan }));
+    const inventoryResult = scanAdoptionInventory(repoRoot);
+    let inventory;
+    if (inventoryResult && typeof inventoryResult.then === "function") {
+        inventory = await inventoryResult;
+    }
+    else {
+        inventory = inventoryResult;
+    }
+    const loadedArtifacts = options.resume ? loadAdoptionPlanArtifacts(repoRoot) : null;
+    const adoptionArtifacts = loadedArtifacts ?? (options.generateAdoptionArtifacts ?? adoption_plan_js_1.generateAdoptionPlanArtifacts)(repoRoot, inventory, { dryRun: options.dryRun, now });
+    if (options.dryRun) {
+        process.stdout.write(`${adoptionArtifacts.markdown}\n`);
+        process.stdout.write("Adoption dry run: Phase C writes skipped.\n");
+        return;
+    }
+    let approved = false;
+    if (options.yes) {
+        process.stdout.write(`${adoptionArtifacts.markdown}\n`);
+        (0, adopt_approve_js_1.persistApprovedAdoptionPlan)(adoptionArtifacts.plan, repoRoot, now);
+        (0, adopt_approve_js_1.logAdoptionApprovalTelemetry)(repoRoot, {
+            event: "adoption-approval-bypassed",
+            run_mode: "yes",
+            plan_id: adoptionArtifacts.plan.plan_id,
+            timestamp: now.toISOString(),
+        });
+        process.stdout.write("Adoption approval bypassed via --yes.\n");
+        approved = true;
+    }
+    else if (options.resume && adoptionArtifacts.plan.approved) {
+        process.stdout.write(`${adoptionArtifacts.markdown}\n`);
+        if (!adoptionArtifacts.plan.approved_at) {
+            (0, adopt_approve_js_1.persistApprovedAdoptionPlan)(adoptionArtifacts.plan, repoRoot, now);
+        }
+        approved = true;
+    }
+    else if (options.readAdoptionApproval) {
+        process.stdout.write(`${adoptionArtifacts.markdown}\n`);
+        approved = options.readAdoptionApproval();
+        if (approved) {
+            (0, adopt_approve_js_1.persistApprovedAdoptionPlan)(adoptionArtifacts.plan, repoRoot, now);
+        }
+        else {
+            process.stdout.write("Adoption aborted: explicit approval required.\n");
+            return;
+        }
+    }
+    else {
+        approved = await (0, adopt_approve_js_1.promptApproval)(adoptionArtifacts.plan, { repoRoot, now });
+        if (!approved) {
+            return;
+        }
+    }
+    const smartDocsMigrationSteps = adoptionArtifacts.plan.steps.filter((step) => step.category === "smartdocs-migrate");
+    if (smartDocsMigrationSteps.length > 0) {
+        (0, adopt_smartdocs_js_1.migrateSmartDocs)(adoptionArtifacts.plan, repoRoot);
+        const moved = adoptionArtifacts.plan.steps.filter((step) => step.category === "smartdocs-migrate" && step.status === "completed").length;
+        const skipped = adoptionArtifacts.plan.steps.filter((step) => step.category === "smartdocs-migrate" && step.status === "skipped").length;
+        process.stdout.write(`SmartDocs migration step completed: moved ${moved}, skipped ${skipped}.\n`);
+    }
+    else {
+        const migrationResult = (options.applySmartDocsMigration ?? applySmartDocsMigration)(repoRoot, inventory);
+        process.stdout.write(`SmartDocs migration step completed: moved ${migrationResult.moved}, skipped ${migrationResult.skipped}.\n`);
+    }
+    void (options.generateFolderCognition ?? adopt_cognition_js_1.generateFolderCognition)(adoptionArtifacts.plan, inventory);
+    process.stdout.write("Folder cognition generation step completed.\n");
+    (0, adopt_instructions_js_1.handleInstructionFiles)(adoptionArtifacts.plan, inventory);
+    process.stdout.write("Instruction file handling step completed.\n");
+    if (adoptionArtifacts.plan.steps.some((step) => step.category === "stage")) {
+        finalizeAdoption(adoptionArtifacts.plan, {
+            repoRoot,
+            commit: options.commit,
+            now,
+        });
+        return;
+    }
+    process.stdout.write("Adoption approved. Proceeding with mutation phases.\n");
+}
+/**
+ * Registers the `init` subcommand on a Commander program.
+ */
+function createInitCommand(options = {}) {
+    const cmd = new commander_1.Command("init")
+        .description("initialise polaris.config.json and detect compaction providers")
+        .option("--dry-run", "print generated config to stdout without writing")
+        .option("--status", "detect and print current repository state without writing files")
+        .option("--adopt", "run existing repository adoption flow")
+        .option("--resume", "resume an approved adoption plan without prompting")
+        .option("--yes", "auto-approve adoption plan when used with --adopt")
+        .option("--commit", "create an adoption commit when used with --adopt")
+        .action(async (cmdOptions) => {
+        await runInit({
+            ...options,
+            dryRun: cmdOptions.dryRun,
+            status: cmdOptions.status,
+            adopt: cmdOptions.adopt,
+            resume: cmdOptions.resume,
+            yes: cmdOptions.yes,
+            commit: cmdOptions.commit,
+        });
+    });
+    return cmd;
+}