@contextforge/core 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -327,9 +327,13 @@ declare const LockSchema: z.ZodObject<{
     registry: z.ZodString;
     resolvedAt: z.ZodString;
     packs: z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
         version: z.ZodString;
+        topic: z.ZodOptional<z.ZodString>;
+        classification: z.ZodOptional<z.ZodString>;
         path: z.ZodString;
         source: z.ZodString;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type ContextForgeLock = z.infer<typeof LockSchema>;
@@ -347,7 +351,7 @@ declare function loadConfig(root: string): Promise<ContextForgeConfig>;
 declare function saveConfig(root: string, config: ContextForgeConfig): Promise<void>;
 declare function addPackToConfig(config: ContextForgeConfig, packName: string): ContextForgeConfig;
 
-declare function downloadPackToContextForge(projectRoot: string, packName: string, packManifest: PackManifest, packUrl: string, timeoutMs?: number): Promise<InstalledPack>;
+declare function downloadPackToContextForge(_projectRoot: string, _packName: string, packManifest: PackManifest, packUrl: string, timeoutMs?: number): Promise<InstalledPack>;
 type InstallPackOptions = {
     force?: boolean;
     dryRun?: boolean;
@@ -361,7 +365,7 @@ type InstallPackResult = {
     summary?: RegistryPackSummary;
     packUrl?: string;
 };
-declare function installPack(projectRoot: string, registryUrl: string, packName: string, options?: InstallPackOptions): Promise<InstallPackResult>;
+declare function installPack(_projectRoot: string, registryUrl: string, packName: string, options?: InstallPackOptions): Promise<InstallPackResult>;
 
 declare function compileOutputs(config: ContextForgeConfig, packs: InstalledPack[], analysis: ProjectAnalysis): GeneratedFile[];
 

package/dist/index.js

@@ -247,15 +247,15 @@ async function readOptional(filePath) {
 function normalizePackFilePath(file) {
   return file.path.split(/[\\/]/u).join(path7.sep);
 }
-async function loadCachedPack(packRoot2) {
-  const manifestPath = path7.join(packRoot2, "pack.json");
+async function loadCachedPack(packRoot) {
+  const manifestPath = path7.join(packRoot, "pack.json");
   if (!await fs7.pathExists(manifestPath)) {
     return null;
   }
   const manifest = PackManifestSchema.parse(await fs7.readJson(manifestPath));
   const files = {};
   for (const file of manifest.files) {
-    const content = await readOptional(path7.join(packRoot2, normalizePackFilePath(file)));
+    const content = await readOptional(path7.join(packRoot, normalizePackFilePath(file)));
     if (content !== void 0) {
       files[file.type] = content;
     }
@@ -530,9 +530,13 @@ var LockSchema = z3.object({
   packs: z3.record(
     z3.string(),
     z3.object({
+      title: z3.string().optional(),
       version: z3.string(),
+      topic: z3.string().optional(),
+      classification: z3.string().optional(),
       path: z3.string(),
-      source: z3.string()
+      source: z3.string(),
+      files: z3.array(z3.string()).optional()
     })
   )
 });
@@ -557,9 +561,13 @@ async function updateContextForgeLock(root, registry, installed) {
   };
   for (const pack of installed) {
     lock.packs[pack.manifest.name] = {
+      title: pack.manifest.title,
       version: pack.manifest.version,
+      topic: pack.manifest.topic,
+      classification: pack.manifest.classification,
       path: pack.summary?.path ?? `packs/${pack.manifest.name}/pack.json`,
-      source: pack.packUrl ?? ""
+      source: pack.packUrl ?? "",
+      files: pack.manifest.files.map((file) => file.type)
     };
   }
   await saveLock(root, lock);
@@ -595,28 +603,10 @@ function addPackToConfig(config, packName) {
 }
 
 // src/registry/installPacks.ts
-import path13 from "path";
-import fs12 from "fs-extra";
-function normalizeRelativePath(relativePath) {
-  return relativePath.split(/[\\/]/u).join(path13.sep);
-}
-function packRoot(projectRoot, packName) {
-  return path13.join(projectRoot, PROJECT_PACK_CACHE, packName);
-}
-function packFilePath(projectRoot, packName, file) {
-  return path13.join(packRoot(projectRoot, packName), normalizeRelativePath(file.path));
-}
-async function downloadPackToContextForge(projectRoot, packName, packManifest, packUrl, timeoutMs) {
-  const root = packRoot(projectRoot, packName);
+async function downloadPackToContextForge(_projectRoot, _packName, packManifest, packUrl, timeoutMs) {
   const files = {};
-  await fs12.ensureDir(root);
-  await fs12.writeFile(path13.join(root, "pack.json"), `${JSON.stringify(packManifest, null, 2)}
-`);
   for (const file of packManifest.files) {
     const content = await fetchPackFile(packUrl, file, timeoutMs);
-    const targetPath = packFilePath(projectRoot, packName, file);
-    await fs12.ensureDir(path13.dirname(targetPath));
-    await fs12.writeFile(targetPath, content);
     files[file.type] = content;
   }
   return {
@@ -625,31 +615,17 @@ async function downloadPackToContextForge(projectRoot, packName, packManifest, p
     files
   };
 }
-async function installPack(projectRoot, registryUrl, packName, options = {}) {
+async function installPack(_projectRoot, registryUrl, packName, options = {}) {
   const registry = await fetchRegistry(registryUrl, options.timeoutMs);
   const summary = findPackSummary(registry, packName);
   if (!summary) {
     throw new Error(`Unknown ContextForge pack: ${packName}`);
   }
-  const alreadyInstalled = await fs12.pathExists(path13.join(packRoot(projectRoot, packName), "pack.json"));
   const packUrl = resolvePackUrl(registryUrl, summary.path);
   const manifest = await fetchPackManifest(packUrl, options.timeoutMs);
-  if (alreadyInstalled && !options.force) {
-    return {
-      installed: false,
-      alreadyInstalled: true,
-      packName,
-      manifest,
-      summary,
-      packUrl
-    };
-  }
-  if (!options.dryRun) {
-    await downloadPackToContextForge(projectRoot, packName, manifest, packUrl, options.timeoutMs);
-  }
   return {
     installed: !options.dryRun,
-    alreadyInstalled,
+    alreadyInstalled: false,
     packName,
     manifest,
     summary,
@@ -838,44 +814,44 @@ async function compileClaudeMd() {
 }
 
 // src/compiler/generateToolOutputs.ts
-import path16 from "path";
-import fs15 from "fs-extra";
+import path15 from "path";
+import fs14 from "fs-extra";
 
 // src/fs/safeWriteFile.ts
-import path14 from "path";
-import fs13 from "fs-extra";
+import path13 from "path";
+import fs12 from "fs-extra";
 async function safeWriteFile(filePath, generatedContent) {
-  const existingContent = await fs13.pathExists(filePath) ? await fs13.readFile(filePath, "utf8") : null;
+  const existingContent = await fs12.pathExists(filePath) ? await fs12.readFile(filePath, "utf8") : null;
   const nextContent = updateGeneratedBlock(existingContent, generatedContent);
-  await fs13.ensureDir(path14.dirname(filePath));
-  await fs13.writeFile(filePath, nextContent);
+  await fs12.ensureDir(path13.dirname(filePath));
+  await fs12.writeFile(filePath, nextContent);
 }
 
 // src/compiler/cleanupGeneratedFiles.ts
-import path15 from "path";
-import fs14 from "fs-extra";
+import path14 from "path";
+import fs13 from "fs-extra";
 function isGeneratedOnlyPath(relativePath) {
   return relativePath.startsWith(".agents/skills/") || relativePath.startsWith(".cursor/rules/") || relativePath.startsWith(".github/instructions/") || relativePath.startsWith(".contextforge/instructions/") || relativePath.startsWith(".contextforge/agents/") || relativePath.startsWith(".contextforge/skills/");
 }
 async function cleanupFile(root, relativePath) {
-  const filePath = path15.join(root, relativePath);
-  if (!await fs14.pathExists(filePath)) {
+  const filePath = path14.join(root, relativePath);
+  if (!await fs13.pathExists(filePath)) {
     return;
   }
   if (isGeneratedOnlyPath(relativePath)) {
-    await fs14.remove(filePath);
+    await fs13.remove(filePath);
     return;
   }
-  const content = await fs14.readFile(filePath, "utf8");
+  const content = await fs13.readFile(filePath, "utf8");
   if (!getGeneratedBlock(content)) {
     return;
   }
   const nextContent = removeGeneratedBlock(content);
   if (nextContent.trim().length === 0) {
-    await fs14.remove(filePath);
+    await fs13.remove(filePath);
     return;
   }
-  await fs14.writeFile(filePath, `${nextContent}
+  await fs13.writeFile(filePath, `${nextContent}
 `);
 }
 async function cleanupStaleGeneratedFiles(root, previousFiles, currentFiles) {
@@ -945,9 +921,9 @@ function withContextForgePreamble2(pack, type, content) {
   return ["# ContextForge Git Safety", "", warning, "", content.trim()].join("\n");
 }
 async function writeGeneratedOnlyFile(root, output) {
-  const filePath = path16.join(root, output.path);
-  await fs15.ensureDir(path16.dirname(filePath));
-  await fs15.writeFile(filePath, output.content.endsWith("\n") ? output.content : `${output.content}
+  const filePath = path15.join(root, output.path);
+  await fs14.ensureDir(path15.dirname(filePath));
+  await fs14.writeFile(filePath, output.content.endsWith("\n") ? output.content : `${output.content}
 `);
 }
 function packOutputs(pack, tools) {
@@ -960,7 +936,7 @@ async function generateToolOutputs(root, packs, config, previousFiles = []) {
     if (isGeneratedOnly) {
       await writeGeneratedOnlyFile(root, output);
     } else {
-      await safeWriteFile(path16.join(root, output.path), output.content);
+      await safeWriteFile(path15.join(root, output.path), output.content);
     }
   }
   const rootOutputs = [];
@@ -971,7 +947,7 @@ async function generateToolOutputs(root, packs, config, previousFiles = []) {
     rootOutputs.push({ path: "CLAUDE.md", content: await compileClaudeMd() });
   }
   for (const output of rootOutputs) {
-    await safeWriteFile(path16.join(root, output.path), output.content);
+    await safeWriteFile(path15.join(root, output.path), output.content);
   }
   const currentFiles = [...packGeneratedOutputs, ...rootOutputs].map((output) => output.path);
   await cleanupStaleGeneratedFiles(root, previousFiles, currentFiles);
@@ -979,19 +955,19 @@ async function generateToolOutputs(root, packs, config, previousFiles = []) {
 }
 
 // src/compiler/writeGeneratedFiles.ts
-import path17 from "path";
+import path16 from "path";
 async function writeGeneratedFiles(root, outputs, previousFiles = []) {
   const currentFiles = outputs.map((output) => output.path);
   for (const output of outputs) {
-    await safeWriteFile(path17.join(root, output.path), output.content);
+    await safeWriteFile(path16.join(root, output.path), output.content);
   }
   await cleanupStaleGeneratedFiles(root, previousFiles, currentFiles);
   return currentFiles;
 }
 
 // src/sync.ts
-import path18 from "path";
-import fs16 from "fs-extra";
+import path17 from "path";
+import fs15 from "fs-extra";
 async function updateContextForgeConfig(projectRoot, packName, registryUrl, generatedFiles) {
   const existing = await loadOptionalConfig(projectRoot);
   const config = addPackToConfig(
@@ -1025,15 +1001,22 @@ async function loadInstalledPackFromRegistry(projectRoot, registryUrl, summary,
   const manifest = await fetchPackManifest(packUrl, timeoutMs);
   return downloadPackToContextForge(projectRoot, manifest.name, manifest, packUrl, timeoutMs);
 }
+async function removeLegacyPackCache(root) {
+  await fs15.remove(path17.join(root, ".contextforge/packs"));
+}
 async function syncInstalledPacks(projectRoot, providedConfig) {
-  const root = path18.resolve(projectRoot);
+  const root = path17.resolve(projectRoot);
   const analysis = await detectProject(root);
   const previousConfig = await loadOptionalConfig(root);
   const config = providedConfig ?? await loadConfig(root);
   const registry = await fetchRegistry(config.registry);
   const installed = [];
   const missing = [];
-  for (const packName of config.installedPacks) {
+  const detectedPackNames = recommendPackNames(analysis).filter(
+    (packName) => Boolean(findPackSummary(registry, packName))
+  );
+  const packNames = [.../* @__PURE__ */ new Set([...config.installedPacks, ...detectedPackNames])];
+  for (const packName of packNames) {
     const summary = findPackSummary(registry, packName);
     if (!summary) {
       missing.push(packName);
@@ -1041,6 +1024,7 @@ async function syncInstalledPacks(projectRoot, providedConfig) {
     }
     installed.push(await loadInstalledPackFromRegistry(root, config.registry, summary));
   }
+  await removeLegacyPackCache(root);
   const generatedFiles = await generateToolOutputs(
     root,
     installed,
@@ -1078,7 +1062,7 @@ async function syncProject(root, providedConfig) {
   return syncInstalledPacks(root, providedConfig);
 }
 async function installPackAndSync(projectRoot, registryUrl, packName, options = {}) {
-  const root = path18.resolve(projectRoot);
+  const root = path17.resolve(projectRoot);
   const config = await loadOptionalConfig(root);
   const result = await installPack(root, registryUrl, packName, options);
   if (result.alreadyInstalled && !options.force && config?.installedPacks.includes(packName)) {
@@ -1111,24 +1095,33 @@ async function installPackAndSync(projectRoot, registryUrl, packName, options =
   };
 }
 async function readInstalledPacks(projectRoot) {
-  return loadProjectPacks(projectRoot);
+  const config = await loadConfig(projectRoot);
+  const registry = await fetchRegistry(config.registry);
+  const installed = [];
+  for (const packName of config.installedPacks) {
+    const summary = findPackSummary(registry, packName);
+    if (summary) {
+      installed.push(await loadInstalledPackFromRegistry(projectRoot, config.registry, summary));
+    }
+  }
+  return installed;
 }
 async function pathExists(root, relativePath) {
-  return fs16.pathExists(path18.join(root, relativePath));
+  return fs15.pathExists(path17.join(root, relativePath));
 }
 
 // src/doctor/doctorProject.ts
-import path19 from "path";
-import fs17 from "fs-extra";
+import path18 from "path";
+import fs16 from "fs-extra";
 async function fileExists(root, relativePath) {
-  return fs17.pathExists(path19.join(root, relativePath));
+  return fs16.pathExists(path18.join(root, relativePath));
 }
 async function readIfExists(root, relativePath) {
-  const filePath = path19.join(root, relativePath);
-  if (!await fs17.pathExists(filePath)) {
+  const filePath = path18.join(root, relativePath);
+  if (!await fs16.pathExists(filePath)) {
     return null;
   }
-  return fs17.readFile(filePath, "utf8");
+  return fs16.readFile(filePath, "utf8");
 }
 function hasContextForgeBlock(content) {
   return Boolean(content && getGeneratedBlock(content));
@@ -1158,7 +1151,7 @@ function expectedGeneratedOutputs(packName, tools) {
 async function doctorProject(root, options = {}) {
   const checks = [];
   const issues = [];
-  const resolvedRoot = path19.resolve(root);
+  const resolvedRoot = path18.resolve(root);
   if (!await fileExists(resolvedRoot, CONFIG_PATH)) {
     return {
       checks,
@@ -1197,8 +1190,6 @@ async function doctorProject(root, options = {}) {
       message: `${LOCK_PATH} is missing. Run \`npx @contextforge/cli sync\`.`
     });
   }
-  const cachedPacks = await loadProjectPacks(resolvedRoot);
-  const cachedPackNames = new Set(cachedPacks.map((pack) => pack.manifest.name));
   for (const packName of config.installedPacks) {
     if (registryPacks.size > 0 && !registryPacks.has(packName)) {
       issues.push({
@@ -1206,12 +1197,11 @@ async function doctorProject(root, options = {}) {
         message: `${packName} is installed in config, but no longer exists in the registry.`
       });
     }
-    if (!cachedPackNames.has(packName)) {
+    if (lock && !lock.packs[packName]) {
       issues.push({
-        level: "error",
-        message: `.contextforge/packs/${packName}/pack.json is missing. Run \`npx @contextforge/cli sync\`.`
+        level: "warning",
+        message: `${packName} is installed in config, but missing from ${LOCK_PATH}. Run \`npx @contextforge/cli sync\`.`
       });
-      continue;
     }
     for (const output of expectedGeneratedOutputs(packName, config.tools)) {
       if (!await fileExists(resolvedRoot, output)) {
@@ -1256,16 +1246,13 @@ async function doctorProject(root, options = {}) {
       message: "CLAUDE.md is large. Root instructions should stay concise; detailed content belongs in pack files."
     });
   }
-  const gitWorkflow = cachedPacks.find((pack) => pack.manifest.name === "git-workflow");
-  if (gitWorkflow) {
+  if (config.installedPacks.includes("git-workflow")) {
     const generatedGitFiles = await Promise.all(
       ["codex", "claude", "cursor", "copilot"].map(
         (tool) => readIfExists(resolvedRoot, `.contextforge/agents/${tool}/git-workflow.md`)
       )
     );
     const gitSummary = [
-      gitWorkflow.files.agents,
-      gitWorkflow.files.claude,
       ...generatedGitFiles,
       agentsMd,
       claudeMd
@@ -1277,14 +1264,6 @@ async function doctorProject(root, options = {}) {
       });
     }
   }
-  for (const pack of cachedPacks) {
-    if (!await packMatchesProject(pack, resolvedRoot, packageJson)) {
-      issues.push({
-        level: "warning",
-        message: `${pack.manifest.name} is installed, but its detection hints do not match this project.`
-      });
-    }
-  }
   if (config.installedPacks.includes("test-driven-development") && !hasScript(packageJson, "test")) {
     issues.push({
       level: "warning",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextforge/core",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",