@contextforge/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yashwanth Krishna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import pc5 from "picocolors";
+
+// src/commands/add.ts
+import {
+  addPackToConfig,
+  cacheRemotePacks,
+  findPack,
+  loadConfig,
+  loadRegistry,
+  packMatchesProject,
+  readPackageJson,
+  saveConfig,
+  syncProject
+} from "@contextforge/core";
+import pc2 from "picocolors";
+
+// src/format.ts
+import pc from "picocolors";
+function yesNo(value) {
+  return value ? pc.green("yes") : pc.dim("no");
+}
+function formatAnalysis(analysis) {
+  const testing = [
+    analysis.testing.vitest && "Vitest",
+    analysis.testing.jest && "Jest",
+    analysis.testing.playwright && "Playwright"
+  ].filter(Boolean).join(", ");
+  return [
+    pc.bold("ContextForge detected:"),
+    "",
+    `Framework: ${analysis.framework}`,
+    `Language: ${analysis.language}`,
+    `Package manager: ${analysis.packageManager}`,
+    `Tailwind CSS: ${yesNo(analysis.styling.tailwind)}`,
+    `shadcn/ui: ${yesNo(analysis.styling.shadcn)}`,
+    `Prisma: ${yesNo(analysis.database.prisma)}`,
+    `Drizzle: ${yesNo(analysis.database.drizzle)}`,
+    `Testing: ${testing || "not detected"}`,
+    ""
+  ].join("\n");
+}
+function formatGeneratedFiles(files) {
+  if (files.length === 0) {
+    return pc.dim("No files generated.");
+  }
+  return ["Generated:", ...files.map((file) => `${pc.green("OK")} ${file}`)].join("\n");
+}
+function formatDoctorReport(report) {
+  const lines = [pc.bold("ContextForge Doctor"), ""];
+  for (const check of report.checks) {
+    lines.push(`${pc.green("OK")} ${check}`);
+  }
+  if (report.issues.length === 0) {
+    lines.push("", pc.green("No issues found."));
+    return lines.join("\n");
+  }
+  lines.push("", pc.bold("Issues:"));
+  for (const issue of report.issues) {
+    const marker = issue.level === "error" ? pc.red("ERR") : pc.yellow("WARN");
+    lines.push(`${marker} ${issue.message}`);
+  }
+  lines.push("", "Run:", "npx @contextforge/cli sync");
+  return lines.join("\n");
+}
+
+// src/registryOptions.ts
+import { DEFAULT_REGISTRY_SOURCES } from "@contextforge/core";
+function collectRegistryOption(value, previous = []) {
+  return [...previous, value];
+}
+function envRegistries() {
+  return (process.env.CONTEXTFORGE_REGISTRY_URL ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+}
+function resolveRegistrySources(config, options) {
+  const configured = config?.registries?.length ? config.registries : DEFAULT_REGISTRY_SOURCES;
+  return [.../* @__PURE__ */ new Set([...configured, ...envRegistries(), ...options?.registry ?? []])];
+}
+
+// src/commands/add.ts
+async function addCommand(packName, options = {}) {
+  const root = process.cwd();
+  const config = await loadConfig(root);
+  const registrySources = resolveRegistrySources(config, options);
+  const registry = await loadRegistry({ root, sources: registrySources });
+  const pack = findPack(registry, packName);
+  if (!pack) {
+    throw new Error(`Unknown pack "${packName}".`);
+  }
+  const packageJson = await readPackageJson(root);
+  const compatible = await packMatchesProject(pack, root, packageJson);
+  const alreadyInstalled = config.packs.includes(packName);
+  const nextConfig = {
+    ...addPackToConfig(config, packName),
+    registries: registrySources
+  };
+  if (!compatible) {
+    console.log(
+      pc2.yellow(
+        `${packName} does not match the current project detection hints. Adding it anyway; run doctor if this was intentional.`
+      )
+    );
+  }
+  await cacheRemotePacks(root, [pack]);
+  await saveConfig(root, nextConfig);
+  const result = await syncProject(root, nextConfig);
+  console.log(
+    alreadyInstalled ? pc2.yellow(`${packName} was already installed. Synced generated files.`) : pc2.green(`Added ${packName}.`)
+  );
+  console.log(formatGeneratedFiles(result.generatedFiles));
+}
+
+// src/commands/doctor.ts
+import { doctorProject } from "@contextforge/core";
+async function doctorCommand() {
+  const report = await doctorProject(process.cwd());
+  console.log(formatDoctorReport(report));
+  if (report.issues.some((issue) => issue.level === "error")) {
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/init.ts
+import { checkbox } from "@inquirer/prompts";
+import {
+  DEFAULT_TOOLS,
+  cacheRemotePacks as cacheRemotePacks2,
+  createConfig,
+  detectProject,
+  loadRegistry as loadRegistry2,
+  recommendPacks,
+  saveConfig as saveConfig2,
+  syncProject as syncProject2
+} from "@contextforge/core";
+import ora from "ora";
+import pc3 from "picocolors";
+var TOOL_LABELS = {
+  codex: "Codex",
+  claude: "Claude Code",
+  cursor: "Cursor",
+  copilot: "GitHub Copilot"
+};
+function canPrompt() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function selectTools() {
+  if (!canPrompt()) {
+    return DEFAULT_TOOLS;
+  }
+  return checkbox({
+    message: "Which AI tools should ContextForge configure?",
+    required: true,
+    choices: DEFAULT_TOOLS.map((tool) => ({
+      name: TOOL_LABELS[tool],
+      value: tool,
+      checked: true
+    }))
+  });
+}
+async function selectPacks(registry, recommended) {
+  if (registry.length === 0) {
+    return [];
+  }
+  if (!canPrompt()) {
+    return recommended;
+  }
+  const recommendedNames = new Set(recommended.map((pack) => pack.name));
+  const selectedNames = await checkbox({
+    message: "Which instruction packs should be installed?",
+    required: true,
+    choices: registry.map((pack) => ({
+      name: `${pack.title} (${pack.name})`,
+      value: pack.name,
+      description: pack.description,
+      checked: recommendedNames.has(pack.name)
+    }))
+  });
+  return registry.filter((pack) => selectedNames.includes(pack.name));
+}
+async function initCommand(options = {}) {
+  const root = process.cwd();
+  const registrySources = resolveRegistrySources(void 0, options);
+  const spinner = ora("Detecting project").start();
+  const [analysis, registry] = await Promise.all([
+    detectProject(root),
+    loadRegistry2({ root, sources: registrySources })
+  ]);
+  const recommended = recommendPacks(analysis, registry);
+  spinner.succeed("Project detected");
+  console.log(formatAnalysis(analysis));
+  if (recommended.length > 0) {
+    console.log(pc3.bold("Recommended packs:"));
+    for (const pack of recommended) {
+      console.log(`${pc3.green("OK")} ${pack.name}`);
+    }
+    console.log("");
+  } else if (registry.length === 0) {
+    console.log(
+      pc3.yellow("No packs were available from the official registry. Check your network or run with a private --registry URL.")
+    );
+    console.log("");
+  }
+  const tools = await selectTools();
+  const packs = await selectPacks(registry, recommended);
+  await cacheRemotePacks2(root, packs);
+  const initialConfig = createConfig(analysis, packs, tools, registrySources);
+  await saveConfig2(root, initialConfig);
+  const result = await syncProject2(root, initialConfig);
+  console.log(pc3.green("ContextForge initialized."));
+  console.log(formatGeneratedFiles(result.generatedFiles));
+}
+
+// src/commands/sync.ts
+import { loadConfig as loadConfig2, syncProject as syncProject3 } from "@contextforge/core";
+import pc4 from "picocolors";
+async function syncCommand(options = {}) {
+  const root = process.cwd();
+  const config = await loadConfig2(root);
+  const result = await syncProject3(root, {
+    ...config,
+    registries: resolveRegistrySources(config, options)
+  });
+  console.log(pc4.green("ContextForge synced."));
+  console.log(formatGeneratedFiles(result.generatedFiles));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("contextforge").description("Make existing codebases AI-agent ready").version("0.1.0");
+program.command("init").description("Initialize AI-agent instructions").option("--registry <url>", "Static remote registry index URL", collectRegistryOption, []).action(initCommand);
+program.command("add").argument("<pack>").description("Add an instruction pack").option("--registry <url>", "Static remote registry index URL", collectRegistryOption, []).action(addCommand);
+program.command("sync").description("Sync generated AI instruction files").option("--registry <url>", "Static remote registry index URL", collectRegistryOption, []).action(syncCommand);
+program.command("doctor").description("Check whether AI instructions match the repo").action(doctorCommand);
+program.parseAsync().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(pc5.red(`Error: ${message}`));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@contextforge/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "contextforge": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^7.8.0",
+    "commander": "^14.0.0",
+    "ora": "^8.2.0",
+    "picocolors": "^1.1.1",
+    "@contextforge/core": "0.1.0"
+  },
+  "devDependencies": {
+    "tsx": "^4.20.0"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "test": "vitest --passWithNoTests"
+  }
+}