ocx 1.2.0 → 1.2.2

package/dist/index.js

@@ -10528,7 +10528,7 @@ class GhostConfigProvider {
 // package.json
 var package_default = {
   name: "ocx",
-  version: "1.2.0",
+  version: "1.2.2",
   description: "OCX CLI - ShadCN-style registry for OpenCode extensions. Install agents, plugins, skills, and MCP servers.",
   author: "kdcokenny",
   license: "MIT",
@@ -10921,14 +10921,15 @@ var isCI = Boolean(process.env.CI || process.env.GITHUB_ACTIONS || process.env.G
 var isTTY = Boolean(process.stdout.isTTY && !isCI);
 var supportsColor = Boolean(isTTY && process.env.FORCE_COLOR !== "0" && process.env.NO_COLOR === undefined);
 // src/utils/git-context.ts
-import { resolve } from "path";
+import { basename, resolve } from "path";
+function getGitEnv() {
+  const { GIT_DIR: _, GIT_WORK_TREE: __, ...cleanEnv } = process.env;
+  return cleanEnv;
+}
 async function detectGitRepo(cwd) {
-  const cleanEnv = { ...process.env };
-  delete cleanEnv.GIT_DIR;
-  delete cleanEnv.GIT_WORK_TREE;
   const gitDirProc = Bun.spawn(["git", "rev-parse", "--git-dir"], {
     cwd,
-    env: cleanEnv,
+    env: getGitEnv(),
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -10943,7 +10944,7 @@ async function detectGitRepo(cwd) {
   }
   const workTreeProc = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
     cwd,
-    env: cleanEnv,
+    env: getGitEnv(),
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -10959,6 +10960,73 @@ async function detectGitRepo(cwd) {
   const gitDir = resolve(cwd, gitDirRaw);
   return { gitDir, workTree };
 }
+async function getBranch(cwd) {
+  const symbolicProc = Bun.spawn(["git", "symbolic-ref", "--short", "HEAD"], {
+    cwd,
+    env: getGitEnv(),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const symbolicExitCode = await symbolicProc.exited;
+  if (symbolicExitCode === 0) {
+    const output = await new Response(symbolicProc.stdout).text();
+    const branch = output.trim();
+    if (branch) {
+      return branch;
+    }
+  }
+  const tagProc = Bun.spawn(["git", "describe", "--tags", "--exact-match", "HEAD"], {
+    cwd,
+    env: getGitEnv(),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const tagExitCode = await tagProc.exited;
+  if (tagExitCode === 0) {
+    const output = await new Response(tagProc.stdout).text();
+    const tag = output.trim();
+    if (tag) {
+      return tag;
+    }
+  }
+  const hashProc = Bun.spawn(["git", "rev-parse", "--short", "HEAD"], {
+    cwd,
+    env: getGitEnv(),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const hashExitCode = await hashProc.exited;
+  if (hashExitCode === 0) {
+    const output = await new Response(hashProc.stdout).text();
+    const hash = output.trim();
+    if (hash) {
+      return hash;
+    }
+  }
+  return null;
+}
+async function getRepoName(cwd) {
+  const proc = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
+    cwd,
+    env: getGitEnv(),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    return null;
+  }
+  const output = await new Response(proc.stdout).text();
+  const rootPath = output.trim();
+  if (!rootPath) {
+    return null;
+  }
+  return basename(rootPath);
+}
+async function getGitInfo(cwd) {
+  const [repoName, branch] = await Promise.all([getRepoName(cwd), getBranch(cwd)]);
+  return { repoName, branch };
+}
 // ../../node_modules/.bun/kleur@4.1.5/node_modules/kleur/index.mjs
 var FORCE_COLOR;
 var NODE_DISABLE_COLORS;
@@ -14454,7 +14522,7 @@ Profile location:`);
 // src/commands/ghost/opencode.ts
 import { renameSync, rmSync } from "fs";
 import { copyFile as copyFilePromise } from "fs/promises";
-import path6 from "path";
+import path8 from "path";
 
 // src/utils/opencode-discovery.ts
 import { exists } from "fs/promises";
@@ -14517,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 };
     }
-    filteredExclusions.add(path6);
+    if (this.includePatterns.length > 0) {
+      return { type: "excluded" };
+    }
+    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}`);
   }
@@ -14558,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(() => {});
@@ -14649,6 +14745,133 @@ 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 path7 from "path";
+var MAX_BRANCH_LENGTH = 20;
+function isInsideTmux() {
+  return Boolean(process.env.TMUX);
+}
+function setTmuxWindowName(name) {
+  if (!isInsideTmux()) {
+    return;
+  }
+  Bun.spawnSync(["tmux", "rename-window", name]);
+  Bun.spawnSync(["tmux", "set-window-option", "automatic-rename", "off"]);
+}
+function setTerminalTitle(title) {
+  if (!isTTY) {
+    return;
+  }
+  process.stdout.write(`\x1B]0;${title}\x07`);
+}
+function setTerminalName(name) {
+  setTmuxWindowName(name);
+  setTerminalTitle(name);
+}
+function formatTerminalName(cwd, profileName, gitInfo) {
+  const repoName = gitInfo.repoName ?? path7.basename(cwd);
+  if (!gitInfo.branch) {
+    return `ghost[${profileName}]:${repoName}`;
+  }
+  const branch = gitInfo.branch.length > MAX_BRANCH_LENGTH ? `${gitInfo.branch.slice(0, MAX_BRANCH_LENGTH - 3)}...` : gitInfo.branch;
+  return `ghost[${profileName}]:${repoName}/${branch}`;
+}
 
 // src/commands/ghost/opencode.ts
 function registerGhostOpenCodeCommand(parent) {
@@ -14686,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 = path6.join(tempDir, "AGENTS.md");
+    const destAgentsPath = path8.join(tempDir, "AGENTS.md");
     await copyFilePromise(agentsPath, destAgentsPath);
   }
   let cleanupDone = false;
@@ -14717,6 +14942,8 @@ async function runGhostOpenCode(args, options2) {
   const sigtermHandler = () => proc?.kill("SIGTERM");
   process.on("SIGINT", sigintHandler);
   process.on("SIGTERM", sigtermHandler);
+  const gitInfo = await getGitInfo(cwd);
+  setTerminalName(formatTerminalName(cwd, profileName, gitInfo));
   proc = Bun.spawn({
     cmd: ["opencode", ...args],
     cwd: tempDir,
@@ -14833,7 +15060,7 @@ async function runProfileList(options2) {
 
 // src/commands/ghost/profile/remove.ts
 function registerProfileRemoveCommand(parent) {
-  parent.command("remove <name>").alias("rm").description("Delete a ghost profile").option("-f, --force", "Skip confirmation and allow deleting current profile").action(async (name, options2) => {
+  parent.command("remove <name>").alias("rm").description("Delete a ghost profile").option("-f, --force", "Allow deleting current profile").action(async (name, options2) => {
     try {
       await runProfileRemove(name, options2);
     } catch (error) {
@@ -14846,23 +15073,9 @@ async function runProfileRemove(name, options2) {
   if (!await manager.exists(name)) {
     throw new ProfileNotFoundError(name);
   }
-  if (!options2.force) {
-    if (!isTTY) {
-      throw new ValidationError("Cannot confirm deletion in non-interactive mode. Use --force to delete without confirmation.");
-    }
-    const confirmed = confirmDeletion(name);
-    if (!confirmed) {
-      console.log("Aborted.");
-      return;
-    }
-  }
-  await manager.remove(name, options2.force);
+  await manager.remove(name, options2.force ?? false);
   logger.success(`Deleted profile "${name}"`);
 }
-function confirmDeletion(name) {
-  const answer = prompt(`Delete profile "${name}"? This cannot be undone. [y/N]`);
-  return answer?.toLowerCase() === "y";
-}
 
 // src/commands/ghost/profile/show.ts
 function registerProfileShowCommand(parent) {
@@ -15748,7 +15961,7 @@ async function hashBundle2(files) {
 `));
 }
 // src/index.ts
-var version = "1.2.0";
+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);
@@ -15775,4 +15988,4 @@ export {
   buildRegistry
 };
 
-//# debugId=4A36829C127A179064756E2164756E21
+//# debugId=DCBED805AED28C6C64756E2164756E21