@contextforge/cli 0.1.2 → 0.1.5

package/dist/index.js

@@ -2,19 +2,14 @@
 
 // src/index.ts
 import { Command } from "commander";
-import pc5 from "picocolors";
+import pc7 from "picocolors";
 
 // src/commands/add.ts
 import {
-  addPackToConfig,
-  cacheRemotePacks,
-  findPack,
-  loadConfig,
-  loadRegistry,
-  packMatchesProject,
-  readPackageJson,
-  saveConfig,
-  syncProject
+  fetchRegistry,
+  findPackSummary,
+  installPackAndSync,
+  loadConfig
 } from "@contextforge/core";
 import pc2 from "picocolors";
 
@@ -39,6 +34,7 @@ function formatAnalysis(analysis) {
     `shadcn/ui: ${yesNo(analysis.styling.shadcn)}`,
     `Prisma: ${yesNo(analysis.database.prisma)}`,
     `Drizzle: ${yesNo(analysis.database.drizzle)}`,
+    `Supabase: ${yesNo(analysis.services.supabase)}`,
     `Testing: ${testing || "not detected"}`,
     ""
   ].join("\n");
@@ -68,7 +64,7 @@ function formatDoctorReport(report) {
 }
 
 // src/registryOptions.ts
-import { DEFAULT_REGISTRY_SOURCES } from "@contextforge/core";
+import { OFFICIAL_REGISTRY_URL } from "@contextforge/core";
 function collectRegistryOption(value, previous = []) {
   return [...previous, value];
 }
@@ -76,47 +72,55 @@ 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 ?? []])];
+  const configured = config?.registry ? [config.registry] : [OFFICIAL_REGISTRY_URL];
+  return [.../* @__PURE__ */ new Set([...options?.registry ?? [], ...envRegistries(), ...configured])];
+}
+function resolveRegistryUrl(config, options) {
+  return resolveRegistrySources(config, options)[0] ?? OFFICIAL_REGISTRY_URL;
 }
 
 // src/commands/add.ts
+async function loadOptionalConfig(root) {
+  try {
+    return await loadConfig(root);
+  } catch {
+    return void 0;
+  }
+}
 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);
+  const config = await loadOptionalConfig(root);
+  const registryUrl = resolveRegistryUrl(config, options);
+  const registry = await fetchRegistry(registryUrl);
+  const summary = findPackSummary(registry, packName);
+  if (!summary) {
+    throw new Error(`Unknown ContextForge pack "${packName}". Run \`npx @contextforge/cli list\` to see available packs.`);
+  }
+  const alreadyConfigured = config?.installedPacks.includes(packName) ?? false;
+  if (alreadyConfigured && !options.force) {
+    console.log(pc2.yellow(`${packName} is already installed. Run \`npx @contextforge/cli sync\` to refresh it.`));
+    return;
+  }
+  if (options.dryRun) {
+    console.log(pc2.cyan(`Dry run: ${packName} would be downloaded from ${registryUrl}.`));
+    console.log(pc2.dim(`Pack path: ${summary.path}`));
+    return;
+  }
+  const result = await installPackAndSync(root, registryUrl, packName, {
+    force: options.force,
+    dryRun: false
+  });
   console.log(
-    alreadyInstalled ? pc2.yellow(`${packName} was already installed. Synced generated files.`) : pc2.green(`Added ${packName}.`)
+    result.alreadyInstalled ? pc2.green(`Reinstalled ${packName}.`) : 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());
+async function doctorCommand(options = {}) {
+  const registry = options.registry?.at(-1);
+  const report = await doctorProject(process.cwd(), registry ? { registry } : void 0);
   console.log(formatDoctorReport(report));
   if (report.issues.some((issue) => issue.level === "error")) {
     process.exitCode = 1;
@@ -124,16 +128,17 @@ async function doctorCommand() {
 }
 
 // src/commands/init.ts
-import { checkbox } from "@inquirer/prompts";
+import { checkbox, confirm } from "@inquirer/prompts";
 import {
+  DEFAULT_CORE_PACKS,
   DEFAULT_TOOLS,
-  cacheRemotePacks as cacheRemotePacks2,
   createConfig,
   detectProject,
-  loadRegistry as loadRegistry2,
+  fetchRegistry as fetchRegistry2,
+  installPack,
+  missingMandatoryCorePacks,
   recommendPacks,
-  saveConfig as saveConfig2,
-  syncProject as syncProject2
+  syncProject
 } from "@contextforge/core";
 import ora from "ora";
 import pc3 from "picocolors";
@@ -143,6 +148,12 @@ var TOOL_LABELS = {
   cursor: "Cursor",
   copilot: "GitHub Copilot"
 };
+var CAPABILITY_PACKS = [
+  "system-design",
+  "frontend-system-design",
+  "api-design",
+  "test-driven-development"
+];
 function canPrompt() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
@@ -150,92 +161,186 @@ async function selectTools() {
   if (!canPrompt()) {
     return DEFAULT_TOOLS;
   }
-  return checkbox({
+  const selected = await checkbox({
     message: "Which AI tools should ContextForge configure?",
     required: true,
-    choices: DEFAULT_TOOLS.map((tool) => ({
-      name: TOOL_LABELS[tool],
-      value: tool,
+    choices: [
+      { name: "All agents", value: "all", checked: true },
+      ...DEFAULT_TOOLS.map((tool) => ({
+        name: TOOL_LABELS[tool],
+        value: tool,
+        checked: false
+      }))
+    ]
+  });
+  return selected.includes("all") ? DEFAULT_TOOLS : selected.filter((tool) => tool !== "all");
+}
+async function selectRecommendedPacks(recommended) {
+  if (recommended.length === 0) {
+    return [];
+  }
+  if (!canPrompt()) {
+    return [];
+  }
+  const wantsRecommendations = await confirm({
+    message: "Install recommended stack-specific packs?",
+    default: true
+  });
+  if (!wantsRecommendations) {
+    return [];
+  }
+  const selected = await checkbox({
+    message: "Select recommended packs to install",
+    choices: recommended.map((pack) => ({
+      name: `${pack.title} (${pack.name})`,
+      value: pack.name,
+      description: pack.description,
       checked: true
     }))
   });
+  return recommended.filter((pack) => selected.includes(pack.name));
 }
-async function selectPacks(registry, recommended) {
-  if (registry.length === 0) {
+async function selectCapabilityPacks(registryPacks) {
+  if (!canPrompt()) {
     return [];
   }
-  if (!canPrompt()) {
-    return recommended;
+  const available = CAPABILITY_PACKS.map(
+    (packName) => registryPacks.find((pack) => pack.name === packName)
+  ).filter((pack) => Boolean(pack));
+  if (available.length === 0) {
+    return [];
   }
-  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) => ({
+  const selected = await checkbox({
+    message: "Add optional architecture or testing packs?",
+    choices: available.map((pack) => ({
       name: `${pack.title} (${pack.name})`,
       value: pack.name,
       description: pack.description,
-      checked: recommendedNames.has(pack.name)
+      checked: false
     }))
   });
-  return registry.filter((pack) => selectedNames.includes(pack.name));
+  return available.filter((pack) => selected.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 registryUrl = resolveRegistryUrl(void 0, options);
+  const spinner = ora("Detecting project and fetching registry").start();
+  const [analysis, registry] = await Promise.all([detectProject(root), fetchRegistry2(registryUrl)]);
   const recommended = await recommendPacks(analysis, registry);
+  const missingMandatory = missingMandatoryCorePacks(registry);
   spinner.succeed("Project detected");
   console.log(formatAnalysis(analysis));
+  if (missingMandatory.length > 0) {
+    console.log(pc3.yellow(`Mandatory packs missing from registry: ${missingMandatory.join(", ")}`));
+    console.log("");
+  }
   if (recommended.length > 0) {
-    console.log(pc3.bold("Recommended packs:"));
+    console.log(pc3.bold("Recommended optional 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);
+  const optionalPacks = await selectRecommendedPacks(recommended);
+  const capabilityPacks = await selectCapabilityPacks(registry.packs);
+  const packNames = [
+    .../* @__PURE__ */ new Set([
+      ...DEFAULT_CORE_PACKS.filter((packName) => registry.packs.some((pack) => pack.name === packName)),
+      ...optionalPacks.map((pack) => pack.name),
+      ...capabilityPacks.map((pack) => pack.name)
+    ])
+  ];
+  for (const packName of packNames) {
+    await installPack(root, registryUrl, packName, { force: true });
+  }
+  const initialConfig = createConfig(
+    analysis,
+    packNames.map((name) => ({ name })),
+    tools,
+    registryUrl
+  );
+  const result = await syncProject(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";
+// src/commands/list.ts
+import { fetchRegistry as fetchRegistry3, listRegistryPacks } from "@contextforge/core";
 import pc4 from "picocolors";
+async function listCommand(options = {}) {
+  const registryUrl = resolveRegistryUrl(void 0, options);
+  const registry = await fetchRegistry3(registryUrl);
+  const packs = listRegistryPacks(registry);
+  const topics = /* @__PURE__ */ new Map();
+  for (const pack of packs) {
+    const topicPacks = topics.get(pack.topic) ?? [];
+    topicPacks.push(pack);
+    topics.set(pack.topic, topicPacks);
+  }
+  console.log(pc4.bold("ContextForge Registry"));
+  console.log(pc4.dim(registryUrl));
+  console.log("");
+  for (const [topic, topicPacks] of topics) {
+    console.log(pc4.bold(topic));
+    for (const pack of topicPacks) {
+      console.log(`  ${pc4.green(pack.name)} - ${pack.title}`);
+      if (pack.description) {
+        console.log(`    ${pc4.dim(pack.description)}`);
+      }
+    }
+    console.log("");
+  }
+}
+
+// src/commands/search.ts
+import { fetchRegistry as fetchRegistry4, searchRegistryPacks } from "@contextforge/core";
+import pc5 from "picocolors";
+async function searchCommand(query, options = {}) {
+  const registryUrl = resolveRegistryUrl(void 0, options);
+  const registry = await fetchRegistry4(registryUrl);
+  const results = searchRegistryPacks(registry, query);
+  if (results.length === 0) {
+    console.log(pc5.yellow(`No packs found for "${query}".`));
+    return;
+  }
+  console.log(pc5.bold(`ContextForge packs matching "${query}"`));
+  console.log("");
+  for (const pack of results) {
+    console.log(`${pc5.green(pack.name)} ${pc5.dim(`[${pack.topic}]`)}`);
+    console.log(`  ${pack.title}`);
+    if (pack.description) {
+      console.log(`  ${pc5.dim(pack.description)}`);
+    }
+  }
+}
+
+// src/commands/sync.ts
+import { loadConfig as loadConfig2, syncProject as syncProject2 } from "@contextforge/core";
+import pc6 from "picocolors";
 async function syncCommand(options = {}) {
   const root = process.cwd();
   const config = await loadConfig2(root);
-  const result = await syncProject3(root, {
+  const registry = resolveRegistryUrl(config, options);
+  const result = await syncProject2(root, {
     ...config,
-    registries: resolveRegistrySources(config, options)
+    registry
   });
-  console.log(pc4.green("ContextForge synced."));
+  console.log(pc6.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.2");
+program.name("contextforge").description("Make existing codebases AI-agent ready").version("0.1.5");
 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("add").argument("<pack>").description("Add an instruction pack").option("--registry <url>", "Static remote registry index URL", collectRegistryOption, []).option("--force", "Re-download and regenerate even when the pack is already installed").option("--dry-run", "Show what would be installed without writing files").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.command("doctor").description("Check whether AI instructions match the repo").option("--registry <url>", "Static remote registry index URL", collectRegistryOption, []).action(doctorCommand);
+program.command("list").description("List available instruction packs").option("--registry <url>", "Static remote registry index URL", collectRegistryOption, []).action(listCommand);
+program.command("search").argument("<query>").description("Search available instruction packs").option("--registry <url>", "Static remote registry index URL", collectRegistryOption, []).action(searchCommand);
 program.parseAsync().catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
-  console.error(pc5.red(`Error: ${message}`));
+  console.error(pc7.red(`Error: ${message}`));
   process.exitCode = 1;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextforge/cli",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "type": "module",
   "bin": {
     "contextforge": "dist/index.js"
@@ -13,7 +13,7 @@
     "commander": "^14.0.0",
     "ora": "^8.2.0",
     "picocolors": "^1.1.1",
-    "@contextforge/core": "0.1.2"
+    "@contextforge/core": "0.1.5"
   },
   "devDependencies": {
     "tsx": "^4.20.0"