@lsctech/polaris 0.1.0

package/dist/cli/adoption-inventory.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanAdoptionInventory = scanAdoptionInventory;
+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 GENERATED_ROOT_HINTS = ["dist", "build", "coverage", ".next", ".nuxt", "out", "generated"];
+const CACHE_ROOT_HINTS = [".cache", ".turbo", ".parcel-cache", ".vite", "tmp", ".tmp"];
+const FIXTURE_ROOT_HINTS = ["fixtures", "__fixtures__", "__mocks__", "test/data", "tests/data"];
+const SKIP_TRAVERSAL = new Set([".git", "node_modules"]);
+function toPosix(path) {
+    return path.replaceAll("\\", "/");
+}
+function withTrailingSlash(path) {
+    return path.endsWith("/") ? path : `${path}/`;
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort();
+}
+function safeRead(path) {
+    try {
+        return (0, node_fs_1.readFileSync)(path, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+function detectPackageManager(repoRoot) {
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "pnpm-lock.yaml")))
+        return "pnpm";
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "yarn.lock")))
+        return "yarn";
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "bun.lockb")) || (0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "bun.lock")))
+        return "bun";
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "package-lock.json")) || (0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "npm-shrinkwrap.json"))) {
+        return "npm";
+    }
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "package.json")))
+        return "npm";
+    return null;
+}
+function detectRepoState(repoRoot, topLevelEntries) {
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, ".polaris"))) {
+        return "polaris-enabled";
+    }
+    const meaningfulEntries = topLevelEntries.filter((entry) => entry.path !== ".git" && entry.path !== ".gitignore");
+    if (meaningfulEntries.length === 0) {
+        return "empty";
+    }
+    const hasManifest = ["package.json", "pyproject.toml", "go.mod", "Cargo.toml"].some((file) => (0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, file)));
+    const hasSourceRoots = topLevelEntries.some((entry) => SOURCE_ROOT_HINTS.includes(entry.path));
+    const hasDocsRoots = topLevelEntries.some((entry) => DOC_ROOT_HINTS.includes(entry.path));
+    if (hasManifest && !hasSourceRoots && !hasDocsRoots) {
+        return "new";
+    }
+    if (!hasManifest && (hasSourceRoots || hasDocsRoots)) {
+        return "partial";
+    }
+    return "existing";
+}
+function walkRepository(repoRoot, relativeDir = "") {
+    const currentDir = (0, node_path_1.join)(repoRoot, relativeDir);
+    let names = [];
+    try {
+        names = (0, node_fs_1.readdirSync)(currentDir);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const name of names) {
+        const relPath = relativeDir ? `${relativeDir}/${name}` : name;
+        const absPath = (0, node_path_1.join)(repoRoot, relPath);
+        let stat;
+        try {
+            stat = (0, node_fs_1.statSync)(absPath);
+        }
+        catch {
+            continue;
+        }
+        const normalizedPath = toPosix(relPath);
+        const repoEntry = {
+            path: normalizedPath,
+            isDirectory: stat.isDirectory(),
+            sizeBytes: stat.size,
+        };
+        entries.push(repoEntry);
+        if (repoEntry.isDirectory && !SKIP_TRAVERSAL.has(name)) {
+            entries.push(...walkRepository(repoRoot, normalizedPath));
+        }
+    }
+    return entries;
+}
+function detectRoots(entries, hints) {
+    const roots = entries
+        .filter((entry) => entry.isDirectory)
+        .map((entry) => entry.path)
+        .filter((path) => hints.some((hint) => path === hint || path.includes(`/${hint}/`) || path.endsWith(`/${hint}`)))
+        .map(withTrailingSlash);
+    return uniqueSorted(roots);
+}
+function parsePackageScripts(repoRoot) {
+    const packageJsonPath = (0, node_path_1.join)(repoRoot, "package.json");
+    if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf-8"));
+        if (!parsed.scripts || typeof parsed.scripts !== "object" || Array.isArray(parsed.scripts)) {
+            return {};
+        }
+        return Object.fromEntries(Object.entries(parsed.scripts).filter(([, value]) => typeof value === "string"));
+    }
+    catch {
+        return {};
+    }
+}
+function buildScriptCommands(scripts, mode) {
+    const matchers = mode === "test"
+        ? [/^test$/i, /test/i, /e2e/i, /integration/i]
+        : [/^build$/i, /build/i, /compile/i, /typecheck/i];
+    const commands = [];
+    for (const scriptName of Object.keys(scripts)) {
+        if (!matchers.some((matcher) => matcher.test(scriptName))) {
+            continue;
+        }
+        if (scriptName === "test") {
+            commands.push("npm test");
+        }
+        else {
+            commands.push(`npm run ${scriptName}`);
+        }
+    }
+    return uniqueSorted(commands);
+}
+const INSTRUCTION_PATTERNS = [
+    {
+        matcher: (entry) => entry.path === "CLAUDE.md",
+        provider: "claude",
+    },
+    {
+        matcher: (entry) => entry.path === "AGENTS.md",
+        provider: "openai",
+    },
+    {
+        matcher: (entry) => entry.path === ".github/copilot-instructions.md",
+        provider: "copilot",
+    },
+    {
+        matcher: (entry) => entry.path === ".cursorrules" || entry.path.startsWith(".cursor/rules/"),
+        provider: "cursor",
+    },
+    {
+        matcher: (entry) => entry.path === ".aider.conf.yml" || entry.path === "AIDER.md",
+        provider: "aider",
+    },
+    {
+        matcher: (entry) => (0, node_path_1.basename)(entry.path) === "GEMINI.md",
+        provider: "gemini",
+    },
+];
+function recommendationForInstruction(hasDelegation, doctrineExists, sizeBytes) {
+    if (hasDelegation) {
+        return {
+            recommendation: "preserve",
+            reason: "Already delegates to Polaris doctrine.",
+        };
+    }
+    if (!doctrineExists) {
+        return {
+            recommendation: "preserve",
+            reason: "No POLARIS.md doctrine detected yet.",
+        };
+    }
+    if (sizeBytes < 500) {
+        return {
+            recommendation: "thin-adapter",
+            reason: "Short generic instruction file; convert to thin adapter.",
+        };
+    }
+    return {
+        recommendation: "migrate",
+        reason: "Substantive instruction file should be preserved in SmartDocs raw migration.",
+    };
+}
+function detectAgentInstructionFiles(repoRoot, entries, doctrineExists) {
+    return entries
+        .filter((entry) => !entry.isDirectory)
+        .map((entry) => {
+        const matched = INSTRUCTION_PATTERNS.find((pattern) => pattern.matcher(entry));
+        if (!matched) {
+            return null;
+        }
+        const content = safeRead((0, node_path_1.join)(repoRoot, entry.path));
+        const hasPolarisDelegation = content.includes("<!-- polaris:delegate") || content.toLowerCase().includes("polaris.md");
+        const recommendation = recommendationForInstruction(hasPolarisDelegation, doctrineExists, entry.sizeBytes);
+        return {
+            path: entry.path,
+            provider: matched.provider,
+            size_bytes: entry.sizeBytes,
+            has_polaris_delegation: hasPolarisDelegation,
+            recommendation: recommendation.recommendation,
+            reason: recommendation.reason,
+        };
+    })
+        .filter((entry) => entry !== null)
+        .sort((a, b) => a.path.localeCompare(b.path));
+}
+function classifyDocKind(path) {
+    const lowered = path.toLowerCase();
+    if (lowered.includes("spec"))
+        return "spec";
+    if (lowered.includes("adr") || lowered.includes("decision"))
+        return "decision";
+    if (lowered.includes("arch") || lowered.includes("design"))
+        return "architecture";
+    if (lowered.includes("integration"))
+        return "integration";
+    if (lowered.includes("doc") || lowered.endsWith(".md") || lowered.endsWith(".mdx"))
+        return "doc";
+    return "unknown";
+}
+function shouldSkipDoc(path) {
+    const lowered = path.toLowerCase();
+    const filename = (0, node_path_1.basename)(lowered);
+    if (lowered.startsWith("smartdocs/") ||
+        lowered.startsWith("node_modules/") ||
+        lowered.startsWith(".git/") ||
+        lowered.startsWith("dist/") ||
+        lowered.startsWith("build/") ||
+        lowered.startsWith("coverage/") ||
+        lowered.startsWith(".next/") ||
+        lowered.startsWith(".nuxt/") ||
+        lowered.startsWith("out/") ||
+        lowered.startsWith("generated/") ||
+        lowered.startsWith(".cache/") ||
+        lowered.startsWith(".turbo/") ||
+        lowered.startsWith("fixtures/") ||
+        lowered.includes("/fixtures/") ||
+        lowered.includes("/__fixtures__/") ||
+        lowered.includes("/test/data/") ||
+        lowered.includes("/tests/data/")) {
+        return true;
+    }
+    if (filename === "agents.md" ||
+        filename === "claude.md" ||
+        filename === "gemini.md" ||
+        filename === "aider.md" ||
+        lowered === ".github/copilot-instructions.md") {
+        return true;
+    }
+    return ["README.md", "CHANGELOG.md", "LICENSE", "CONTRIBUTING.md"].includes(path);
+}
+function detectSmartDocsCandidates(repoRoot, entries) {
+    const docs = entries
+        .filter((entry) => !entry.isDirectory)
+        .filter((entry) => entry.path.endsWith(".md") || entry.path.endsWith(".mdx"))
+        .filter((entry) => entry.sizeBytes > 100)
+        .filter((entry) => !shouldSkipDoc(entry.path))
+        .map((entry) => {
+        const content = safeRead((0, node_path_1.join)(repoRoot, entry.path));
+        const filename = (0, node_path_1.basename)(entry.path);
+        const hasFrontmatter = content.startsWith("---\n") || content.startsWith("---\r\n");
+        const kind = classifyDocKind(entry.path);
+        const estimatedRisk = kind === "architecture" || kind === "decision" ? "medium" : "low";
+        return {
+            path: entry.path,
+            kind,
+            suggested_destination: `smartdocs/raw/${filename}`,
+            confidence: hasFrontmatter ? 0.95 : 0.7,
+            has_frontmatter: hasFrontmatter,
+            estimated_risk: estimatedRisk,
+        };
+    });
+    return docs.sort((a, b) => a.path.localeCompare(b.path));
+}
+function detectArchitectureNotes(entries) {
+    return uniqueSorted(entries
+        .filter((entry) => !entry.isDirectory)
+        .filter((entry) => entry.path.endsWith(".md") || entry.path.endsWith(".mdx"))
+        .map((entry) => entry.path)
+        .filter((path) => {
+        const lowered = path.toLowerCase();
+        return (lowered.includes("adr") || lowered.includes("rfc") || lowered.includes("architecture") || lowered.includes("design"));
+    }));
+}
+function detectExistingSmartDocsDirs(entries) {
+    return uniqueSorted(entries
+        .filter((entry) => entry.isDirectory)
+        .map((entry) => entry.path)
+        .filter((path) => path === "smartdocs" || path.startsWith("smartdocs/"))
+        .map(withTrailingSlash));
+}
+function detectLikelyCanonicalFolders(sourceRoots, docsRoots) {
+    const folders = [...sourceRoots, ...docsRoots]
+        .map((path) => path.slice(0, -1))
+        .filter((path) => path !== "smartdocs" && !path.includes("fixtures"));
+    return uniqueSorted(folders);
+}
+function detectIgnoreCandidates(generatedRoots, cacheRoots) {
+    return uniqueSorted([...generatedRoots, ...cacheRoots, ".taskchain_artifacts/"]);
+}
+function scanAdoptionInventory(repoRoot, options = {}) {
+    const now = options.now ?? new Date();
+    const allEntries = walkRepository(repoRoot);
+    const topLevelEntries = allEntries.filter((entry) => !entry.path.includes("/"));
+    const packageScripts = parsePackageScripts(repoRoot);
+    const sourceRoots = detectRoots(topLevelEntries, SOURCE_ROOT_HINTS);
+    const docsRoots = detectRoots(topLevelEntries, DOC_ROOT_HINTS);
+    const generatedRoots = detectRoots(allEntries, GENERATED_ROOT_HINTS);
+    const cacheRoots = detectRoots(allEntries, CACHE_ROOT_HINTS);
+    const fixtureRoots = detectRoots(allEntries, FIXTURE_ROOT_HINTS);
+    const doctrineExists = (0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "POLARIS.md"));
+    const inventory = {
+        scan_date: now.toISOString(),
+        repo_state: detectRepoState(repoRoot, topLevelEntries),
+        package_manager: detectPackageManager(repoRoot),
+        source_roots: sourceRoots,
+        docs_roots: docsRoots,
+        test_commands: buildScriptCommands(packageScripts, "test"),
+        build_commands: buildScriptCommands(packageScripts, "build"),
+        package_scripts: packageScripts,
+        generated_roots: generatedRoots,
+        cache_roots: cacheRoots,
+        fixture_roots: fixtureRoots,
+        agent_instruction_files: detectAgentInstructionFiles(repoRoot, allEntries, doctrineExists),
+        existing_smartdocs_dirs: detectExistingSmartDocsDirs(allEntries),
+        architecture_notes: detectArchitectureNotes(allEntries),
+        likely_canonical_folders: detectLikelyCanonicalFolders(sourceRoots, docsRoots),
+        smartdocs_candidates: detectSmartDocsCandidates(repoRoot, allEntries),
+        ignore_candidates: detectIgnoreCandidates(generatedRoots, cacheRoots),
+    };
+    if (options.writeArtifact ?? true) {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, ".polaris"), { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".polaris", "adoption-inventory.json"), `${JSON.stringify(inventory, null, 2)}\n`, "utf-8");
+    }
+    return inventory;
+}

package/dist/cli/adoption-plan.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAdoptionPlan = generateAdoptionPlan;
+exports.renderAdoptionPlanMarkdown = renderAdoptionPlanMarkdown;
+exports.generateAdoptionPlanArtifacts = generateAdoptionPlanArtifacts;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function formatPlanId(isoTimestamp) {
+    return `adoption-${isoTimestamp.replaceAll(":", "-")}`;
+}
+function normalizePath(path) {
+    return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function createStep(order, partial) {
+    return {
+        ...partial,
+        order,
+        status: "pending",
+    };
+}
+function buildSteps(inventory) {
+    const steps = [];
+    let order = 1;
+    steps.push(createStep(order++, {
+        step_id: "provider-config-lock",
+        phase: "A",
+        category: "provider-config",
+        action: "modify",
+        dest_path: "polaris.config.json",
+        description: "Write minimal provider config lock before adoption scan/mutations.",
+        destructive: true,
+        requires_approval: false,
+        estimated_risk: "low",
+    }));
+    steps.push(createStep(order++, {
+        step_id: "adoption-scaffold",
+        phase: "A",
+        category: "scaffold",
+        action: "create",
+        dest_path: ".polaris/",
+        description: "Ensure Polaris scaffold files/folders required for adoption workflow exist.",
+        destructive: false,
+        requires_approval: false,
+        estimated_risk: "low",
+    }));
+    for (const candidate of inventory.smartdocs_candidates) {
+        steps.push(createStep(order++, {
+            step_id: `smartdocs-migrate-${order.toString().padStart(3, "0")}`,
+            phase: "C",
+            category: "smartdocs-migrate",
+            action: "move",
+            source_path: candidate.path,
+            dest_path: candidate.suggested_destination,
+            description: `Move ${candidate.path} to ${candidate.suggested_destination}.`,
+            destructive: true,
+            requires_approval: true,
+            estimated_risk: candidate.estimated_risk,
+        }));
+    }
+    for (const folder of inventory.likely_canonical_folders) {
+        const normalizedFolder = normalizePath(folder);
+        steps.push(createStep(order++, {
+            step_id: `cognition-generate-${order.toString().padStart(3, "0")}`,
+            phase: "C",
+            category: "cognition-generate",
+            action: "create",
+            dest_path: normalizedFolder,
+            description: `Generate ${normalizedFolder}/POLARIS.md and ${normalizedFolder}/SUMMARY.md templates if missing.`,
+            destructive: false,
+            requires_approval: true,
+            estimated_risk: "medium",
+        }));
+    }
+    for (const file of inventory.agent_instruction_files) {
+        const action = file.recommendation === "preserve" ? "skip" : "modify";
+        const destructive = action === "modify";
+        const risk = file.recommendation === "migrate"
+            ? "high"
+            : file.recommendation === "thin-adapter"
+                ? "medium"
+                : "low";
+        steps.push(createStep(order++, {
+            step_id: `instruction-refactor-${order.toString().padStart(3, "0")}`,
+            phase: "C",
+            category: "instruction-refactor",
+            action,
+            source_path: file.path,
+            dest_path: file.recommendation === "migrate"
+                ? `smartdocs/raw/migrated-instructions/${file.path.split("/").pop() ?? "instruction.md"}`
+                : file.path,
+            description: action === "skip"
+                ? `Preserve instruction file ${file.path} (${file.reason}).`
+                : `Apply ${file.recommendation} strategy to ${file.path} (${file.reason}).`,
+            destructive,
+            requires_approval: destructive,
+            estimated_risk: risk,
+        }));
+    }
+    for (const ignorePath of inventory.ignore_candidates) {
+        steps.push(createStep(order++, {
+            step_id: `ignore-rules-${order.toString().padStart(3, "0")}`,
+            phase: "C",
+            category: "ignore-rules",
+            action: "append",
+            dest_path: ".polarisignore",
+            description: `Append ${ignorePath} to .polarisignore.`,
+            destructive: true,
+            requires_approval: true,
+            estimated_risk: "low",
+        }));
+    }
+    steps.push(createStep(order++, {
+        step_id: "atlas-generate",
+        phase: "C",
+        category: "atlas-generate",
+        action: "modify",
+        dest_path: ".polaris/map/index.json",
+        description: "Run polaris map index and record adoption baseline coverage.",
+        destructive: true,
+        requires_approval: true,
+        estimated_risk: "medium",
+    }));
+    steps.push(createStep(order++, {
+        step_id: "stage-adoption",
+        phase: "C",
+        category: "stage",
+        action: "modify",
+        dest_path: ".git/index",
+        description: "Stage coherent adoption changes and prepare optional commit.",
+        destructive: true,
+        requires_approval: true,
+        estimated_risk: "medium",
+    }));
+    return steps;
+}
+function buildImpactSummary(steps, inventory) {
+    const filesToCreate = steps.filter((step) => step.action === "create").length;
+    const filesToMove = steps.filter((step) => step.action === "move").length;
+    const filesToModify = steps.filter((step) => step.action === "modify" || step.action === "append").length;
+    const instructionFilesAffected = steps.filter((step) => step.category === "instruction-refactor" && step.action !== "skip").length;
+    return {
+        files_to_create: filesToCreate,
+        files_to_move: filesToMove,
+        files_to_modify: filesToModify,
+        instruction_files_affected: instructionFilesAffected,
+        smartdocs_candidates_moved: inventory.smartdocs_candidates.length,
+        cognition_files_to_generate: inventory.likely_canonical_folders.length * 2,
+    };
+}
+function generateAdoptionPlan(inventory, options = {}) {
+    const generatedAt = (options.now ?? new Date()).toISOString();
+    const steps = buildSteps(inventory);
+    return {
+        plan_id: formatPlanId(generatedAt),
+        generated_at: generatedAt,
+        repo_state: inventory.repo_state,
+        approved: false,
+        approved_at: null,
+        dry_run: options.dryRun ?? false,
+        steps,
+        impact_summary: buildImpactSummary(steps, inventory),
+    };
+}
+function renderAdoptionPlanMarkdown(plan) {
+    const lines = [];
+    lines.push("# Adoption Plan");
+    lines.push("");
+    lines.push(`- Plan ID: \`${plan.plan_id}\``);
+    lines.push(`- Generated at: ${plan.generated_at}`);
+    lines.push(`- Repo state: ${plan.repo_state}`);
+    lines.push(`- Approved: ${plan.approved ? "yes" : "no"}`);
+    lines.push(`- Approved at: ${plan.approved_at ?? "n/a"}`);
+    lines.push(`- Dry run: ${plan.dry_run ? "yes" : "no"}`);
+    lines.push("");
+    lines.push("## Impact Summary");
+    lines.push("");
+    lines.push("| Metric | Value |");
+    lines.push("| --- | ---: |");
+    lines.push(`| Files to create | ${plan.impact_summary.files_to_create} |`);
+    lines.push(`| Files to move | ${plan.impact_summary.files_to_move} |`);
+    lines.push(`| Files to modify | ${plan.impact_summary.files_to_modify} |`);
+    lines.push(`| Instruction files affected | ${plan.impact_summary.instruction_files_affected} |`);
+    lines.push(`| SmartDocs candidates moved | ${plan.impact_summary.smartdocs_candidates_moved} |`);
+    lines.push(`| Cognition files to generate | ${plan.impact_summary.cognition_files_to_generate} |`);
+    lines.push("");
+    for (const phase of ["A", "B", "C"]) {
+        const phaseSteps = plan.steps.filter((step) => step.phase === phase);
+        lines.push(`## Phase ${phase}`);
+        lines.push("");
+        if (phaseSteps.length === 0) {
+            lines.push("_No steps._");
+            lines.push("");
+            continue;
+        }
+        for (const step of phaseSteps) {
+            const source = step.source_path ? ` source: \`${step.source_path}\`` : "";
+            const dest = step.dest_path ? ` destination: \`${step.dest_path}\`` : "";
+            lines.push(`- **${step.order}. ${step.step_id}** — ${step.category} / ${step.action} / approval ${step.requires_approval ? "required" : "not required"} / risk ${step.estimated_risk} / status ${step.status}${source}${dest}`);
+            lines.push(`  - ${step.description}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function generateAdoptionPlanArtifacts(repoRoot, inventory, options = {}) {
+    const plan = generateAdoptionPlan(inventory, options);
+    const jsonPath = (0, node_path_1.join)(repoRoot, ".polaris", "adoption-plan.json");
+    const markdownPath = (0, node_path_1.join)(repoRoot, ".polaris", "adoption-plan.md");
+    const json = `${JSON.stringify(plan, null, 2)}\n`;
+    const markdown = renderAdoptionPlanMarkdown(plan);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, ".polaris"), { recursive: true });
+    (0, node_fs_1.writeFileSync)(jsonPath, json, "utf-8");
+    (0, node_fs_1.writeFileSync)(markdownPath, markdown, "utf-8");
+    return {
+        plan,
+        json,
+        markdown,
+        jsonPath,
+        markdownPath,
+        wroteFiles: true,
+    };
+}

package/dist/cli/args.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCliArgs = parseCliArgs;
+function parseCliArgs(argv) {
+    const flags = {};
+    const positional = [];
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("--")) {
+                flags[key] = next;
+                i += 2;
+            }
+            else {
+                flags[key] = true;
+                i += 1;
+            }
+        }
+        else {
+            positional.push(arg);
+            i += 1;
+        }
+    }
+    return { flags, positional };
+}

package/dist/cli/args.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const args_js_1 = require("./args.js");
+(0, vitest_1.describe)("parseCliArgs", () => {
+    (0, vitest_1.it)("parses --state-file value", () => {
+        const r = (0, args_js_1.parseCliArgs)(["--state-file", "path/to/state.json"]);
+        (0, vitest_1.expect)(r.flags["state-file"]).toBe("path/to/state.json");
+        (0, vitest_1.expect)(r.positional).toEqual([]);
+    });
+    (0, vitest_1.it)("parses boolean flag", () => {
+        const r = (0, args_js_1.parseCliArgs)(["--json"]);
+        (0, vitest_1.expect)(r.flags["json"]).toBe(true);
+        (0, vitest_1.expect)(r.positional).toEqual([]);
+    });
+    (0, vitest_1.it)("parses --dry-run", () => {
+        const r = (0, args_js_1.parseCliArgs)(["--dry-run"]);
+        (0, vitest_1.expect)(r.flags["dry-run"]).toBe(true);
+    });
+    (0, vitest_1.it)("collects positional args before flags", () => {
+        const r = (0, args_js_1.parseCliArgs)(["continue", "--json"]);
+        (0, vitest_1.expect)(r.positional).toEqual(["continue"]);
+        (0, vitest_1.expect)(r.flags["json"]).toBe(true);
+    });
+    (0, vitest_1.it)("returns empty flags and positional for empty input", () => {
+        const r = (0, args_js_1.parseCliArgs)([]);
+        (0, vitest_1.expect)(r.flags).toEqual({});
+        (0, vitest_1.expect)(r.positional).toEqual([]);
+    });
+});

package/dist/cli/branding.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Centralized Polaris CLO branding strings and terminal banner.
+ * All brand copy lives here — change once, applies everywhere.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRAND = void 0;
+exports.getBanner = getBanner;
+exports.BRAND = {
+    name: "Polaris CLO",
+    fullName: "POLARIS CLO",
+    subtitle: "Command Line Orchestrator",
+    tagline: "Navigate · Align · Orchestrate",
+    pkg: "@lsctech/polaris",
+};
+const ESC = "\x1b";
+const RESET = `${ESC}[0m`;
+const BOLD = `${ESC}[1m`;
+const DIM = `${ESC}[2m`;
+const CYAN = `${ESC}[36m`;
+const BRIGHT_BLUE = `${ESC}[94m`;
+/**
+ * Returns the startup banner string.
+ * Strips ANSI codes when stdout is not a TTY (e.g. pipes, CI).
+ */
+function getBanner(forceColor = false) {
+    const color = forceColor || (process.stdout.isTTY ?? false);
+    const star = color ? `${BRIGHT_BLUE}✦${RESET}` : "✦";
+    const title = color ? `${BOLD}${CYAN}${exports.BRAND.fullName}${RESET}` : exports.BRAND.fullName;
+    const sub = color ? `${DIM}${exports.BRAND.subtitle}${RESET}` : exports.BRAND.subtitle;
+    const tag = color ? `${DIM}${exports.BRAND.tagline}${RESET}` : exports.BRAND.tagline;
+    const rule = color ? `${DIM}${"─".repeat(38)}${RESET}` : "─".repeat(38);
+    return [
+        "",
+        `  ${star}  ${title}`,
+        `  ${rule}`,
+        `  ${sub}`,
+        `  ${tag}`,
+        "",
+    ].join("\n");
+}