claudeinone-cli 1.0.0

package/README.md

@@ -0,0 +1,72 @@
+# claudeinone-cli
+
+Production-grade framework for [Claude Code](https://claude.ai/code). Installs 213 skill guides, 37 specialist agents, and 95 `/co:` commands into any project — giving Claude expert-level knowledge across every major framework, pattern, and deployment strategy.
+
+## Install
+
+```bash
+npm install -g claudeinone-cli
+```
+
+## Usage
+
+```bash
+# Install into an existing project
+cd my-project
+co init
+
+# Create a new project
+co new my-app
+
+# Verify installation
+co doctor
+
+# Update to latest kit
+co update
+```
+
+## What Gets Installed
+
+```
+my-project/
+├── CLAUDE.md                    # Master system prompt
+├── .claude/
+│   ├── skills/                  # 213 production skill guides
+│   ├── agents/                  # 37 specialist agents
+│   ├── commands/co/             # 95 /co: slash commands
+│   ├── settings.json
+│   └── .ck.json
+├── docs/
+├── plans/
+└── journals/
+```
+
+## Commands in Claude Code
+
+All ClaudeInOne commands are namespaced under `/co:` to avoid collision with Claude Code built-ins.
+
+| Category | Commands |
+|----------|----------|
+| Plan | `/co:plan`, `/co:plan-fast`, `/co:plan-hard`, `/co:plan-parallel` |
+| Build | `/co:cook`, `/co:bootstrap`, `/co:scaffold`, `/co:new-feature` |
+| Fix | `/co:fix`, `/co:fix-fast`, `/co:fix-hard`, `/co:fix-types`, `/co:fix-ui` |
+| Review | `/co:review-codebase`, `/co:review-security`, `/co:review-perf`, `/co:review-a11y` |
+| Test | `/co:test`, `/co:test-gen`, `/co:test-ui` |
+| Git | `/co:git-cm`, `/co:git-cp`, `/co:pr` |
+| Deploy | `/co:docker`, `/co:k8s`, `/co:terraform`, `/co:deploy` |
+| Docs | `/co:docs-init`, `/co:docs-update`, `/co:docs-readme` |
+
+## CLI Reference
+
+```
+co init [--yes] [--global] [--exclude <pattern>]
+co new <name> [--dir <path>]
+co doctor [--fix] [--report]
+co update
+co versions
+co uninstall [--global]
+```
+
+## License
+
+MIT

package/dist/commands/doctor.js

@@ -0,0 +1,84 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function exists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runDoctor(options) {
+    const cwd = process.cwd();
+    const checks = [];
+    const issues = [];
+    try {
+        await execFileAsync("claude", ["--version"], { timeout: 5_000 });
+        checks.push({ name: "claude executable", ok: true });
+    }
+    catch {
+        checks.push({ name: "claude executable", ok: false, details: "Claude Code CLI is not available in PATH." });
+        issues.push("Install Claude Code CLI and ensure `claude --version` works.");
+    }
+    const claudeDir = path.join(cwd, ".claude");
+    const hasClaudeDir = await exists(claudeDir);
+    checks.push({ name: ".claude directory", ok: hasClaudeDir });
+    const required = [
+        path.join(claudeDir, "commands"),
+        path.join(claudeDir, "agents"),
+        path.join(claudeDir, "skills"),
+        path.join(claudeDir, "settings.json"),
+        path.join(claudeDir, ".ck.json")
+    ];
+    for (const req of required) {
+        checks.push({ name: path.relative(cwd, req), ok: await exists(req) });
+    }
+    const rootRequired = [
+        path.join(cwd, "CLAUDE.md"),
+        path.join(cwd, "docs"),
+        path.join(cwd, "plans"),
+        path.join(cwd, "journals")
+    ];
+    for (const req of rootRequired) {
+        checks.push({ name: path.relative(cwd, req), ok: await exists(req) });
+    }
+    if (options.fix) {
+        await fs.mkdir(path.join(claudeDir, "commands"), { recursive: true });
+        await fs.mkdir(path.join(claudeDir, "agents"), { recursive: true });
+        await fs.mkdir(path.join(claudeDir, "skills"), { recursive: true });
+        await fs.mkdir(path.join(cwd, "docs"), { recursive: true });
+        await fs.mkdir(path.join(cwd, "plans"), { recursive: true });
+        await fs.mkdir(path.join(cwd, "journals"), { recursive: true });
+        const ckJson = path.join(claudeDir, ".ck.json");
+        if (!(await exists(ckJson))) {
+            await fs.writeFile(ckJson, JSON.stringify({ version: "1.0.0", kit: "claudeinone" }, null, 2) + "\n", "utf8");
+        }
+        const settings = path.join(claudeDir, "settings.json");
+        if (!(await exists(settings))) {
+            await fs.writeFile(settings, JSON.stringify({ hooks: { preTool: [], postTool: [] }, permissions: { default: "ask", allow: [] } }, null, 2) + "\n", "utf8");
+        }
+        const claudeMd = path.join(cwd, "CLAUDE.md");
+        if (!(await exists(claudeMd))) {
+            await fs.writeFile(claudeMd, "# ClaudeInOne\n", "utf8");
+        }
+    }
+    const failed = checks.filter((c) => !c.ok);
+    if (options.report) {
+        console.log(JSON.stringify({ ok: failed.length === 0, checks, issues }, null, 2));
+        return;
+    }
+    for (const check of checks) {
+        console.log(`${check.ok ? "OK" : "FAIL"}  ${check.name}`);
+    }
+    if (failed.length > 0) {
+        console.log("Doctor found issues. Re-run with --fix to repair basic structure.");
+        process.exitCode = 1;
+    }
+    else {
+        console.log("Doctor check passed.");
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,105 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { installKit } from "../utils/installer.js";
+import { getFileDiffs } from "../utils/merger.js";
+import { backupPaths } from "../utils/backup.js";
+import { getGlobalClaudeDir } from "../utils/platform.js";
+async function readKitVersion(kitRoot) {
+    const configPath = path.join(kitRoot, ".claude", ".ck.json");
+    const raw = await fs.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? "1.0.0";
+}
+async function resolveConflictActions(conflicts) {
+    const skipPaths = new Set();
+    if (conflicts.length === 0)
+        return skipPaths;
+    const rl = readline.createInterface({ input, output });
+    let overwriteAll = false;
+    let skipAll = false;
+    try {
+        for (const rel of conflicts) {
+            if (overwriteAll)
+                continue;
+            if (skipAll) {
+                skipPaths.add(rel);
+                continue;
+            }
+            const answer = (await rl.question(`Conflict: ${rel}\nChoose [o]verwrite, [s]kip, overwrite [a]ll, skip a[l]l (default: s): `))
+                .trim()
+                .toLowerCase();
+            if (answer === "a") {
+                overwriteAll = true;
+            }
+            else if (answer === "l") {
+                skipAll = true;
+                skipPaths.add(rel);
+            }
+            else if (answer === "o") {
+                // overwrite this file
+            }
+            else {
+                skipPaths.add(rel);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+    return skipPaths;
+}
+export async function runInit(options) {
+    const filePath = fileURLToPath(import.meta.url);
+    const cliRoot = path.resolve(path.dirname(filePath), "..", "..");
+    const kitRoot = path.join(cliRoot, "kit");
+    const targetRoot = options.global ? getGlobalClaudeDir() : process.cwd();
+    if (options.global) {
+        const globalClaudeDir = getGlobalClaudeDir();
+        const diffs = await getFileDiffs(path.join(kitRoot, ".claude"), globalClaudeDir);
+        const conflicts = diffs.filter((d) => d.targetExists && !d.identical).map((d) => d.relPath);
+        let skipPaths = new Set();
+        if (conflicts.length > 0 && !options.yes) {
+            console.log(`Detected ${conflicts.length} changed global file conflicts.`);
+            skipPaths = await resolveConflictActions(conflicts);
+        }
+        if (conflicts.length > 0 && skipPaths.size < conflicts.length) {
+            const backup = await backupPaths(globalClaudeDir, ["."]);
+            if (backup)
+                console.log(`Backup created at ${backup}`);
+        }
+        await installKit({
+            kitRoot,
+            destinationRoot: globalClaudeDir,
+            sourceSubdir: ".claude",
+            extraExcludes: options.exclude ?? [],
+            skipPaths: [...skipPaths]
+        });
+        console.log(`Installed global kit at ${globalClaudeDir}`);
+        return;
+    }
+    const diffs = await getFileDiffs(kitRoot, targetRoot);
+    const conflicts = diffs.filter((d) => d.targetExists && !d.identical).map((d) => d.relPath);
+    let skipPaths = new Set();
+    if (conflicts.length > 0 && !options.yes) {
+        console.log(`Detected ${conflicts.length} local file conflicts.`);
+        skipPaths = await resolveConflictActions(conflicts);
+    }
+    if (conflicts.length > 0 && skipPaths.size < conflicts.length) {
+        const backup = await backupPaths(targetRoot, [".claude", "CLAUDE.md", "docs", "plans", "journals"]);
+        if (backup)
+            console.log(`Backup created at ${backup}`);
+    }
+    await installKit({
+        kitRoot,
+        destinationRoot: targetRoot,
+        extraExcludes: options.exclude ?? [],
+        skipPaths: [...skipPaths]
+    });
+    const version = options.version ?? (await readKitVersion(kitRoot));
+    await fs.mkdir(path.join(targetRoot, ".claude"), { recursive: true });
+    await fs.writeFile(path.join(targetRoot, ".claude", ".ck.json"), JSON.stringify({ version, kit: options.kit }, null, 2) + "\n", "utf8");
+    console.log(`Installed ClaudeInOne (${options.kit}) v${version} in ${targetRoot}`);
+}

package/dist/commands/new.js

@@ -0,0 +1,26 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { runInit } from "./init.js";
+const execFileAsync = promisify(execFile);
+export async function runNew(name, options) {
+    const baseDir = options.dir ? path.resolve(options.dir) : process.cwd();
+    const projectDir = path.join(baseDir, name);
+    await fs.mkdir(projectDir, { recursive: true });
+    try {
+        await execFileAsync("git", ["init"], { cwd: projectDir });
+    }
+    catch {
+        // Git init is best-effort.
+    }
+    const previousCwd = process.cwd();
+    process.chdir(projectDir);
+    try {
+        await runInit({ kit: options.kit, yes: true });
+    }
+    finally {
+        process.chdir(previousCwd);
+    }
+    console.log(`Created new ClaudeInOne project at ${projectDir}`);
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,25 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getGlobalClaudeDir } from "../utils/platform.js";
+async function removeIfExists(target) {
+    await fs.rm(target, { recursive: true, force: true });
+}
+export async function runUninstall(options) {
+    const root = options.global ? getGlobalClaudeDir() : process.cwd();
+    if (options.global) {
+        await removeIfExists(path.join(root, "commands"));
+        await removeIfExists(path.join(root, "agents"));
+        await removeIfExists(path.join(root, "skills"));
+        await removeIfExists(path.join(root, "settings.json"));
+        await removeIfExists(path.join(root, ".ck.json"));
+        await removeIfExists(path.join(root, ".ckignore"));
+        console.log(`Removed ClaudeKit global files from ${root}`);
+        return;
+    }
+    await removeIfExists(path.join(root, ".claude"));
+    await removeIfExists(path.join(root, "CLAUDE.md"));
+    await removeIfExists(path.join(root, "docs"));
+    await removeIfExists(path.join(root, "plans"));
+    await removeIfExists(path.join(root, "journals"));
+    console.log(`Removed ClaudeKit files from ${root}`);
+}

package/dist/commands/update.js

@@ -0,0 +1,17 @@
+import { spawn } from "node:child_process";
+export async function runUpdate() {
+    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    await new Promise((resolve, reject) => {
+        const child = spawn(npmCommand, ["install", "-g", "claudekit-cli@latest"], {
+            stdio: "inherit"
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`npm exited with code ${code ?? "unknown"}`));
+        });
+    });
+    console.log("ClaudeKit CLI updated to latest.");
+}

package/dist/commands/versions.js

@@ -0,0 +1,36 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function readJson(filePath) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function runVersions() {
+    const filePath = fileURLToPath(import.meta.url);
+    const cliRoot = path.resolve(path.dirname(filePath), "..", "..");
+    const pkg = await readJson(path.join(cliRoot, "package.json"));
+    const kit = await readJson(path.join(cliRoot, "kit", ".claude", ".ck.json"));
+    console.log(`cli-installed: ${pkg?.version ?? "unknown"}`);
+    console.log(`kit-bundled: ${kit?.version ?? "unknown"}`);
+    try {
+        const { stdout } = await execFileAsync("npm", ["view", "claudeinone-cli", "versions", "--json"], { timeout: 10_000 });
+        const parsed = JSON.parse(stdout.trim());
+        const versions = Array.isArray(parsed) ? parsed : [parsed];
+        const latest = versions[versions.length - 1];
+        console.log(`registry-latest: ${latest}`);
+        console.log("registry-versions:");
+        for (const version of versions.slice(-15)) {
+            console.log(` - ${version}`);
+        }
+    }
+    catch {
+        console.log("registry-latest: unavailable");
+    }
+}

package/dist/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { runInit } from "./commands/init.js";
+import { runNew } from "./commands/new.js";
+import { runDoctor } from "./commands/doctor.js";
+import { runVersions } from "./commands/versions.js";
+import { runUpdate } from "./commands/update.js";
+import { runUninstall } from "./commands/uninstall.js";
+const program = new Command();
+program.name("co").description("ClaudeInOne CLI").version("1.0.0");
+program
+    .command("init")
+    .option("--kit <kit>", "kit name", "claudeinone")
+    .option("-g, --global", "install globally into ~/.claude")
+    .option("-y, --yes", "overwrite without interactive prompts")
+    .option("--exclude <pattern...>", "extra files/directories to exclude")
+    .option("--version <version>", "override kit version metadata")
+    .action(async (opts) => {
+    await runInit({
+        kit: opts.kit,
+        global: Boolean(opts.global),
+        yes: Boolean(opts.yes),
+        exclude: opts.exclude,
+        version: opts.version
+    });
+});
+program
+    .command("new <name>")
+    .option("--kit <kit>", "kit name", "claudeinone")
+    .option("--dir <path>", "base directory")
+    .action(async (name, opts) => {
+    await runNew(name, { kit: opts.kit, dir: opts.dir });
+});
+program
+    .command("doctor")
+    .option("--fix", "repair basic structure")
+    .option("--report", "emit JSON report")
+    .action(async (opts) => {
+    await runDoctor({ fix: Boolean(opts.fix), report: Boolean(opts.report) });
+});
+program.command("versions").action(async () => runVersions());
+program.command("update").action(async () => runUpdate());
+program
+    .command("uninstall")
+    .option("-g, --global", "remove global install")
+    .action(async (opts) => runUninstall({ global: Boolean(opts.global) }));
+program.parseAsync(process.argv);

package/dist/utils/backup.js

@@ -0,0 +1,31 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+async function exists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function backupPaths(baseDir, relativePaths) {
+    const existing = [];
+    for (const rel of relativePaths) {
+        const full = path.join(baseDir, rel);
+        if (await exists(full))
+            existing.push(rel);
+    }
+    if (existing.length === 0)
+        return null;
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupDir = path.join(baseDir, `.claude.backup.${stamp}`);
+    await fs.mkdir(backupDir, { recursive: true });
+    for (const rel of existing) {
+        const src = path.join(baseDir, rel);
+        const dest = path.join(backupDir, rel);
+        await fs.mkdir(path.dirname(dest), { recursive: true });
+        await fs.cp(src, dest, { recursive: true, force: true });
+    }
+    return backupDir;
+}

package/dist/utils/installer.js

@@ -0,0 +1,52 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+function normalizePatterns(patterns) {
+    return patterns.map((p) => p.trim()).filter(Boolean);
+}
+function shouldSkip(relPath, patterns) {
+    const p = relPath.replaceAll("\\", "/");
+    return patterns.some((pattern) => {
+        const v = pattern.replaceAll("\\", "/");
+        return p === v || p.startsWith(`${v}/`) || path.basename(p) === v;
+    });
+}
+async function readIgnoreFile(kitRoot) {
+    const ignorePath = path.join(kitRoot, ".claude", ".ckignore");
+    try {
+        const raw = await fs.readFile(ignorePath, "utf8");
+        return raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith("#"));
+    }
+    catch {
+        return [];
+    }
+}
+async function copyRecursive(srcRoot, currentSrc, destRoot, patterns) {
+    const entries = await fs.readdir(currentSrc, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = path.join(currentSrc, entry.name);
+        const rel = path.relative(srcRoot, src);
+        if (shouldSkip(rel, patterns))
+            continue;
+        const dest = path.join(destRoot, rel);
+        if (entry.isDirectory()) {
+            await fs.mkdir(dest, { recursive: true });
+            await copyRecursive(srcRoot, src, destRoot, patterns);
+        }
+        else if (entry.isFile() || entry.isSymbolicLink()) {
+            await fs.mkdir(path.dirname(dest), { recursive: true });
+            await fs.cp(src, dest, { force: true, dereference: false });
+        }
+    }
+}
+export async function installKit(options) {
+    const sourceRoot = options.sourceSubdir
+        ? path.join(options.kitRoot, options.sourceSubdir)
+        : options.kitRoot;
+    const ignores = await readIgnoreFile(options.kitRoot);
+    const patterns = normalizePatterns([...(options.extraExcludes ?? []), ...(options.skipPaths ?? []), ...ignores]);
+    await fs.mkdir(options.destinationRoot, { recursive: true });
+    await copyRecursive(sourceRoot, sourceRoot, options.destinationRoot, patterns);
+}

package/dist/utils/merger.js

@@ -0,0 +1,56 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+async function collectFiles(base, cursor = "") {
+    const root = path.join(base, cursor);
+    const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    const out = [];
+    for (const entry of entries) {
+        const rel = path.join(cursor, entry.name);
+        const full = path.join(base, rel);
+        if (entry.isDirectory()) {
+            out.push(...(await collectFiles(base, rel)));
+        }
+        else if (entry.isFile()) {
+            out.push(rel);
+        }
+        else {
+            const stat = await fs.stat(full);
+            if (stat.isFile())
+                out.push(rel);
+        }
+    }
+    return out;
+}
+async function isSameFile(sourcePath, targetPath) {
+    try {
+        const [a, b] = await Promise.all([fs.readFile(sourcePath), fs.readFile(targetPath)]);
+        return a.equals(b);
+    }
+    catch {
+        return false;
+    }
+}
+export async function getFileDiffs(sourceRoot, targetRoot) {
+    const srcFiles = await collectFiles(sourceRoot);
+    const diffs = [];
+    for (const rel of srcFiles) {
+        const target = path.join(targetRoot, rel);
+        try {
+            const stat = await fs.stat(target);
+            if (!stat.isFile()) {
+                diffs.push({ relPath: rel, targetExists: true, identical: false });
+                continue;
+            }
+            const source = path.join(sourceRoot, rel);
+            diffs.push({ relPath: rel, targetExists: true, identical: await isSameFile(source, target) });
+        }
+        catch {
+            diffs.push({ relPath: rel, targetExists: false, identical: false });
+        }
+    }
+    return diffs.sort((a, b) => a.relPath.localeCompare(b.relPath));
+}
+export async function findConflicts(sourceRoot, targetRoot) {
+    const diffs = await getFileDiffs(sourceRoot, targetRoot);
+    return diffs.filter((d) => d.targetExists && !d.identical).map((d) => d.relPath);
+}

package/dist/utils/platform.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+import os from "node:os";
+export function getGlobalClaudeDir() {
+    if (process.platform === "win32") {
+        const base = process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+        return path.join(base, ".claude");
+    }
+    return path.join(os.homedir(), ".claude");
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "claudeinone-cli",
+  "version": "1.0.0",
+  "description": "Production-grade Claude Code framework — 213 skills, 37 agents, 95 /co: commands",
+  "type": "module",
+  "bin": {
+    "co": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "smoke": "bash ./scripts/smoke.sh",
+    "dev": "bun run src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "llm",
+    "developer-tools",
+    "cli",
+    "framework",
+    "skills",
+    "agents",
+    "commands"
+  ],
+  "author": "Abhi Poluri",
+  "license": "MIT",
+  "homepage": "https://github.com/AbhiPoluri/ClaudeInOne",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AbhiPoluri/ClaudeInOne.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AbhiPoluri/ClaudeInOne/issues"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.6",
+    "typescript": "^5.6.3"
+  }
+}