@contextforge/core 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -182,7 +182,7 @@ declare function hasScript(packageJson: PackageJson | null, scriptName: string):
 
 declare function findPack(registry: LoadedPack[], packName: string): LoadedPack | undefined;
 declare function resolvePacks(packNames: string[], registry: LoadedPack[]): LoadedPack[];
-declare function recommendPacks(analysis: ProjectAnalysis, registry: LoadedPack[]): LoadedPack[];
+declare function recommendPacks(analysis: ProjectAnalysis, registry: LoadedPack[]): Promise<LoadedPack[]>;
 declare function packMatchesProject(pack: LoadedPack, root: string, packageJson: PackageJson | null): Promise<boolean>;
 declare function packageManagerLabel(packageManager: PackageManager): string;
 

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/detect/detectProject.ts
-import path5 from "path";
+import path6 from "path";
 import fg4 from "fast-glob";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 
 // src/detect/detectAITools.ts
 import path from "path";
@@ -91,6 +91,28 @@ async function detectPackageManager(root) {
   return "unknown";
 }
 
+// src/project/packageJson.ts
+import path5 from "path";
+import fs5 from "fs-extra";
+async function readPackageJson(root) {
+  const packageJsonPath = path5.join(root, "package.json");
+  if (!await fs5.pathExists(packageJsonPath)) {
+    return null;
+  }
+  return fs5.readJson(packageJsonPath);
+}
+function hasPackage(packageJson, packageName) {
+  if (!packageJson) {
+    return false;
+  }
+  return Boolean(
+    packageJson.dependencies?.[packageName] || packageJson.devDependencies?.[packageName] || packageJson.peerDependencies?.[packageName] || packageJson.optionalDependencies?.[packageName]
+  );
+}
+function hasScript(packageJson, scriptName) {
+  return Boolean(packageJson?.scripts?.[scriptName]);
+}
+
 // src/detect/detectProject.ts
 async function hasAny(root, patterns) {
   const matches = await fg4(patterns, {
@@ -101,21 +123,27 @@ async function hasAny(root, patterns) {
   return matches.length > 0;
 }
 async function detectProject(root) {
-  const resolvedRoot = path5.resolve(root);
-  const [packageManager, framework, database, aiTools] = await Promise.all([
+  const resolvedRoot = path6.resolve(root);
+  const [packageManager, framework, database, aiTools, packageJson] = await Promise.all([
     detectPackageManager(resolvedRoot),
     detectFramework(resolvedRoot),
     detectDatabase(resolvedRoot),
-    detectAITools(resolvedRoot)
+    detectAITools(resolvedRoot),
+    readPackageJson(resolvedRoot)
   ]);
-  const [typescript, tailwind, shadcn, vitest, jest, playwright] = await Promise.all([
-    fs5.pathExists(path5.join(resolvedRoot, "tsconfig.json")),
+  const [typescript, tailwindConfig, componentsJson, vitestConfig, jestConfig, playwrightConfig] = await Promise.all([
+    fs6.pathExists(path6.join(resolvedRoot, "tsconfig.json")),
     hasAny(resolvedRoot, ["tailwind.config.{js,ts,mjs,mts,cjs,cts}"]),
-    fs5.pathExists(path5.join(resolvedRoot, "components.json")),
+    fs6.pathExists(path6.join(resolvedRoot, "components.json")),
     hasAny(resolvedRoot, ["vitest.config.{js,ts,mjs,mts,cjs,cts}"]),
     hasAny(resolvedRoot, ["jest.config.{js,ts,mjs,mts,cjs,cts}", "jest.config.json"]),
     hasAny(resolvedRoot, ["playwright.config.{js,ts,mjs,mts,cjs,cts}"])
   ]);
+  const tailwind = tailwindConfig || hasPackage(packageJson, "tailwindcss");
+  const shadcn = componentsJson || hasPackage(packageJson, "shadcn") || hasPackage(packageJson, "shadcn-ui");
+  const vitest = vitestConfig || hasPackage(packageJson, "vitest");
+  const jest = jestConfig || hasPackage(packageJson, "jest");
+  const playwright = playwrightConfig || hasPackage(packageJson, "@playwright/test") || hasPackage(packageJson, "playwright");
   return {
     root: resolvedRoot,
     packageManager,
@@ -176,30 +204,30 @@ var RemoteRegistryIndexSchema = z.object({
 });
 
 // src/registry/loadRegistry.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/registry/localRegistry.ts
-import path6 from "path";
-import fs6 from "fs-extra";
+import path7 from "path";
+import fs7 from "fs-extra";
 async function loadLocalRegistry(registryRoot, source) {
-  if (!await fs6.pathExists(registryRoot)) {
+  if (!await fs7.pathExists(registryRoot)) {
     return [];
   }
-  const entries = await fs6.readdir(registryRoot, { withFileTypes: true });
+  const entries = await fs7.readdir(registryRoot, { withFileTypes: true });
   const packs = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const directory = path6.join(registryRoot, entry.name);
-    const packPath = path6.join(directory, "pack.json");
-    if (!await fs6.pathExists(packPath)) {
+    const directory = path7.join(registryRoot, entry.name);
+    const packPath = path7.join(directory, "pack.json");
+    if (!await fs7.pathExists(packPath)) {
       continue;
     }
-    const parsed = PackSchema.parse(await fs6.readJson(packPath));
+    const parsed = PackSchema.parse(await fs7.readJson(packPath));
     const readOptional = async (fileName) => {
-      const filePath = path6.join(directory, fileName);
-      return await fs6.pathExists(filePath) ? fs6.readFile(filePath, "utf8") : void 0;
+      const filePath = path7.join(directory, fileName);
+      return await fs7.pathExists(filePath) ? fs7.readFile(filePath, "utf8") : void 0;
     };
     const rules = await readOptional("rules.md");
     if (!rules) {
@@ -325,7 +353,7 @@ async function loadRegistry(input = {}) {
   const sources = input.sources ?? DEFAULT_REGISTRY_SOURCES;
   const packs = [];
   if (input.root) {
-    packs.push(...await loadLocalRegistry(path7.join(input.root, PROJECT_PACK_CACHE), "project-cache"));
+    packs.push(...await loadLocalRegistry(path8.join(input.root, PROJECT_PACK_CACHE), "project-cache"));
   }
   for (const source of sources) {
     packs.push(...await loadRegistrySource(source, input.timeoutMs));
@@ -335,31 +363,8 @@ async function loadRegistry(input = {}) {
 
 // src/registry/resolvePack.ts
 import path9 from "path";
+import fg5 from "fast-glob";
 import fs8 from "fs-extra";
-
-// src/project/packageJson.ts
-import path8 from "path";
-import fs7 from "fs-extra";
-async function readPackageJson(root) {
-  const packageJsonPath = path8.join(root, "package.json");
-  if (!await fs7.pathExists(packageJsonPath)) {
-    return null;
-  }
-  return fs7.readJson(packageJsonPath);
-}
-function hasPackage(packageJson, packageName) {
-  if (!packageJson) {
-    return false;
-  }
-  return Boolean(
-    packageJson.dependencies?.[packageName] || packageJson.devDependencies?.[packageName] || packageJson.peerDependencies?.[packageName] || packageJson.optionalDependencies?.[packageName]
-  );
-}
-function hasScript(packageJson, scriptName) {
-  return Boolean(packageJson?.scripts?.[scriptName]);
-}
-
-// src/registry/resolvePack.ts
 function findPack(registry, packName) {
   return registry.find((pack) => pack.name === packName);
 }
@@ -373,29 +378,37 @@ function resolvePacks(packNames, registry) {
     return pack;
   });
 }
-function recommendPacks(analysis, registry) {
-  const names = /* @__PURE__ */ new Set();
-  names.add("env-secrets");
-  if (analysis.framework === "next-app-router") {
-    names.add("next-app-router");
-  }
-  if (analysis.database.prisma) {
-    names.add("prisma-migrations");
-  }
-  if (analysis.styling.shadcn) {
-    names.add("shadcn-ui");
+async function hasDetectFile(root, filePattern) {
+  if (filePattern.includes("*")) {
+    const matches = await fg5(filePattern, {
+      cwd: root,
+      onlyFiles: false,
+      dot: true
+    });
+    return matches.length > 0;
   }
-  if (analysis.testing.vitest || analysis.testing.jest || analysis.testing.playwright) {
-    names.add("testing-workflow");
+  return fs8.pathExists(path9.join(root, filePattern));
+}
+function hasDetectHints(pack) {
+  return Boolean(pack.detect?.files?.length || pack.detect?.packages?.length);
+}
+async function recommendPacks(analysis, registry) {
+  const packageJson = await readPackageJson(analysis.root);
+  const recommended = [];
+  for (const pack of registry) {
+    if (pack.name === "env-secrets") {
+      recommended.push(pack);
+      continue;
+    }
+    if (hasDetectHints(pack) && await packMatchesProject(pack, analysis.root, packageJson)) {
+      recommended.push(pack);
+    }
   }
-  return resolvePacks(
-    [...names].filter((name) => findPack(registry, name)),
-    registry
-  );
+  return recommended;
 }
 async function packMatchesProject(pack, root, packageJson) {
   const fileChecks = await Promise.all(
-    pack.detect?.files?.map((filePattern) => fs8.pathExists(path9.join(root, filePattern))) ?? []
+    pack.detect?.files?.map((filePattern) => hasDetectFile(root, filePattern)) ?? []
   );
   const packageChecks = pack.detect?.packages?.map((packageName) => hasPackage(packageJson, packageName)) ?? [];
   const checks = [...fileChecks, ...packageChecks];

package/package.json

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