ocx 1.2.1 → 1.2.2

package/dist/index.js

@@ -10528,7 +10528,7 @@ class GhostConfigProvider {
 // package.json
 var package_default = {
   name: "ocx",
-  version: "1.2.1",
+  version: "1.2.2",
   description: "OCX CLI - ShadCN-style registry for OpenCode extensions. Install agents, plugins, skills, and MCP servers.",
   author: "kdcokenny",
   license: "MIT",
@@ -14522,7 +14522,7 @@ Profile location:`);
 // src/commands/ghost/opencode.ts
 import { renameSync, rmSync } from "fs";
 import { copyFile as copyFilePromise } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 
 // src/utils/opencode-discovery.ts
 import { exists } from "fs/promises";
@@ -14585,40 +14585,73 @@ async function discoverProjectFiles(start, stop) {
   return excluded;
 }
 
+// src/utils/symlink-farm.ts
+import { randomBytes } from "crypto";
+import { mkdir as mkdir4, readdir as readdir3, rename as rename3, rm as rm2, stat as stat3, symlink as symlink2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname4, isAbsolute, join as join5, relative as relative2 } from "path";
+
 // src/utils/pattern-filter.ts
+import path6 from "path";
 var {Glob: Glob2 } = globalThis.Bun;
-function matchesAnyGlob(filePath, globs) {
-  return globs.some((g) => g.match(filePath));
-}
-function filterExcludedPaths(excludedPaths, includePatterns, excludePatterns) {
-  if (!includePatterns || includePatterns.length === 0) {
-    return new Set(excludedPaths);
-  }
-  const includeGlobs = includePatterns.map((p) => new Glob2(p));
-  const excludeGlobs = excludePatterns?.map((p) => new Glob2(p)) ?? [];
-  const filteredExclusions = new Set;
-  for (const path6 of excludedPaths) {
-    const matchesInclude = matchesAnyGlob(path6, includeGlobs);
-    const matchesExclude = matchesAnyGlob(path6, excludeGlobs);
-    if (matchesInclude && !matchesExclude) {
-      continue;
+function normalizeForMatching(absolutePath, projectRoot) {
+  const relativePath = path6.relative(projectRoot, absolutePath);
+  return relativePath.split(path6.sep).join("/").replace(/^\.\//, "");
+}
+class PathMatcher {
+  includeGlobs;
+  excludeGlobs;
+  includePatterns;
+  constructor(includePatterns = [], excludePatterns = []) {
+    this.includePatterns = includePatterns;
+    this.includeGlobs = includePatterns.map((p) => ({ pattern: p, glob: new Glob2(p) }));
+    this.excludeGlobs = excludePatterns.map((p) => ({ pattern: p, glob: new Glob2(p) }));
+  }
+  getDisposition(relativePath) {
+    if (this.excludeGlobs.some((g) => g.glob.match(relativePath))) {
+      return { type: "excluded" };
+    }
+    if (this.includeGlobs.some((g) => g.glob.match(relativePath))) {
+      return { type: "included" };
+    }
+    const patternsInsideDir = this.includePatterns.filter((pattern) => {
+      if (pattern.startsWith(`${relativePath}/`))
+        return true;
+      if (pattern.startsWith("**/"))
+        return true;
+      return false;
+    });
+    if (patternsInsideDir.length > 0) {
+      return { type: "partial", patterns: patternsInsideDir };
+    }
+    if (this.includePatterns.length > 0) {
+      return { type: "excluded" };
     }
-    filteredExclusions.add(path6);
+    return { type: "included" };
+  }
+  targetsInside(dirPath) {
+    const normalizedDir = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
+    return this.includePatterns.some((p) => p.startsWith(normalizedDir));
+  }
+  getInnerPatterns(dirPath) {
+    const normalizedDir = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
+    return this.includePatterns.filter((p) => p.startsWith(normalizedDir));
   }
-  return filteredExclusions;
+  hasIncludePatterns() {
+    return this.includePatterns.length > 0;
+  }
+}
+function createPathMatcher(includePatterns = [], excludePatterns = []) {
+  return new PathMatcher(includePatterns, excludePatterns);
 }
 
 // src/utils/symlink-farm.ts
-import { randomBytes } from "crypto";
-import { mkdir as mkdir4, readdir as readdir3, rename as rename3, rm as rm2, stat as stat3, symlink as symlink2 } from "fs/promises";
-import { tmpdir } from "os";
-import { dirname as dirname4, isAbsolute, join as join5, relative as relative2 } from "path";
 var STALE_SESSION_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 var REMOVING_THRESHOLD_MS = 60 * 60 * 1000;
 var GHOST_DIR_PREFIX = "ocx-ghost-";
 var REMOVING_SUFFIX = "-removing";
 var GHOST_MARKER_FILE = ".ocx-ghost-marker";
-async function createSymlinkFarm(sourceDir, excludePaths) {
+async function createSymlinkFarm(sourceDir, excludePaths, options2) {
   if (!isAbsolute(sourceDir)) {
     throw new Error(`sourceDir must be an absolute path, got: ${sourceDir}`);
   }
@@ -14626,14 +14659,9 @@ async function createSymlinkFarm(sourceDir, excludePaths) {
   const tempDir = join5(tmpdir(), `${GHOST_DIR_PREFIX}${suffix}`);
   await Bun.write(join5(tempDir, GHOST_MARKER_FILE), "");
   try {
-    const entries = await readdir3(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const sourcePath = join5(sourceDir, entry.name);
-      if (excludePaths.has(sourcePath))
-        continue;
-      const targetPath = join5(tempDir, entry.name);
-      await symlink2(sourcePath, targetPath);
-    }
+    const matcher = createPathMatcher(options2?.includePatterns ?? [], options2?.excludePatterns ?? []);
+    const plan = await computeSymlinkPlan(sourceDir, sourceDir, excludePaths, matcher);
+    await executeSymlinkPlan(plan, sourceDir, tempDir);
     return tempDir;
   } catch (error) {
     await rm2(tempDir, { recursive: true, force: true }).catch(() => {});
@@ -14717,9 +14745,104 @@ async function cleanupOrphanedGhostDirs(tempBase = tmpdir()) {
   }
   return cleanedCount;
 }
+async function handleExcludedEntry(isDirectory, disposition, computeNestedPlan) {
+  if (disposition.type === "excluded") {
+    return { action: "skip" };
+  }
+  if (disposition.type === "included") {
+    return { action: "includeWhole" };
+  }
+  if (isDirectory) {
+    const nestedPlan = await computeNestedPlan();
+    return { action: "partial", nestedPlan };
+  }
+  return { action: "skip" };
+}
+async function computeSymlinkPlan(sourceDir, projectRoot, excludedPaths, matcher, insideExcludedTree = false) {
+  if (!isAbsolute(sourceDir)) {
+    throw new Error(`sourceDir must be an absolute path, got: ${sourceDir}`);
+  }
+  const plan = {
+    wholeDirs: [],
+    files: [],
+    partialDirs: new Map
+  };
+  const entries = await readdir3(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = join5(sourceDir, entry.name);
+    const relativePath = normalizeForMatching(sourcePath, projectRoot);
+    if (insideExcludedTree) {
+      const disposition = matcher.getDisposition(relativePath);
+      const result = await handleExcludedEntry(entry.isDirectory(), disposition, () => computeSymlinkPlan(sourcePath, projectRoot, excludedPaths, matcher, true));
+      if (result.action === "skip") {
+        continue;
+      }
+      if (result.action === "includeWhole") {
+        if (entry.isDirectory()) {
+          plan.wholeDirs.push(entry.name);
+        } else {
+          plan.files.push(entry.name);
+        }
+        continue;
+      }
+      plan.partialDirs.set(entry.name, result.nestedPlan);
+      continue;
+    }
+    if (excludedPaths.has(sourcePath)) {
+      if (!matcher.hasIncludePatterns()) {
+        continue;
+      }
+      const disposition = matcher.getDisposition(relativePath);
+      const result = await handleExcludedEntry(entry.isDirectory(), disposition, () => computeSymlinkPlan(sourcePath, projectRoot, excludedPaths, matcher, true));
+      if (result.action === "skip") {
+        continue;
+      }
+      if (result.action === "includeWhole") {
+        if (entry.isDirectory()) {
+          plan.wholeDirs.push(entry.name);
+        } else {
+          plan.files.push(entry.name);
+        }
+        continue;
+      }
+      plan.partialDirs.set(entry.name, result.nestedPlan);
+      continue;
+    }
+    if (entry.isDirectory()) {
+      plan.wholeDirs.push(entry.name);
+    } else {
+      plan.files.push(entry.name);
+    }
+  }
+  return plan;
+}
+async function executeSymlinkPlan(plan, sourceRoot, targetRoot) {
+  if (!isAbsolute(sourceRoot)) {
+    throw new Error(`sourceRoot must be an absolute path, got: ${sourceRoot}`);
+  }
+  if (!isAbsolute(targetRoot)) {
+    throw new Error(`targetRoot must be an absolute path, got: ${targetRoot}`);
+  }
+  for (const dirName of plan.wholeDirs) {
+    const sourcePath = join5(sourceRoot, dirName);
+    const targetPath = join5(targetRoot, dirName);
+    await symlink2(sourcePath, targetPath);
+  }
+  for (const fileName of plan.files) {
+    const sourcePath = join5(sourceRoot, fileName);
+    const targetPath = join5(targetRoot, fileName);
+    await symlink2(sourcePath, targetPath);
+  }
+  for (const [dirName, nestedPlan] of plan.partialDirs) {
+    const sourcePath = join5(sourceRoot, dirName);
+    const targetPath = join5(targetRoot, dirName);
+    await mkdir4(targetPath, { recursive: true });
+    await executeSymlinkPlan(nestedPlan, sourcePath, targetPath);
+  }
+}
 
 // src/utils/terminal-title.ts
-import path6 from "path";
+import path7 from "path";
 var MAX_BRANCH_LENGTH = 20;
 function isInsideTmux() {
   return Boolean(process.env.TMUX);
@@ -14742,7 +14865,7 @@ function setTerminalName(name) {
   setTerminalTitle(name);
 }
 function formatTerminalName(cwd, profileName, gitInfo) {
-  const repoName = gitInfo.repoName ?? path6.basename(cwd);
+  const repoName = gitInfo.repoName ?? path7.basename(cwd);
   if (!gitInfo.branch) {
     return `ghost[${profileName}]:${repoName}`;
   }
@@ -14786,13 +14909,15 @@ async function runGhostOpenCode(args, options2) {
   const gitRoot = gitContext?.workTree ?? cwd;
   const discoveredPaths = await discoverProjectFiles(cwd, gitRoot);
   const ghostConfig = profile.ghost;
-  const excludePaths = filterExcludedPaths(discoveredPaths, ghostConfig.include, ghostConfig.exclude);
-  const tempDir = await createSymlinkFarm(cwd, excludePaths);
+  const tempDir = await createSymlinkFarm(cwd, discoveredPaths, {
+    includePatterns: ghostConfig.include,
+    excludePatterns: ghostConfig.exclude
+  });
   const ghostFiles = await discoverProjectFiles(profileDir, profileDir);
   await injectGhostFiles(tempDir, profileDir, ghostFiles);
   if (profile.hasAgents) {
     const agentsPath = getProfileAgents(profileName);
-    const destAgentsPath = path7.join(tempDir, "AGENTS.md");
+    const destAgentsPath = path8.join(tempDir, "AGENTS.md");
     await copyFilePromise(agentsPath, destAgentsPath);
   }
   let cleanupDone = false;
@@ -15836,7 +15961,7 @@ async function hashBundle2(files) {
 `));
 }
 // src/index.ts
-var version = "1.2.1";
+var version = "1.2.2";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version);
   registerInitCommand(program2);
@@ -15863,4 +15988,4 @@ export {
   buildRegistry
 };
 
-//# debugId=FF19E8C89476382D64756E2164756E21
+//# debugId=DCBED805AED28C6C64756E2164756E21