great-cto 0.1.0

package/README.md

@@ -0,0 +1,90 @@
+# great-cto
+
+> One command install for the [great_cto](https://github.com/avelikiy/great_cto) Claude Code plugin.
+
+```bash
+npx great-cto init
+```
+
+That's it. The CLI detects your stack, picks the right archetype, clones the plugin, enables it, and writes a pre-filled `PROJECT.md`.
+
+## What it does
+
+1. **Scans** your project for stack signals — `package.json`, `requirements.txt`, `Cargo.toml`, `go.mod`, `Chart.yaml`, `*.tf`, `hardhat.config.*`, etc.
+2. **Picks** the matching great_cto archetype:
+   - `web-service` · `mobile-app` · `ai-system` · `commerce` · `web3`
+   - `data-platform` · `infra` · `library` · `iot-embedded` · `regulated` · `greenfield`
+3. **Installs** the plugin into `~/.claude/plugins/cache/local/great_cto/<latest>/`
+4. **Enables** it in `~/.claude/settings.json` (atomic merge — other keys preserved, backup taken)
+5. **Bootstraps** `.great_cto/PROJECT.md` pre-filled with archetype, stack, suggested compliance frameworks
+
+After install, restart Claude Code and run `/inbox` or `/audit`.
+
+## Examples
+
+### Commerce detection (Stripe + Next.js)
+
+```
+[1/5] scanning /path/to/saas
+  stack: next.js, nodejs, prisma, react, stripe, supabase, typescript
+  languages: javascript, typescript
+  tests: yes  CI: yes
+[2/5] picking archetype
+  archetype: commerce (confidence: medium)
+  rationale: payments SDK detected: Stripe — PCI-DSS gate mandatory
+  suggested compliance: gdpr, pci-dss
+```
+
+### AI system (MCP + Anthropic SDK)
+
+```
+  archetype: ai-system (confidence: high)
+  rationale: AI/LLM tooling detected (MCP SDK, Anthropic SDK, LangChain) —
+             security gate mandatory for prompt injection + output sanitization
+  suggested compliance: eu-ai-act
+```
+
+### Infra repo (Terraform + Helm)
+
+```
+  archetype: infra (confidence: high)
+  rationale: infrastructure-as-code detected: Terraform, Helm
+```
+
+## Options
+
+```
+npx great-cto init [options]
+
+  -y, --yes              Skip confirmation prompts (non-interactive)
+      --dry-run          Show what would be done without doing it
+      --force            Reinstall even if already present
+      --archetype NAME   Override detected archetype
+      --version-tag VER  Pin to specific great_cto version (default: latest)
+      --dir PATH         Run against a different directory (default: cwd)
+  -h, --help             Show help
+  -v, --version          Show CLI version
+```
+
+## Safety
+
+- **Atomic `settings.json` merge**: a timestamped `.bak` file is written before any change. Other `enabledPlugins` entries and unrelated keys are preserved.
+- **Dry-run by default**: run `--dry-run` first to see exactly what will happen.
+- **Idempotent**: running twice does nothing the second time (unless `--force`).
+- **Never overwrites `PROJECT.md`**: if you already have one, the CLI leaves it untouched.
+
+## Requirements
+
+- Node.js ≥ 22.6.0
+- Git (to clone the plugin repo)
+- [Claude Code](https://claude.com/claude-code)
+
+## License
+
+MIT — same as the plugin.
+
+## Links
+
+- Plugin: [github.com/avelikiy/great_cto](https://github.com/avelikiy/great_cto)
+- Issues: [github.com/avelikiy/great_cto/issues](https://github.com/avelikiy/great_cto/issues)
+- Author: [velykyi](https://www.linkedin.com/in/velykyi/)

package/dist/archetypes.js

@@ -0,0 +1,234 @@
+// Archetype decision: detected stack → archetype recommendation.
+// Mirrors great_cto's 10 archetypes in skills/great_cto/ARCHETYPES.md.
+// Rules are evaluated; highest score wins.
+const RULES = [
+    // ── commerce ─────────────────────────────────────
+    {
+        archetype: "commerce",
+        score: (d) => {
+            let s = 0;
+            if (d.stack.includes("stripe"))
+                s += 5;
+            if (d.stack.includes("shopify"))
+                s += 5;
+            if (d.stack.includes("braintree"))
+                s += 5;
+            return s;
+        },
+        reason: (d) => {
+            const payments = [];
+            if (d.stack.includes("stripe"))
+                payments.push("Stripe");
+            if (d.stack.includes("shopify"))
+                payments.push("Shopify");
+            if (d.stack.includes("braintree"))
+                payments.push("Braintree");
+            return `payments SDK detected: ${payments.join(", ")} — PCI-DSS gate mandatory`;
+        },
+    },
+    // ── web3 ─────────────────────────────────────────
+    {
+        archetype: "web3",
+        score: (d) => {
+            let s = 0;
+            if (d.stack.includes("solidity"))
+                s += 6;
+            if (d.stack.includes("web3"))
+                s += 4;
+            return s;
+        },
+        reason: (_d) => "Solidity / smart-contract tooling detected — formal verification gate",
+    },
+    // ── iot-embedded ─────────────────────────────────
+    {
+        archetype: "iot-embedded",
+        score: (d) => (d.stack.includes("embedded") ? 6 : 0),
+        reason: (_d) => "platformio.ini / sdkconfig detected — embedded firmware archetype",
+    },
+    // ── ai-system ────────────────────────────────────
+    {
+        archetype: "ai-system",
+        score: (d) => {
+            let s = 0;
+            if (d.stack.includes("anthropic-sdk"))
+                s += 4;
+            if (d.stack.includes("openai-sdk"))
+                s += 3;
+            if (d.stack.includes("langchain"))
+                s += 4;
+            if (d.stack.includes("llamaindex"))
+                s += 4;
+            if (d.stack.includes("mcp"))
+                s += 5;
+            if (d.stack.includes("ml"))
+                s += 3;
+            return s;
+        },
+        reason: (d) => {
+            const bits = [];
+            if (d.stack.includes("mcp"))
+                bits.push("MCP SDK");
+            if (d.stack.includes("anthropic-sdk"))
+                bits.push("Anthropic SDK");
+            if (d.stack.includes("openai-sdk"))
+                bits.push("OpenAI SDK");
+            if (d.stack.includes("langchain"))
+                bits.push("LangChain");
+            if (d.stack.includes("llamaindex"))
+                bits.push("LlamaIndex");
+            if (d.stack.includes("ml"))
+                bits.push("ML stack");
+            return `AI/LLM tooling detected (${bits.join(", ")}) — security gate mandatory for prompt injection + output sanitization`;
+        },
+    },
+    // ── mobile-app ───────────────────────────────────
+    {
+        archetype: "mobile-app",
+        score: (d) => {
+            let s = 0;
+            if (d.stack.includes("react-native"))
+                s += 5;
+            if (d.stack.includes("expo"))
+                s += 5;
+            if (d.stack.includes("ios"))
+                s += 5;
+            if (d.stack.includes("swift"))
+                s += 3;
+            return s;
+        },
+        reason: (d) => {
+            const bits = [];
+            if (d.stack.includes("react-native"))
+                bits.push("React Native");
+            if (d.stack.includes("expo"))
+                bits.push("Expo");
+            if (d.stack.includes("ios"))
+                bits.push("iOS project");
+            return `mobile framework detected: ${bits.join(", ")}`;
+        },
+    },
+    // ── data-platform ────────────────────────────────
+    {
+        archetype: "data-platform",
+        score: (d) => (d.stack.includes("data-pipeline") ? 4 : 0),
+        reason: (_d) => "data pipeline tooling detected (pandas/airflow/prefect)",
+    },
+    // ── infra ────────────────────────────────────────
+    {
+        archetype: "infra",
+        score: (d) => {
+            const hasTerraform = d.stack.includes("terraform");
+            const hasHelm = d.stack.includes("helm");
+            const hasK8s = d.stack.includes("kubernetes");
+            // Require at least one explicit infra signal
+            if (!hasTerraform && !hasHelm && !hasK8s)
+                return 0;
+            let s = 0;
+            if (hasTerraform)
+                s += 4;
+            if (hasHelm)
+                s += 4;
+            if (hasK8s)
+                s += 4;
+            // Pure-infra repo (no app code) gets a small bonus
+            if (!d.stack.includes("nodejs") && !d.stack.includes("python") && !d.stack.includes("go"))
+                s += 2;
+            return s;
+        },
+        reason: (d) => {
+            const bits = [];
+            if (d.stack.includes("terraform"))
+                bits.push("Terraform");
+            if (d.stack.includes("helm"))
+                bits.push("Helm");
+            if (d.stack.includes("kubernetes"))
+                bits.push("Kustomize/K8s");
+            return `infrastructure-as-code detected: ${bits.join(", ")}`;
+        },
+    },
+    // ── web-service (default for web frameworks) ─────
+    {
+        archetype: "web-service",
+        score: (d) => {
+            let s = 0;
+            const webFrameworks = [
+                "next.js", "react", "vue", "angular", "svelte", "astro",
+                "express", "fastify", "nestjs", "hono",
+                "django", "fastapi", "flask",
+            ];
+            for (const fw of webFrameworks)
+                if (d.stack.includes(fw))
+                    s += 1;
+            if (s > 0)
+                s += 2; // baseline bonus for any web framework
+            return s;
+        },
+        reason: (d) => {
+            const fw = d.stack.find((t) => ["next.js", "react", "vue", "angular", "svelte", "astro", "express", "fastify", "nestjs", "hono", "django", "fastapi", "flask"].includes(t));
+            return `web framework detected: ${fw ?? "unknown"}`;
+        },
+    },
+    // ── library (no app framework, just code) ────────
+    {
+        archetype: "library",
+        score: (d) => {
+            const hasApp = d.stack.some((t) => ["next.js", "django", "fastapi", "express", "fastify", "nestjs", "react-native", "expo", "terraform"].includes(t));
+            if (hasApp)
+                return 0;
+            // Plain Node or Python or Go or Rust with no web/mobile/infra → likely a library
+            if (d.stack.includes("nodejs") || d.stack.includes("python") || d.stack.includes("go") || d.stack.includes("rust")) {
+                return 2;
+            }
+            return 0;
+        },
+        reason: (_d) => "no web/mobile/infra framework detected — looks like a library/SDK",
+    },
+];
+export function pickArchetype(d) {
+    const scored = RULES
+        .map((r) => ({ archetype: r.archetype, score: r.score(d), reason: r.reason(d) }))
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score);
+    if (scored.length === 0) {
+        return {
+            primary: "greenfield",
+            confidence: "low",
+            rationale: "no strong signals detected — treating as greenfield project",
+            alternatives: [],
+        };
+    }
+    const top = scored[0];
+    const nextBest = scored[1]?.score ?? 0;
+    const gap = top.score - nextBest;
+    const confidence = top.score >= 5 && gap >= 2 ? "high" :
+        top.score >= 3 ? "medium" : "low";
+    return {
+        primary: top.archetype,
+        confidence,
+        rationale: top.reason,
+        alternatives: scored.slice(1, 4).map((r) => r.archetype),
+    };
+}
+// Compliance hints — auto-suggested based on stack.
+export function suggestCompliance(d, archetype) {
+    const c = new Set();
+    if (archetype === "commerce") {
+        c.add("pci-dss");
+        c.add("gdpr");
+    }
+    if (archetype === "ai-system") {
+        c.add("eu-ai-act");
+    }
+    if (archetype === "web3") {
+        c.add("soc2");
+    }
+    if (archetype === "iot-embedded") {
+        c.add("iso27001");
+    }
+    if (d.stack.includes("stripe"))
+        c.add("pci-dss");
+    // Reasonable default for any web service storing user data
+    if (archetype === "web-service")
+        c.add("gdpr");
+    return Array.from(c).sort();
+}

package/dist/bootstrap.js

@@ -0,0 +1,75 @@
+// Generate .great_cto/PROJECT.md pre-filled from detected stack + archetype.
+// Safe: will NOT overwrite an existing PROJECT.md.
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dim, success, warn } from "./ui.js";
+export function bootstrap(dir, detection, archetype, compliance) {
+    const greatCtoDir = join(dir, ".great_cto");
+    const projectMd = join(greatCtoDir, "PROJECT.md");
+    if (existsSync(projectMd)) {
+        warn(`.great_cto/PROJECT.md already exists — not overwriting.`);
+        return { projectMdPath: projectMd, created: false, skippedReason: "already exists" };
+    }
+    mkdirSync(greatCtoDir, { recursive: true });
+    const title = inferProjectTitle(dir);
+    const stackLine = detection.stack.length > 0 ? detection.stack.join(", ") : "to be defined";
+    const complianceLine = compliance.length > 0 ? compliance.join(", ") : "none";
+    const teamSize = 1; // MVP default — user edits later
+    const approvalLevel = "gates-only"; // default per README
+    const content = `# ${title}
+
+> Auto-generated by \`great-cto init\` on ${new Date().toISOString().slice(0, 10)}.
+> Edit freely — this file is yours. Re-run \`npx great-cto init\` won't overwrite it.
+
+## Project
+
+primary: ${archetype}
+stack: ${stackLine}
+languages: ${detection.languages.join(", ") || "to be defined"}
+package-manager: ${detection.packageManager ?? "none"}
+
+## Team
+
+size: ${teamSize}
+mode: solo
+approval-level: ${approvalLevel}
+
+## Compliance
+
+frameworks: [${complianceLine}]
+
+## Goals
+
+- <add your primary goal here>
+- <add your second goal here>
+
+## Context
+
+- Tests present: ${detection.hasTests ? "yes" : "no"}
+- CI configured: ${detection.hasCI ? "yes" : "no"}
+- Detected signals: ${JSON.stringify(detection.signals, null, 2).replace(/\n/g, "\n  ")}
+
+## Notes
+
+Generated from stack auto-detection. For a full audit (gap analysis, tech
+debt scan, architectural review) run \`/audit\` in Claude Code after install.
+`;
+    writeFileSync(projectMd, content, "utf-8");
+    success(`created .great_cto/PROJECT.md ${dim(`(archetype: ${archetype})`)}`);
+    return { projectMdPath: projectMd, created: true, skippedReason: null };
+}
+function inferProjectTitle(dir) {
+    // Prefer package.json name, then directory basename.
+    try {
+        const pkgPath = join(dir, "package.json");
+        if (existsSync(pkgPath)) {
+            const { readFileSync } = require("node:fs");
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (pkg.name)
+                return pkg.name;
+        }
+    }
+    catch { /* ignore */ }
+    const parts = dir.split(/[\/\\]/);
+    return parts[parts.length - 1] ?? "project";
+}

package/dist/detect.js

@@ -0,0 +1,314 @@
+// Stack detection: scan cwd for technology signals.
+// Zero-dependency — pure file reads + JSON parse.
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+export function detect(dir) {
+    const signals = {};
+    const stack = new Set();
+    const languages = new Set();
+    function sig(name, file) {
+        if (!signals[name])
+            signals[name] = [];
+        signals[name].push(file);
+    }
+    // ── package.json (Node/TS) ────────────────────────────────
+    const pkgPath = join(dir, "package.json");
+    let pkg = {};
+    if (existsSync(pkgPath)) {
+        sig("node", "package.json");
+        stack.add("nodejs");
+        languages.add("javascript");
+        try {
+            pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const allDeps = {
+                ...(pkg.dependencies ?? {}),
+                ...(pkg.devDependencies ?? {}),
+                ...(pkg.peerDependencies ?? {}),
+            };
+            const has = (name) => name in allDeps;
+            if (has("typescript") || existsSync(join(dir, "tsconfig.json"))) {
+                stack.add("typescript");
+                languages.add("typescript");
+            }
+            // Frameworks
+            if (has("next")) {
+                stack.add("next.js");
+                sig("framework-next", "package.json");
+            }
+            if (has("react") || has("react-dom"))
+                stack.add("react");
+            if (has("vue") || has("nuxt"))
+                stack.add("vue");
+            if (has("@angular/core"))
+                stack.add("angular");
+            if (has("svelte") || has("@sveltejs/kit"))
+                stack.add("svelte");
+            if (has("astro"))
+                stack.add("astro");
+            if (has("express"))
+                stack.add("express");
+            if (has("fastify"))
+                stack.add("fastify");
+            if (has("@nestjs/core"))
+                stack.add("nestjs");
+            if (has("hono"))
+                stack.add("hono");
+            // Mobile
+            if (has("react-native")) {
+                stack.add("react-native");
+                sig("mobile", "package.json");
+            }
+            if (has("expo"))
+                stack.add("expo");
+            // AI / agents
+            if (has("openai")) {
+                stack.add("openai-sdk");
+                sig("ai", "openai");
+            }
+            if (has("@anthropic-ai/sdk")) {
+                stack.add("anthropic-sdk");
+                sig("ai", "anthropic-sdk");
+            }
+            if (has("langchain") || has("@langchain/core")) {
+                stack.add("langchain");
+                sig("ai", "langchain");
+            }
+            if (has("llamaindex")) {
+                stack.add("llamaindex");
+                sig("ai", "llamaindex");
+            }
+            if (has("@modelcontextprotocol/sdk")) {
+                stack.add("mcp");
+                sig("ai", "mcp");
+            }
+            // Payments / commerce
+            if (has("stripe") || has("@stripe/stripe-js")) {
+                stack.add("stripe");
+                sig("commerce", "stripe");
+            }
+            if (has("@shopify/shopify-api")) {
+                stack.add("shopify");
+                sig("commerce", "shopify");
+            }
+            if (has("braintree")) {
+                stack.add("braintree");
+                sig("commerce", "braintree");
+            }
+            // Auth
+            if (has("next-auth") || has("@auth/core"))
+                stack.add("auth");
+            if (has("@clerk/nextjs") || has("@clerk/clerk-sdk-node"))
+                stack.add("clerk");
+            if (has("@supabase/supabase-js"))
+                stack.add("supabase");
+            // Databases / ORMs
+            if (has("prisma") || has("@prisma/client"))
+                stack.add("prisma");
+            if (has("drizzle-orm"))
+                stack.add("drizzle");
+            if (has("typeorm"))
+                stack.add("typeorm");
+            if (has("mongodb") || has("mongoose"))
+                stack.add("mongodb");
+            if (has("pg") || has("postgres"))
+                stack.add("postgres");
+            if (has("mysql") || has("mysql2"))
+                stack.add("mysql");
+            if (has("redis") || has("ioredis"))
+                stack.add("redis");
+            // Testing
+            if (has("jest") || has("vitest") || has("mocha") || has("@playwright/test") || has("playwright")) {
+                sig("tests", "package.json");
+            }
+        }
+        catch { /* ignore malformed */ }
+    }
+    // ── Python ────────────────────────────────────────────────
+    if (existsSync(join(dir, "requirements.txt")) ||
+        existsSync(join(dir, "pyproject.toml")) ||
+        existsSync(join(dir, "setup.py"))) {
+        sig("python", "pyproject/requirements/setup");
+        stack.add("python");
+        languages.add("python");
+        try {
+            const reqs = existsSync(join(dir, "requirements.txt"))
+                ? readFileSync(join(dir, "requirements.txt"), "utf-8")
+                : "";
+            const pyproject = existsSync(join(dir, "pyproject.toml"))
+                ? readFileSync(join(dir, "pyproject.toml"), "utf-8")
+                : "";
+            const all = reqs + "\n" + pyproject;
+            const ihas = (s) => all.toLowerCase().includes(s);
+            if (ihas("django")) {
+                stack.add("django");
+                sig("framework-django", "python");
+            }
+            if (ihas("fastapi")) {
+                stack.add("fastapi");
+                sig("framework-fastapi", "python");
+            }
+            if (ihas("flask"))
+                stack.add("flask");
+            if (ihas("openai"))
+                stack.add("openai-sdk");
+            if (ihas("anthropic"))
+                stack.add("anthropic-sdk");
+            if (ihas("langchain")) {
+                stack.add("langchain");
+                sig("ai", "langchain");
+            }
+            if (ihas("llama-index") || ihas("llamaindex"))
+                stack.add("llamaindex");
+            if (ihas("torch") || ihas("tensorflow") || ihas("scikit-learn")) {
+                stack.add("ml");
+                sig("ml", "python");
+            }
+            if (ihas("pandas") || ihas("dask") || ihas("airflow") || ihas("prefect")) {
+                stack.add("data-pipeline");
+                sig("data", "python");
+            }
+            if (ihas("stripe")) {
+                stack.add("stripe");
+                sig("commerce", "stripe");
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // ── Go ────────────────────────────────────────────────────
+    if (existsSync(join(dir, "go.mod"))) {
+        sig("go", "go.mod");
+        stack.add("go");
+        languages.add("go");
+        try {
+            const gomod = readFileSync(join(dir, "go.mod"), "utf-8");
+            if (gomod.includes("stripe-go"))
+                stack.add("stripe");
+            if (gomod.includes("openai-go"))
+                stack.add("openai-sdk");
+        }
+        catch { /* ignore */ }
+    }
+    // ── Rust ──────────────────────────────────────────────────
+    if (existsSync(join(dir, "Cargo.toml"))) {
+        sig("rust", "Cargo.toml");
+        stack.add("rust");
+        languages.add("rust");
+        try {
+            const cargo = readFileSync(join(dir, "Cargo.toml"), "utf-8");
+            if (cargo.includes("actix-web") || cargo.includes("axum") || cargo.includes("rocket")) {
+                sig("web-rust", "Cargo.toml");
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // ── Java / Kotlin ─────────────────────────────────────────
+    if (existsSync(join(dir, "pom.xml"))) {
+        sig("java", "pom.xml");
+        stack.add("java");
+        languages.add("java");
+    }
+    if (existsSync(join(dir, "build.gradle")) || existsSync(join(dir, "build.gradle.kts"))) {
+        sig("gradle", "build.gradle");
+        stack.add("gradle");
+        if (existsSync(join(dir, "build.gradle.kts")))
+            languages.add("kotlin");
+        else
+            languages.add("java");
+    }
+    // ── Swift / iOS ───────────────────────────────────────────
+    if (existsSync(join(dir, "Package.swift"))) {
+        sig("swift", "Package.swift");
+        stack.add("swift");
+        languages.add("swift");
+    }
+    if (safeGlob(dir, /\.xcodeproj$/)) {
+        sig("ios", "xcodeproj");
+        stack.add("ios");
+    }
+    // ── Infra ─────────────────────────────────────────────────
+    if (safeGlob(dir, /\.tf$/)) {
+        sig("infra", "terraform");
+        stack.add("terraform");
+    }
+    if (existsSync(join(dir, "Chart.yaml")) || existsSync(join(dir, "values.yaml"))) {
+        sig("infra", "helm");
+        stack.add("helm");
+    }
+    if (safeGlob(dir, /kustomization\.ya?ml$/)) {
+        sig("infra", "kustomize");
+        stack.add("kubernetes");
+    }
+    if (existsSync(join(dir, "Dockerfile")) || existsSync(join(dir, "docker-compose.yml"))) {
+        sig("docker", "Dockerfile");
+        stack.add("docker");
+    }
+    // ── Smart contracts ──────────────────────────────────────
+    if (existsSync(join(dir, "hardhat.config.js")) ||
+        existsSync(join(dir, "hardhat.config.ts")) ||
+        existsSync(join(dir, "foundry.toml"))) {
+        sig("web3", "smart-contract");
+        stack.add("web3");
+        stack.add("solidity");
+        languages.add("solidity");
+    }
+    if (safeGlob(dir, /\.sol$/)) {
+        sig("web3", "solidity-files");
+        stack.add("solidity");
+    }
+    // ── Embedded ─────────────────────────────────────────────
+    if (existsSync(join(dir, "platformio.ini")) ||
+        existsSync(join(dir, "sdkconfig")) ||
+        existsSync(join(dir, "Kconfig"))) {
+        sig("embedded", "platformio/sdk");
+        stack.add("embedded");
+    }
+    // ── Package manager ──────────────────────────────────────
+    let packageManager = null;
+    if (existsSync(join(dir, "pnpm-lock.yaml")))
+        packageManager = "pnpm";
+    else if (existsSync(join(dir, "yarn.lock")))
+        packageManager = "yarn";
+    else if (existsSync(join(dir, "bun.lockb")) || existsSync(join(dir, "bun.lock")))
+        packageManager = "bun";
+    else if (existsSync(join(dir, "package-lock.json")))
+        packageManager = "npm";
+    // ── CI / tests ───────────────────────────────────────────
+    const hasTests = !!signals["tests"] ||
+        existsSync(join(dir, "pytest.ini")) ||
+        existsSync(join(dir, "tox.ini")) ||
+        safeGlob(dir, /^(tests?|spec|__tests__)$/, "dir");
+    const hasCI = existsSync(join(dir, ".github", "workflows")) ||
+        existsSync(join(dir, ".gitlab-ci.yml")) ||
+        existsSync(join(dir, ".circleci")) ||
+        existsSync(join(dir, "azure-pipelines.yml"));
+    const hasExistingGreatCto = existsSync(join(dir, ".great_cto", "PROJECT.md")) ||
+        existsSync(join(dir, ".great_cto", "SKILL.md"));
+    return {
+        stack: Array.from(stack).sort(),
+        languages: Array.from(languages).sort(),
+        signals,
+        packageManager,
+        hasTests,
+        hasCI,
+        hasExistingGreatCto,
+    };
+}
+// ── helpers ──────────────────────────────────────────────────
+function safeGlob(dir, pattern, kind = "file") {
+    try {
+        const entries = readdirSync(dir);
+        for (const e of entries) {
+            const p = join(dir, e);
+            try {
+                const st = statSync(p);
+                if (kind === "file" && st.isFile() && pattern.test(e))
+                    return true;
+                if (kind === "dir" && st.isDirectory() && pattern.test(e))
+                    return true;
+            }
+            catch { /* unreadable entry */ }
+        }
+    }
+    catch { /* unreadable dir */ }
+    return false;
+}

package/dist/installer.js

@@ -0,0 +1,132 @@
+// Install the great_cto plugin into ~/.claude/plugins/cache/local/great_cto/<version>/.
+// Uses git clone. Falls back to tarball fetch if git is unavailable.
+import { spawnSync, execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { log, success, warn, dim } from "./ui.js";
+const REPO_URL = "https://github.com/avelikiy/great_cto.git";
+export function hasGit() {
+    try {
+        execFileSync("git", ["--version"], { stdio: "pipe", timeout: 5_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function detectLatestVersion() {
+    try {
+        const out = execFileSync("git", ["ls-remote", "--tags", REPO_URL], {
+            encoding: "utf-8",
+            timeout: 15_000,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const tags = out
+            .split("\n")
+            .map((line) => line.match(/refs\/tags\/v?([0-9]+\.[0-9]+\.[0-9]+)(?!\^)/)?.[1])
+            .filter((t) => !!t)
+            .sort((a, b) => cmpSemver(b, a));
+        return tags[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function cmpSemver(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+export function getPluginBaseDir() {
+    return join(homedir(), ".claude", "plugins", "cache", "local", "great_cto");
+}
+export function findInstalledVersions() {
+    const base = getPluginBaseDir();
+    if (!existsSync(base))
+        return [];
+    try {
+        const { readdirSync } = require("node:fs");
+        return readdirSync(base).filter((name) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(name)).sort(cmpSemver);
+    }
+    catch {
+        return [];
+    }
+}
+export function install(opts = {}) {
+    if (!hasGit()) {
+        throw new Error("git is required to install great_cto. Install git first: https://git-scm.com/downloads");
+    }
+    // Resolve version
+    let version = opts.version;
+    if (!version) {
+        const latest = detectLatestVersion();
+        if (!latest) {
+            warn("Could not detect latest version from GitHub tags — falling back to main branch.");
+            version = "main";
+        }
+        else {
+            version = latest;
+        }
+    }
+    const pluginDir = join(getPluginBaseDir(), version);
+    if (existsSync(pluginDir) && !opts.force) {
+        // Verify it has plugin.json (otherwise corrupted install)
+        const manifest = join(pluginDir, ".claude-plugin", "plugin.json");
+        if (existsSync(manifest)) {
+            return { installed: false, pluginDir, version, alreadyInstalled: true };
+        }
+        // Corrupted → remove and reinstall
+        warn(`Previous install at ${pluginDir} looks corrupted — reinstalling.`);
+        rmSync(pluginDir, { recursive: true, force: true });
+    }
+    mkdirSync(join(getPluginBaseDir()), { recursive: true });
+    log(dim(`  cloning ${REPO_URL} into ${pluginDir}`));
+    const ref = /^[0-9]+\.[0-9]+\.[0-9]+$/.test(version) ? `v${version}` : version;
+    const result = spawnSync("git", ["clone", "--depth=1", "--branch", ref, REPO_URL, pluginDir], {
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 120_000,
+    });
+    if (result.status !== 0) {
+        const stderr = result.stderr?.toString() ?? "";
+        // If branch/tag doesn't exist, try plain clone of main
+        if (stderr.includes("not found") || stderr.includes("Remote branch")) {
+            warn(`Tag ${ref} not found — cloning default branch.`);
+            rmSync(pluginDir, { recursive: true, force: true });
+            const r2 = spawnSync("git", ["clone", "--depth=1", REPO_URL, pluginDir], {
+                stdio: ["ignore", "pipe", "pipe"],
+                timeout: 120_000,
+            });
+            if (r2.status !== 0) {
+                throw new Error(`git clone failed: ${r2.stderr?.toString() ?? "unknown error"}`);
+            }
+            // Re-read version from actual plugin.json
+            version = readPluginVersion(pluginDir) ?? "main";
+        }
+        else {
+            throw new Error(`git clone failed: ${stderr}`);
+        }
+    }
+    // Sanity check: did we get a plugin?
+    const manifest = join(pluginDir, ".claude-plugin", "plugin.json");
+    if (!existsSync(manifest)) {
+        throw new Error(`Install appeared to succeed but ${manifest} is missing. Repo layout may have changed.`);
+    }
+    success(`plugin installed at ${pluginDir}`);
+    return { installed: true, pluginDir, version, alreadyInstalled: false };
+}
+function readPluginVersion(pluginDir) {
+    try {
+        const manifest = join(pluginDir, ".claude-plugin", "plugin.json");
+        const pkg = JSON.parse(readFileSync(manifest, "utf-8"));
+        return pkg.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/main.js

@@ -0,0 +1,240 @@
+// CLI entry: parse args, run the init flow.
+//
+// Flow:
+//   1. banner
+//   2. detect stack in cwd
+//   3. pick archetype + compliance
+//   4. confirm with user (unless -y)
+//   5. install plugin (git clone)
+//   6. enable in ~/.claude/settings.json
+//   7. bootstrap .great_cto/PROJECT.md
+//   8. print next steps
+import { resolve } from "node:path";
+import { banner, bold, cyan, dim, error, green, log, step, warn, yellow, confirm } from "./ui.js";
+import { detect } from "./detect.js";
+import { pickArchetype, suggestCompliance } from "./archetypes.js";
+import { install, findInstalledVersions } from "./installer.js";
+import { enableGreatCto } from "./settings.js";
+import { bootstrap } from "./bootstrap.js";
+function parseArgs(argv) {
+    const args = {
+        command: "init",
+        dir: process.cwd(),
+        yes: false,
+        dryRun: false,
+        force: false,
+        archetype: null,
+        version: null,
+    };
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-h" || a === "--help")
+            args.command = "help";
+        else if (a === "-v" || a === "--version")
+            args.command = "version";
+        else if (a === "-y" || a === "--yes")
+            args.yes = true;
+        else if (a === "--dry-run")
+            args.dryRun = true;
+        else if (a === "--force")
+            args.force = true;
+        else if (a === "--archetype")
+            args.archetype = argv[++i] ?? null;
+        else if (a === "--version-tag")
+            args.version = argv[++i] ?? null;
+        else if (a.startsWith("--dir="))
+            args.dir = a.slice("--dir=".length);
+        else if (a === "--dir")
+            args.dir = argv[++i] ?? args.dir;
+        else if (a === "init" || a === "help" || a === "version") {
+            args.command = a;
+        }
+        else
+            rest.push(a);
+    }
+    args.dir = resolve(args.dir);
+    return args;
+}
+function printHelp() {
+    log(`${bold("great-cto")} — one-command install for the great_cto Claude Code plugin
+
+${bold("Usage:")}
+  npx great-cto init [options]
+  npx great-cto help
+  npx great-cto version
+
+${bold("Options:")}
+  -y, --yes              Skip confirmation prompts (non-interactive)
+      --dry-run          Show what would be done without doing it
+      --force            Reinstall even if already present
+      --archetype NAME   Override detected archetype
+                         (${cyan("web-service|mobile-app|ai-system|commerce|web3|")}
+                          ${cyan("data-platform|infra|library|iot-embedded|regulated")})
+      --version-tag VER  Pin to specific great_cto version (default: latest)
+      --dir PATH         Run against a different directory (default: cwd)
+  -h, --help             Show this help
+  -v, --version          Show great-cto CLI version
+
+${bold("What it does:")}
+  1. Scans your project for stack signals (package.json, Cargo.toml, go.mod, etc.)
+  2. Picks the matching great_cto archetype (web-service, commerce, ai-system, ...)
+  3. Clones the plugin into ~/.claude/plugins/cache/local/great_cto/<version>/
+  4. Enables the plugin in ~/.claude/settings.json
+  5. Creates .great_cto/PROJECT.md pre-filled with archetype + detected stack
+
+${bold("Next steps after install:")}
+  Restart Claude Code. Then run ${cyan("/inbox")} to see what needs attention,
+  or ${cyan("/audit")} for a full analysis of an existing codebase.
+
+${bold("Links:")}
+  github.com/avelikiy/great_cto
+`);
+}
+async function runInit(args) {
+    banner();
+    // ── 1. detect ────────────────────────────────────────────
+    step(1, 5, `scanning ${args.dir}`);
+    const detection = detect(args.dir);
+    if (detection.hasExistingGreatCto) {
+        warn(".great_cto/ already exists in this directory.");
+        warn("If you're re-initializing, back it up first or run with --force.");
+        if (!args.yes && !args.force) {
+            const ok = await confirm("Continue anyway?", false);
+            if (!ok) {
+                log("Aborted.");
+                return 1;
+            }
+        }
+    }
+    log(`  ${dim("stack:")} ${detection.stack.length > 0 ? detection.stack.join(", ") : dim("(no strong signals)")}`);
+    log(`  ${dim("languages:")} ${detection.languages.join(", ") || dim("(none)")}`);
+    if (detection.packageManager)
+        log(`  ${dim("package manager:")} ${detection.packageManager}`);
+    log(`  ${dim("tests:")} ${detection.hasTests ? green("yes") : yellow("no")}  ${dim("CI:")} ${detection.hasCI ? green("yes") : yellow("no")}`);
+    // ── 2. pick archetype ────────────────────────────────────
+    step(2, 5, "picking archetype");
+    let archetype;
+    let rationale;
+    let alternatives;
+    let confidence;
+    if (args.archetype) {
+        archetype = args.archetype;
+        rationale = "overridden via --archetype";
+        alternatives = [];
+        confidence = "user-specified";
+    }
+    else {
+        const pick = pickArchetype(detection);
+        archetype = pick.primary;
+        rationale = pick.rationale;
+        alternatives = pick.alternatives;
+        confidence = pick.confidence;
+    }
+    const compliance = suggestCompliance(detection, archetype);
+    log(`  ${dim("archetype:")} ${cyan(archetype)} ${dim(`(confidence: ${confidence})`)}`);
+    log(`  ${dim("rationale:")} ${rationale}`);
+    if (alternatives.length > 0) {
+        log(`  ${dim("alternatives:")} ${alternatives.join(", ")}`);
+    }
+    log(`  ${dim("suggested compliance:")} ${compliance.length > 0 ? compliance.join(", ") : "none"}`);
+    // Confirmation
+    if (!args.yes) {
+        log("");
+        const ok = await confirm(bold("Install great_cto plugin and bootstrap this project?"), true);
+        if (!ok) {
+            log("Aborted.");
+            return 1;
+        }
+    }
+    if (args.dryRun) {
+        log("");
+        log(yellow("dry-run: no changes made."));
+        log(`  would install plugin into ~/.claude/plugins/cache/local/great_cto/<version>/`);
+        log(`  would enable great_cto@local in ~/.claude/settings.json`);
+        log(`  would create .great_cto/PROJECT.md with archetype=${archetype}`);
+        return 0;
+    }
+    // ── 3. install plugin ────────────────────────────────────
+    step(3, 5, "installing plugin");
+    const existing = findInstalledVersions();
+    if (existing.length > 0 && !args.version && !args.force) {
+        log(`  ${dim("already-installed versions:")} ${existing.join(", ")}`);
+    }
+    const installResult = install({
+        version: args.version ?? undefined,
+        force: args.force,
+    });
+    if (installResult.alreadyInstalled) {
+        log(`  ${dim("version")} ${installResult.version} ${dim("already installed at")} ${installResult.pluginDir}`);
+        log(`  ${dim("(use --force to reinstall)")}`);
+    }
+    // ── 4. enable in settings ────────────────────────────────
+    step(4, 5, "enabling plugin in ~/.claude/settings.json");
+    const enableResult = enableGreatCto();
+    if (enableResult.alreadyEnabled) {
+        log(`  ${dim("already enabled in")} ${enableResult.settingsPath}`);
+    }
+    // ── 5. bootstrap ─────────────────────────────────────────
+    step(5, 5, "bootstrapping .great_cto/PROJECT.md");
+    const bs = bootstrap(args.dir, detection, archetype, compliance);
+    if (!bs.created) {
+        log(`  ${dim("PROJECT.md already exists at")} ${bs.projectMdPath} ${dim("— kept as-is")}`);
+    }
+    // ── done ─────────────────────────────────────────────────
+    log("");
+    log(green(bold("✓ great_cto is ready.")));
+    log("");
+    log(bold("Next steps:"));
+    log(`  1. ${dim("Restart Claude Code to pick up the plugin.")}`);
+    log(`  2. ${dim("Edit")} ${cyan(".great_cto/PROJECT.md")} ${dim("to refine goals and compliance.")}`);
+    log(`  3. ${dim("In Claude Code, run:")} ${cyan("/inbox")} ${dim("— see what needs attention.")}`);
+    log(`  4. ${dim("For existing repos:")} ${cyan("/audit")} ${dim("— gap analysis + prioritized task backlog.")}`);
+    log(`  5. ${dim("For new features:")} ${cyan('/start "describe what you\'re building"')}`);
+    log("");
+    log(dim("Docs: https://github.com/avelikiy/great_cto"));
+    log("");
+    return 0;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.command === "help") {
+        printHelp();
+        process.exit(0);
+    }
+    if (args.command === "version") {
+        // Version resolved in index.mjs or from package.json at runtime
+        try {
+            const { readFileSync } = await import("node:fs");
+            const { dirname, join } = await import("node:path");
+            const { fileURLToPath } = await import("node:url");
+            const here = dirname(fileURLToPath(import.meta.url));
+            // dist or src; package.json is two levels up
+            for (const base of [here, join(here, ".."), join(here, "..", "..")]) {
+                const p = join(base, "package.json");
+                try {
+                    const pkg = JSON.parse(readFileSync(p, "utf-8"));
+                    if (pkg.name === "great-cto" && pkg.version) {
+                        log(pkg.version);
+                        process.exit(0);
+                    }
+                }
+                catch { /* keep searching */ }
+            }
+            log("0.0.0");
+        }
+        catch {
+            log("0.0.0");
+        }
+        process.exit(0);
+    }
+    try {
+        const code = await runInit(args);
+        process.exit(code);
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(1);
+    }
+}
+await main();

package/dist/settings.js

@@ -0,0 +1,56 @@
+// Atomic merge of enabledPlugins into ~/.claude/settings.json.
+// Preserves all other keys. Backup-aware.
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { dim, success, warn } from "./ui.js";
+export function getSettingsPath() {
+    return join(homedir(), ".claude", "settings.json");
+}
+export function enableGreatCto() {
+    const path = getSettingsPath();
+    const pluginKey = "great_cto@local";
+    const backupPath = existsSync(path) ? `${path}.bak-${Date.now()}` : null;
+    mkdirSync(dirname(path), { recursive: true });
+    // Read existing
+    let existing = {};
+    if (existsSync(path)) {
+        try {
+            const raw = readFileSync(path, "utf-8");
+            if (raw.trim())
+                existing = JSON.parse(raw);
+        }
+        catch (e) {
+            warn(`${path} exists but is not valid JSON — leaving it alone.`);
+            warn(`Create or fix it manually and add: { "enabledPlugins": { "${pluginKey}": true } }`);
+            return { settingsPath: path, enabled: false, alreadyEnabled: false, backupPath: null };
+        }
+        if (backupPath)
+            copyFileSync(path, backupPath);
+    }
+    // Check if already enabled
+    const currentEnabled = existing["enabledPlugins"];
+    if (currentEnabled &&
+        typeof currentEnabled === "object" &&
+        currentEnabled[pluginKey] === true) {
+        return { settingsPath: path, enabled: false, alreadyEnabled: true, backupPath: null };
+    }
+    // Merge
+    const enabledPlugins = currentEnabled && typeof currentEnabled === "object"
+        ? { ...currentEnabled }
+        : {};
+    enabledPlugins[pluginKey] = true;
+    existing["enabledPlugins"] = enabledPlugins;
+    // Atomic write: write to temp, rename
+    const tmp = `${path}.tmp-${Date.now()}`;
+    writeFileSync(tmp, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+    const { renameSync } = require("node:fs");
+    renameSync(tmp, path);
+    if (backupPath) {
+        success(`enabled ${pluginKey} in ~/.claude/settings.json ${dim(`(backup: ${backupPath})`)}`);
+    }
+    else {
+        success(`created ~/.claude/settings.json with ${pluginKey} enabled`);
+    }
+    return { settingsPath: path, enabled: true, alreadyEnabled: false, backupPath };
+}

package/dist/ui.js

@@ -0,0 +1,55 @@
+// Minimal terminal UI: colors, logging, prompts. Zero deps.
+const isTTY = process.stdout.isTTY && process.env.NO_COLOR !== "1";
+function wrap(code) {
+    return (s) => (isTTY ? `\x1b[${code}m${s}\x1b[0m` : s);
+}
+export const bold = wrap("1");
+export const dim = wrap("2");
+export const red = wrap("31");
+export const green = wrap("32");
+export const yellow = wrap("33");
+export const blue = wrap("34");
+export const magenta = wrap("35");
+export const cyan = wrap("36");
+export const gray = wrap("90");
+export function log(msg = "") {
+    process.stdout.write(msg + "\n");
+}
+export function error(msg) {
+    process.stderr.write(red("error: ") + msg + "\n");
+}
+export function warn(msg) {
+    process.stderr.write(yellow("warning: ") + msg + "\n");
+}
+export function step(n, total, msg) {
+    log(cyan(`[${n}/${total}]`) + " " + msg);
+}
+export function success(msg) {
+    log(green("✓") + " " + msg);
+}
+export function banner() {
+    if (!isTTY) {
+        log("great-cto");
+        return;
+    }
+    log("");
+    log(bold(cyan("  great_cto")) + dim(" — SDLC pipeline plugin for Claude Code"));
+    log(dim("  https://github.com/avelikiy/great_cto"));
+    log("");
+}
+export async function confirm(question, defaultYes = true) {
+    if (!process.stdin.isTTY)
+        return defaultYes;
+    const hint = defaultYes ? dim("[Y/n]") : dim("[y/N]");
+    process.stdout.write(question + " " + hint + " ");
+    return new Promise((resolve) => {
+        process.stdin.setEncoding("utf-8");
+        process.stdin.once("data", (data) => {
+            const ans = String(data).trim().toLowerCase();
+            if (ans === "")
+                resolve(defaultYes);
+            else
+                resolve(ans === "y" || ans === "yes");
+        });
+    });
+}

package/index.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Entry point. Loads compiled src/main.js or runs src/main.ts directly in dev.
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const compiled = join(__dirname, "dist", "main.js");
+const source = join(__dirname, "src", "main.ts");
+
+if (existsSync(compiled)) {
+  await import(compiled);
+} else if (existsSync(source)) {
+  // Node 22 supports --experimental-strip-types via import for .ts
+  await import(source);
+} else {
+  console.error("great-cto: no entry point found. Did you run `npm run build`?");
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "great-cto",
+  "version": "0.1.0",
+  "description": "One command install for the great_cto Claude Code plugin. Auto-detects your stack, picks the right archetype, bootstraps PROJECT.md.",
+  "keywords": [
+    "claude-code",
+    "plugin",
+    "sdlc",
+    "agent",
+    "ai",
+    "cli",
+    "installer",
+    "cto",
+    "great-cto"
+  ],
+  "homepage": "https://github.com/avelikiy/great_cto",
+  "license": "MIT",
+  "author": "Oleksandr Velykyi",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avelikiy/great_cto.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "great-cto": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "dist/",
+    "README.md"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test 'tests/*.test.ts'",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "22.15.3",
+    "typescript": "5.8.3"
+  },
+  "engines": {
+    "node": ">=22.6.0"
+  }
+}