nocaap 0.0.1

package/dist/index.js

@@ -0,0 +1,2491 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { confirm, input, checkbox } from '@inquirer/prompts';
+import upath from 'upath';
+import 'path';
+import fs2 from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
+import { z } from 'zod';
+import os from 'os';
+import simpleGit from 'simple-git';
+import matter from 'gray-matter';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+var CONTEXT_DIR = ".context";
+var PACKAGES_DIR = "packages";
+var CONFIG_FILE = "context.config.json";
+var LOCK_FILE = "context.lock";
+var INDEX_FILE = "INDEX.md";
+function toUnix(filePath) {
+  return upath.toUnix(filePath);
+}
+function join(...segments) {
+  return upath.join(...segments);
+}
+function dirname(filePath) {
+  return upath.dirname(filePath);
+}
+function basename(filePath, ext) {
+  return upath.basename(filePath, ext);
+}
+function extname(filePath) {
+  return upath.extname(filePath);
+}
+function getContextDir(projectRoot) {
+  return join(projectRoot, CONTEXT_DIR);
+}
+function getPackagesDir(projectRoot) {
+  return join(getContextDir(projectRoot), PACKAGES_DIR);
+}
+function getConfigPath(projectRoot) {
+  return join(getContextDir(projectRoot), CONFIG_FILE);
+}
+function getLockfilePath(projectRoot) {
+  return join(getContextDir(projectRoot), LOCK_FILE);
+}
+function getIndexPath(projectRoot) {
+  return join(getContextDir(projectRoot), INDEX_FILE);
+}
+function getPackagePath(projectRoot, alias) {
+  return join(getPackagesDir(projectRoot), alias);
+}
+function relative(from, to) {
+  return upath.relative(from, to);
+}
+async function ensureDir(dirPath) {
+  await fs2.ensureDir(dirPath);
+}
+async function exists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var log = {
+  /** Info message (blue) */
+  info: (message) => console.log(chalk.blue("\u2139"), message),
+  /** Success message (green) */
+  success: (message) => console.log(chalk.green("\u2714"), message),
+  /** Warning message (yellow) */
+  warn: (message) => console.log(chalk.yellow("\u26A0"), message),
+  /** Error message (red) */
+  error: (message) => console.log(chalk.red("\u2716"), message),
+  /** Debug message (gray) - only when NOCAAP_DEBUG=true */
+  debug: (message) => {
+    if (process.env.NOCAAP_DEBUG === "true") {
+      console.log(chalk.gray("\u{1F50D}"), chalk.gray(message));
+    }
+  },
+  /** Plain message */
+  plain: (message) => console.log(message),
+  /** Styled title */
+  title: (message) => console.log(chalk.bold.cyan(`
+${message}
+`)),
+  /** Dim helper text */
+  dim: (message) => console.log(chalk.dim(message)),
+  /** Empty line for spacing */
+  newline: () => console.log(),
+  /** Horizontal rule */
+  hr: () => console.log(chalk.dim("\u2500".repeat(50)))
+};
+var style = {
+  bold: (text) => chalk.bold(text),
+  dim: (text) => chalk.dim(text),
+  italic: (text) => chalk.italic(text),
+  underline: (text) => chalk.underline(text),
+  code: (text) => chalk.cyan(`\`${text}\``),
+  path: (text) => chalk.yellow(text),
+  url: (text) => chalk.blue.underline(text),
+  success: (text) => chalk.green(text),
+  error: (text) => chalk.red(text),
+  warn: (text) => chalk.yellow(text)
+};
+function createSpinner(text) {
+  const spinner = ora({
+    text,
+    color: "cyan"
+  });
+  const instance = {
+    start(newText) {
+      spinner.start(newText);
+      return instance;
+    },
+    stop() {
+      spinner.stop();
+      return instance;
+    },
+    succeed(newText) {
+      spinner.succeed(newText);
+      return instance;
+    },
+    fail(newText) {
+      spinner.fail(newText);
+      return instance;
+    },
+    warn(newText) {
+      spinner.warn(newText);
+      return instance;
+    },
+    info(newText) {
+      spinner.info(newText);
+      return instance;
+    },
+    get text() {
+      return spinner.text;
+    },
+    set text(value) {
+      spinner.text = value;
+    }
+  };
+  return instance;
+}
+var gitUrlPattern = /^(git@|https:\/\/|git:\/\/).+/;
+var ContextEntrySchema = z.object({
+  name: z.string().min(1, "Context name is required"),
+  description: z.string(),
+  repo: z.string().min(1, "Repository URL is required").refine(
+    (url) => gitUrlPattern.test(url),
+    "Must be a valid Git URL (git@, https://, or git://)"
+  ),
+  path: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var RegistrySchema = z.object({
+  name: z.string().optional(),
+  contexts: z.array(ContextEntrySchema),
+  imports: z.array(z.string().url()).optional()
+});
+var PackageEntrySchema = z.object({
+  alias: z.string().min(1, "Alias is required"),
+  source: z.string().min(1, "Source URL is required"),
+  path: z.string().optional(),
+  version: z.string().default("main")
+});
+var ConfigSchema = z.object({
+  registryUrl: z.string().url().optional(),
+  packages: z.array(PackageEntrySchema)
+});
+var LockEntrySchema = z.object({
+  commitHash: z.string().min(1, "Commit hash is required"),
+  sparsePath: z.string(),
+  updatedAt: z.string().datetime()
+});
+var LockfileSchema = z.record(z.string(), LockEntrySchema);
+function safeValidate(schema, data) {
+  const result = schema.safeParse(data);
+  return result.success ? { success: true, data: result.data } : { success: false, error: result.error };
+}
+function safeValidateRegistry(data) {
+  return safeValidate(RegistrySchema, data);
+}
+function safeValidateConfig(data) {
+  const result = ConfigSchema.safeParse(data);
+  return result.success ? { success: true, data: result.data } : { success: false, error: result.error };
+}
+function safeValidateLockfile(data) {
+  return safeValidate(LockfileSchema, data);
+}
+
+// src/core/config.ts
+async function initContextDir(projectRoot) {
+  const contextDir = getContextDir(projectRoot);
+  const packagesDir = getPackagesDir(projectRoot);
+  const configPath = getConfigPath(projectRoot);
+  const lockfilePath = getLockfilePath(projectRoot);
+  log.debug(`Initializing context directory at ${contextDir}`);
+  await ensureDir(contextDir);
+  await ensureDir(packagesDir);
+  if (!await exists(configPath)) {
+    const defaultConfig = { packages: [] };
+    await fs2.writeJson(configPath, defaultConfig, { spaces: 2 });
+    log.debug(`Created default config at ${configPath}`);
+  }
+  if (!await exists(lockfilePath)) {
+    const defaultLockfile = {};
+    await fs2.writeJson(lockfilePath, defaultLockfile, { spaces: 2 });
+    log.debug(`Created default lockfile at ${lockfilePath}`);
+  }
+  await updateGitignore(projectRoot);
+}
+async function configExists(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  return exists(configPath);
+}
+async function readConfig(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  if (!await exists(configPath)) {
+    log.debug(`Config file not found at ${configPath}`);
+    return null;
+  }
+  try {
+    const data = await fs2.readJson(configPath);
+    const result = safeValidateConfig(data);
+    if (!result.success) {
+      const errorMessages = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(`Invalid config file: ${errorMessages}`);
+    }
+    log.debug(`Read config from ${configPath}`);
+    return result.data;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Failed to parse config file: Invalid JSON at ${configPath}`);
+    }
+    throw error;
+  }
+}
+async function writeConfig(projectRoot, config) {
+  const configPath = getConfigPath(projectRoot);
+  const result = safeValidateConfig(config);
+  if (!result.success) {
+    const errorMessages = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    throw new Error(`Invalid config data: ${errorMessages}`);
+  }
+  await fs2.writeJson(configPath, config, { spaces: 2 });
+  log.debug(`Wrote config to ${configPath}`);
+}
+async function readLockfile(projectRoot) {
+  const lockfilePath = getLockfilePath(projectRoot);
+  if (!await exists(lockfilePath)) {
+    log.debug(`Lockfile not found at ${lockfilePath}, returning empty lockfile`);
+    return {};
+  }
+  try {
+    const data = await fs2.readJson(lockfilePath);
+    const result = safeValidateLockfile(data);
+    if (!result.success) {
+      const errorMessages = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(`Invalid lockfile: ${errorMessages}`);
+    }
+    log.debug(`Read lockfile from ${lockfilePath}`);
+    return result.data;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Failed to parse lockfile: Invalid JSON at ${lockfilePath}`);
+    }
+    throw error;
+  }
+}
+async function writeLockfile(projectRoot, lockfile) {
+  const lockfilePath = getLockfilePath(projectRoot);
+  const result = safeValidateLockfile(lockfile);
+  if (!result.success) {
+    const errorMessages = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    throw new Error(`Invalid lockfile data: ${errorMessages}`);
+  }
+  await fs2.writeJson(lockfilePath, lockfile, { spaces: 2 });
+  log.debug(`Wrote lockfile to ${lockfilePath}`);
+}
+async function updateLockEntry(projectRoot, alias, entry) {
+  const lockfile = await readLockfile(projectRoot);
+  lockfile[alias] = {
+    ...entry,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeLockfile(projectRoot, lockfile);
+  log.debug(`Updated lock entry for alias '${alias}'`);
+}
+async function removeLockEntry(projectRoot, alias) {
+  const lockfile = await readLockfile(projectRoot);
+  if (alias in lockfile) {
+    delete lockfile[alias];
+    await writeLockfile(projectRoot, lockfile);
+    log.debug(`Removed lock entry for alias '${alias}'`);
+  }
+}
+async function getLockEntry(projectRoot, alias) {
+  const lockfile = await readLockfile(projectRoot);
+  return lockfile[alias];
+}
+async function upsertPackage(projectRoot, pkg) {
+  const config = await readConfig(projectRoot) ?? { packages: [] };
+  const existingIndex = config.packages.findIndex((p) => p.alias === pkg.alias);
+  if (existingIndex >= 0) {
+    config.packages[existingIndex] = pkg;
+    log.debug(`Updated package '${pkg.alias}' in config`);
+  } else {
+    config.packages.push(pkg);
+    log.debug(`Added package '${pkg.alias}' to config`);
+  }
+  await writeConfig(projectRoot, config);
+}
+async function removePackage(projectRoot, alias) {
+  const config = await readConfig(projectRoot);
+  if (!config) return false;
+  const initialLength = config.packages.length;
+  config.packages = config.packages.filter((p) => p.alias !== alias);
+  if (config.packages.length < initialLength) {
+    await writeConfig(projectRoot, config);
+    log.debug(`Removed package '${alias}' from config`);
+    return true;
+  }
+  return false;
+}
+async function getPackage(projectRoot, alias) {
+  const config = await readConfig(projectRoot);
+  return config?.packages.find((p) => p.alias === alias);
+}
+var GITIGNORE_ENTRY = ".context/packages/";
+var GITIGNORE_COMMENT = "# nocaap packages (auto-generated)";
+async function updateGitignore(projectRoot) {
+  const gitignorePath = join(projectRoot, ".gitignore");
+  try {
+    if (await exists(gitignorePath)) {
+      const content = await fs2.readFile(gitignorePath, "utf-8");
+      if (content.includes(GITIGNORE_ENTRY)) {
+        log.debug(".gitignore already contains nocaap entry");
+        return false;
+      }
+      const newContent = content.endsWith("\n") ? content : content + "\n";
+      await fs2.writeFile(gitignorePath, `${newContent}
+${GITIGNORE_COMMENT}
+${GITIGNORE_ENTRY}
+`);
+    } else {
+      await fs2.writeFile(gitignorePath, `${GITIGNORE_COMMENT}
+${GITIGNORE_ENTRY}
+`);
+    }
+    log.debug("Updated .gitignore with nocaap entry");
+    return true;
+  } catch (error) {
+    log.debug(`Failed to update .gitignore: ${error}`);
+    return false;
+  }
+}
+var CURSOR_RULES_CONTENT = `# nocaap Context
+This project uses nocaap for organizational context.
+Read .context/INDEX.md for available documentation.
+`;
+async function updateCursorRules(projectRoot) {
+  const cursorDir = join(projectRoot, ".cursor");
+  const cursorRulesPath = join(cursorDir, "rules");
+  const legacyCursorRulesPath = join(projectRoot, ".cursorrules");
+  try {
+    for (const rulePath of [cursorRulesPath, legacyCursorRulesPath]) {
+      if (await exists(rulePath)) {
+        const content = await fs2.readFile(rulePath, "utf-8");
+        if (content.includes(".context/INDEX.md")) {
+          log.debug("Cursor rules already contain nocaap reference");
+          return false;
+        }
+      }
+    }
+    if (await exists(cursorDir)) {
+      if (await exists(cursorRulesPath)) {
+        const content = await fs2.readFile(cursorRulesPath, "utf-8");
+        const newContent = content.endsWith("\n") ? content : content + "\n";
+        await fs2.writeFile(cursorRulesPath, `${newContent}
+${CURSOR_RULES_CONTENT}`);
+      } else {
+        await fs2.writeFile(cursorRulesPath, CURSOR_RULES_CONTENT);
+      }
+      log.debug("Updated .cursor/rules with nocaap reference");
+      return true;
+    }
+    if (await exists(legacyCursorRulesPath)) {
+      const content = await fs2.readFile(legacyCursorRulesPath, "utf-8");
+      const newContent = content.endsWith("\n") ? content : content + "\n";
+      await fs2.writeFile(legacyCursorRulesPath, `${newContent}
+${CURSOR_RULES_CONTENT}`);
+    } else {
+      await fs2.writeFile(legacyCursorRulesPath, CURSOR_RULES_CONTENT);
+    }
+    log.debug("Updated .cursorrules with nocaap reference");
+    return true;
+  } catch (error) {
+    log.debug(`Failed to update Cursor rules: ${error}`);
+    return false;
+  }
+}
+var CLAUDE_MD_CONTENT = `
+## Project Context
+This project uses nocaap for organizational context.
+Read \`.context/INDEX.md\` for standards, guidelines, and documentation.
+`;
+async function updateClaudeMd(projectRoot) {
+  const claudeMdPath = join(projectRoot, "CLAUDE.md");
+  try {
+    if (await exists(claudeMdPath)) {
+      const content = await fs2.readFile(claudeMdPath, "utf-8");
+      if (content.includes(".context/INDEX.md")) {
+        log.debug("CLAUDE.md already contains nocaap reference");
+        return false;
+      }
+      const newContent = content.endsWith("\n") ? content : content + "\n";
+      await fs2.writeFile(claudeMdPath, `${newContent}${CLAUDE_MD_CONTENT}`);
+    } else {
+      await fs2.writeFile(claudeMdPath, `# CLAUDE.md${CLAUDE_MD_CONTENT}`);
+    }
+    log.debug("Updated CLAUDE.md with nocaap reference");
+    return true;
+  } catch (error) {
+    log.debug(`Failed to update CLAUDE.md: ${error}`);
+    return false;
+  }
+}
+var NOCAAP_DIR = ".nocaap";
+var CONFIG_FILE2 = "config.json";
+function getGlobalConfigDir() {
+  return join(os.homedir(), NOCAAP_DIR);
+}
+function getGlobalConfigPath() {
+  return join(getGlobalConfigDir(), CONFIG_FILE2);
+}
+async function getGlobalConfig() {
+  const configPath = getGlobalConfigPath();
+  if (!await exists(configPath)) {
+    log.debug(`Global config not found at ${configPath}`);
+    return {};
+  }
+  try {
+    const data = await fs2.readJson(configPath);
+    log.debug(`Read global config from ${configPath}`);
+    return data;
+  } catch (error) {
+    log.debug(`Failed to read global config: ${error}`);
+    return {};
+  }
+}
+async function setGlobalConfig(config) {
+  const configDir = getGlobalConfigDir();
+  const configPath = getGlobalConfigPath();
+  await fs2.ensureDir(configDir);
+  config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await fs2.writeJson(configPath, config, { spaces: 2 });
+  log.debug(`Wrote global config to ${configPath}`);
+}
+async function getDefaultRegistry() {
+  const envRegistry = process.env.NOCAAP_DEFAULT_REGISTRY;
+  if (envRegistry) {
+    log.debug(`Using registry from NOCAAP_DEFAULT_REGISTRY env var`);
+    return envRegistry;
+  }
+  const config = await getGlobalConfig();
+  return config.defaultRegistry;
+}
+async function setDefaultRegistry(url) {
+  const config = await getGlobalConfig();
+  config.defaultRegistry = url;
+  await setGlobalConfig(config);
+  log.debug(`Set default registry to ${url}`);
+}
+async function clearDefaultRegistry() {
+  const config = await getGlobalConfig();
+  delete config.defaultRegistry;
+  await setGlobalConfig(config);
+  log.debug("Cleared default registry");
+}
+function createGit(baseDir) {
+  const options = {
+    baseDir: baseDir ? toUnix(baseDir) : void 0,
+    binary: "git",
+    maxConcurrentProcesses: 6,
+    trimmed: true,
+    timeout: {
+      block: 6e4
+      // 60 seconds for any single operation
+    }
+  };
+  return simpleGit(options);
+}
+async function checkAccess(repoUrl) {
+  log.debug(`Checking access to ${repoUrl}`);
+  try {
+    const git = createGit();
+    await git.listRemote([repoUrl, "HEAD"]);
+    log.debug(`Access confirmed for ${repoUrl}`);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    log.debug(`Access denied or repo not found: ${repoUrl} - ${message}`);
+    return false;
+  }
+}
+async function getDefaultBranch(repoUrl) {
+  log.debug(`Detecting default branch for ${repoUrl}`);
+  try {
+    const git = createGit();
+    const result = await git.listRemote(["--symref", repoUrl, "HEAD"]);
+    const match = result.match(/ref:\s+refs\/heads\/([^\t\s]+)/);
+    if (match && match[1]) {
+      log.debug(`Default branch detected: ${match[1]}`);
+      return match[1];
+    }
+    const branchesResult = await git.listRemote(["--heads", repoUrl]);
+    const commonBranches = ["main", "master", "develop", "trunk"];
+    for (const branch of commonBranches) {
+      if (branchesResult.includes(`refs/heads/${branch}`)) {
+        log.debug(`Default branch fallback: ${branch}`);
+        return branch;
+      }
+    }
+    log.debug('Could not detect default branch, using "main"');
+    return "main";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    log.debug(`Failed to detect default branch: ${message}, using "main"`);
+    return "main";
+  }
+}
+async function sparseClone(options) {
+  const { repoUrl, targetDir, sparsePath } = options;
+  const normalizedTarget = toUnix(targetDir);
+  log.debug(`Sparse cloning ${repoUrl} to ${normalizedTarget}`);
+  const branch = options.branch || await getDefaultBranch(repoUrl);
+  if (await exists(normalizedTarget)) {
+    if (await isGitRepo(normalizedTarget)) {
+      if (await isDirty(normalizedTarget)) {
+        throw new Error(
+          `Target directory has uncommitted changes: ${normalizedTarget}. Please commit or discard changes before re-cloning.`
+        );
+      }
+    }
+    log.debug(`Removing existing directory: ${normalizedTarget}`);
+    await fs2.remove(normalizedTarget);
+  }
+  await ensureDir(dirname(normalizedTarget));
+  const cloneArgs = [
+    "--filter=blob:none",
+    // Partial clone - no blobs initially
+    "--sparse",
+    // Enable sparse checkout
+    "--depth",
+    "1",
+    // Shallow clone - no history
+    "--branch",
+    branch
+    // Always specify branch (auto-detected if not provided)
+  ];
+  cloneArgs.push(repoUrl, normalizedTarget);
+  const git = createGit();
+  try {
+    await git.clone(repoUrl, normalizedTarget, cloneArgs.slice(0, -2));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to clone ${repoUrl}: ${message}`);
+  }
+  if (sparsePath) {
+    const repoGit = createGit(normalizedTarget);
+    const normalizedSparsePath = toUnix(sparsePath).replace(/^\/+/, "");
+    try {
+      await repoGit.raw(["sparse-checkout", "set", "--no-cone", normalizedSparsePath]);
+      log.debug(`Set sparse-checkout path: ${normalizedSparsePath}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to set sparse-checkout path '${sparsePath}': ${message}`);
+    }
+    const sparseFullPath = join(normalizedTarget, normalizedSparsePath);
+    if (!await exists(sparseFullPath)) {
+      log.warn(`Sparse path '${sparsePath}' does not exist in the repository`);
+    } else {
+      log.debug(`Flattening sparse path: ${sparseFullPath} -> ${normalizedTarget}`);
+      const items = await fs2.readdir(sparseFullPath);
+      for (const item of items) {
+        const srcPath = join(sparseFullPath, item);
+        const destPath = join(normalizedTarget, item);
+        await fs2.move(srcPath, destPath, { overwrite: true });
+      }
+      const topLevelDir = normalizedSparsePath.split("/")[0];
+      if (topLevelDir) {
+        const topLevelPath = join(normalizedTarget, topLevelDir);
+        await fs2.remove(topLevelPath);
+        log.debug(`Removed empty sparse directory: ${topLevelPath}`);
+      }
+    }
+  }
+  const commitHash = await getHeadCommit(normalizedTarget);
+  log.debug(`Clone complete. HEAD: ${commitHash}`);
+  return { commitHash };
+}
+async function isGitRepo(dirPath) {
+  const gitDir = join(dirPath, ".git");
+  return exists(gitDir);
+}
+async function isDirty(repoPath) {
+  const normalizedPath = toUnix(repoPath);
+  log.debug(`Checking dirty state for ${normalizedPath}`);
+  if (!await isGitRepo(normalizedPath)) {
+    throw new Error(`Not a git repository: ${normalizedPath}`);
+  }
+  try {
+    const git = createGit(normalizedPath);
+    const status = await git.status();
+    const isDirtyState = !status.isClean();
+    log.debug(`Repository ${normalizedPath} is ${isDirtyState ? "dirty" : "clean"}`);
+    return isDirtyState;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to check repository status: ${message}`);
+  }
+}
+async function getHeadCommit(repoPath) {
+  const normalizedPath = toUnix(repoPath);
+  if (!await isGitRepo(normalizedPath)) {
+    throw new Error(`Not a git repository: ${normalizedPath}`);
+  }
+  try {
+    const git = createGit(normalizedPath);
+    const hash = await git.revparse(["HEAD"]);
+    return hash.trim();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to get HEAD commit: ${message}`);
+  }
+}
+async function pull(repoPath) {
+  const normalizedPath = toUnix(repoPath);
+  log.debug(`Pulling updates for ${normalizedPath}`);
+  if (!await isGitRepo(normalizedPath)) {
+    throw new Error(`Not a git repository: ${normalizedPath}`);
+  }
+  if (await isDirty(normalizedPath)) {
+    throw new Error(
+      `Cannot pull: repository has uncommitted changes at ${normalizedPath}. Please commit or discard changes first.`
+    );
+  }
+  try {
+    const git = createGit(normalizedPath);
+    await git.pull();
+    const commitHash = await getHeadCommit(normalizedPath);
+    log.debug(`Pull complete. HEAD: ${commitHash}`);
+    return { commitHash };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to pull updates: ${message}`);
+  }
+}
+async function getRemoteCommitHash(repoUrl, branch) {
+  log.debug(`Getting remote commit hash for ${repoUrl}`);
+  try {
+    const git = createGit();
+    const ref = branch ? `refs/heads/${branch}` : "HEAD";
+    const result = await git.listRemote([repoUrl, ref]);
+    const match = result.match(/^([a-f0-9]+)/);
+    if (!match || !match[1]) {
+      throw new Error("Could not parse commit hash from remote");
+    }
+    const commitHash = match[1];
+    log.debug(`Remote commit hash: ${commitHash}`);
+    return commitHash;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to get remote commit hash: ${message}`);
+  }
+}
+async function cloneToTemp(repoUrl, branch) {
+  const tempBase = join(os.tmpdir(), "nocaap-push");
+  await ensureDir(tempBase);
+  const tempDir = await fs2.mkdtemp(join(tempBase, "repo-"));
+  log.debug(`Cloning ${repoUrl} to temp directory: ${tempDir}`);
+  try {
+    const git = createGit();
+    const cloneArgs = ["--depth", "1"];
+    if (branch) {
+      cloneArgs.push("--branch", branch);
+    }
+    await git.clone(repoUrl, tempDir, cloneArgs);
+    log.debug(`Temp clone complete: ${tempDir}`);
+    return {
+      tempDir,
+      cleanup: async () => {
+        log.debug(`Cleaning up temp directory: ${tempDir}`);
+        await fs2.remove(tempDir);
+      }
+    };
+  } catch (error) {
+    await fs2.remove(tempDir);
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to clone to temp directory: ${message}`);
+  }
+}
+async function createBranch(repoPath, branchName) {
+  const normalizedPath = toUnix(repoPath);
+  if (!await isGitRepo(normalizedPath)) {
+    throw new Error(`Not a git repository: ${normalizedPath}`);
+  }
+  try {
+    const git = createGit(normalizedPath);
+    await git.checkoutLocalBranch(branchName);
+    log.debug(`Created and checked out branch: ${branchName}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to create branch: ${message}`);
+  }
+}
+async function commitAll(repoPath, message) {
+  const normalizedPath = toUnix(repoPath);
+  if (!await isGitRepo(normalizedPath)) {
+    throw new Error(`Not a git repository: ${normalizedPath}`);
+  }
+  try {
+    const git = createGit(normalizedPath);
+    await git.add("-A");
+    const result = await git.commit(message);
+    log.debug(`Committed changes: ${result.commit}`);
+    return result.commit;
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to commit: ${message2}`);
+  }
+}
+async function pushBranch(repoPath, branchName) {
+  const normalizedPath = toUnix(repoPath);
+  if (!await isGitRepo(normalizedPath)) {
+    throw new Error(`Not a git repository: ${normalizedPath}`);
+  }
+  try {
+    const git = createGit(normalizedPath);
+    await git.push("origin", branchName, ["--set-upstream"]);
+    log.debug(`Pushed branch ${branchName} to origin`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    if (message.includes("Permission denied") || message.includes("403") || message.includes("authentication failed")) {
+      throw new Error(
+        `Permission denied. You don't have write access to this repository.
+Consider forking the repository and pushing to your fork.`
+      );
+    }
+    throw new Error(`Failed to push: ${message}`);
+  }
+}
+
+// src/core/registry.ts
+var DEFAULT_MAX_DEPTH = 3;
+var DEFAULT_TIMEOUT_MS = 1e4;
+function normalizeRegistryUrl(url) {
+  const original = url.trim();
+  let filePath = "nocaap-registry.json";
+  let gitUrl = "";
+  let httpUrl = null;
+  let provider = "unknown";
+  let branch = null;
+  if (original.startsWith("git@") || original.startsWith("ssh://")) {
+    const hashIndex = original.indexOf("#");
+    if (hashIndex !== -1) {
+      gitUrl = original.substring(0, hashIndex);
+      filePath = original.substring(hashIndex + 1);
+    } else {
+      gitUrl = original.endsWith(".git") ? original : `${original}.git`;
+    }
+    if (original.includes("github.com")) provider = "github";
+    else if (original.includes("gitlab.com")) provider = "gitlab";
+    else if (original.includes("bitbucket.org")) provider = "bitbucket";
+    if (provider === "github") {
+      const match = gitUrl.match(/git@github\.com:(.+?)(?:\.git)?$/);
+      if (match) {
+        httpUrl = `https://raw.githubusercontent.com/${match[1]}/main/${filePath}`;
+      }
+    }
+    return { original, gitUrl, filePath, httpUrl, provider, branch };
+  }
+  const rawGitHubMatch = original.match(
+    /^https:\/\/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)\/(.+)$/
+  );
+  if (rawGitHubMatch) {
+    const [, org, repo, branchName, path2] = rawGitHubMatch;
+    gitUrl = `git@github.com:${org}/${repo}.git`;
+    filePath = path2;
+    httpUrl = original;
+    provider = "github";
+    branch = branchName ?? null;
+    return { original, gitUrl, filePath, httpUrl, provider, branch };
+  }
+  const blobMatch = original.match(
+    /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/
+  );
+  if (blobMatch) {
+    const [, org, repo, branchName, path2] = blobMatch;
+    gitUrl = `git@github.com:${org}/${repo}.git`;
+    filePath = path2;
+    httpUrl = `https://raw.githubusercontent.com/${org}/${repo}/${branchName}/${path2}`;
+    provider = "github";
+    branch = branchName ?? null;
+    return { original, gitUrl, filePath, httpUrl, provider, branch };
+  }
+  const repoMatch = original.match(
+    /^https:\/\/github\.com\/([^/]+)\/([^/]+?)(\/)?$/
+  );
+  if (repoMatch && repoMatch[1] && repoMatch[2]) {
+    const org = repoMatch[1];
+    const repo = repoMatch[2];
+    const cleanRepo = repo.replace(/\.git$/, "");
+    gitUrl = `git@github.com:${org}/${cleanRepo}.git`;
+    filePath = "nocaap-registry.json";
+    httpUrl = `https://raw.githubusercontent.com/${org}/${cleanRepo}/main/${filePath}`;
+    provider = "github";
+    return { original, gitUrl, filePath, httpUrl, provider, branch };
+  }
+  const gitlabMatch = original.match(
+    /^https:\/\/gitlab\.com\/([^/]+)\/([^/]+)/
+  );
+  if (gitlabMatch && gitlabMatch[1] && gitlabMatch[2]) {
+    const org = gitlabMatch[1];
+    const repo = gitlabMatch[2];
+    const cleanRepo = repo.replace(/\.git$/, "");
+    gitUrl = `git@gitlab.com:${org}/${cleanRepo}.git`;
+    provider = "gitlab";
+    const gitlabFileMatch = original.match(
+      /^https:\/\/gitlab\.com\/([^/]+)\/([^/]+)\/-\/blob\/([^/]+)\/(.+)$/
+    );
+    if (gitlabFileMatch && gitlabFileMatch[3] && gitlabFileMatch[4]) {
+      filePath = gitlabFileMatch[4];
+      branch = gitlabFileMatch[3];
+      httpUrl = `https://gitlab.com/${org}/${cleanRepo}/-/raw/${branch}/${filePath}`;
+    } else {
+      httpUrl = `https://gitlab.com/${org}/${cleanRepo}/-/raw/main/${filePath}`;
+    }
+    return { original, gitUrl, filePath, httpUrl, provider, branch };
+  }
+  const bitbucketMatch = original.match(
+    /^https:\/\/bitbucket\.org\/([^/]+)\/([^/]+)/
+  );
+  if (bitbucketMatch && bitbucketMatch[1] && bitbucketMatch[2]) {
+    const org = bitbucketMatch[1];
+    const repo = bitbucketMatch[2];
+    const cleanRepo = repo.replace(/\.git$/, "");
+    gitUrl = `git@bitbucket.org:${org}/${cleanRepo}.git`;
+    provider = "bitbucket";
+    httpUrl = `https://bitbucket.org/${org}/${cleanRepo}/raw/main/${filePath}`;
+    return { original, gitUrl, filePath, httpUrl, provider, branch };
+  }
+  if (original.startsWith("http://") || original.startsWith("https://")) {
+    return {
+      original,
+      gitUrl: "",
+      filePath: "",
+      httpUrl: original,
+      provider: "unknown",
+      branch: null
+    };
+  }
+  throw new Error(
+    `Unrecognized registry URL format: ${original}
+
+Supported formats:
+  https://github.com/org/repo
+  https://github.com/org/repo/blob/main/nocaap-registry.json
+  https://raw.githubusercontent.com/org/repo/main/file.json
+  git@github.com:org/repo.git
+  git@github.com:org/repo.git#path/to/registry.json`
+  );
+}
+async function fetchRegistryViaGit(repoUrl, filePath, branchHint) {
+  log.debug(`Fetching registry via Git: ${repoUrl} -> ${filePath}`);
+  let hasAccess;
+  try {
+    hasAccess = await checkAccess(repoUrl);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    if (message.includes("ENOENT") || message.includes("not found")) {
+      throw new Error(
+        `Git is not installed or not in PATH.
+
+To use private repositories, you need:
+  1. Git installed (https://git-scm.com)
+  2. SSH keys configured for your Git host`
+      );
+    }
+    throw new Error(`Failed to check repository access: ${message}`);
+  }
+  if (!hasAccess) {
+    throw new Error(
+      `Cannot access repository via SSH: ${repoUrl}
+
+Please check:
+  \u2022 You have SSH keys configured (run: ssh -T git@github.com)
+  \u2022 You have read access to the repository
+  \u2022 The repository URL is correct`
+    );
+  }
+  const tempDir = join(os.tmpdir(), `nocaap-registry-${Date.now()}`);
+  try {
+    const fileDir = dirname(filePath);
+    const sparsePath = fileDir === "." || fileDir === "" ? void 0 : fileDir;
+    const branch = branchHint || await getDefaultBranch(repoUrl);
+    await sparseClone({
+      repoUrl,
+      targetDir: tempDir,
+      sparsePath,
+      branch
+    });
+    const registryPath = join(tempDir, filePath);
+    if (!await exists(registryPath)) {
+      throw new Error(
+        `Registry file not found: ${filePath}
+
+Please check:
+  \u2022 The file path is correct
+  \u2022 The file exists in the repository
+  \u2022 Try: git@...#${filePath}`
+      );
+    }
+    const content = await fs2.readFile(registryPath, "utf-8");
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch {
+      throw new Error(`Invalid JSON in registry file: ${filePath}`);
+    }
+    const result = safeValidateRegistry(data);
+    if (!result.success) {
+      const errorMessages = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(`Invalid registry schema: ${errorMessages}`);
+    }
+    log.debug(`Successfully fetched registry via Git with ${result.data.contexts.length} contexts`);
+    return result.data;
+  } finally {
+    await fs2.remove(tempDir).catch(() => {
+      log.debug(`Failed to cleanup temp directory: ${tempDir}`);
+    });
+  }
+}
+var HttpFetchError = class extends Error {
+  constructor(message, status, shouldTrySSH) {
+    super(message);
+    this.status = status;
+    this.shouldTrySSH = shouldTrySSH;
+    this.name = "HttpFetchError";
+  }
+};
+async function fetchRegistryViaHttp(url) {
+  log.debug(`Fetching registry via HTTP: ${url}`);
+  let response;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+    response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeoutId);
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new HttpFetchError(
+        `Registry fetch timed out after ${DEFAULT_TIMEOUT_MS / 1e3}s`,
+        null,
+        false
+      );
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new HttpFetchError(`Network error: ${message}`, null, false);
+  }
+  if (!response.ok) {
+    const isGitHub = url.includes("githubusercontent.com") || url.includes("github.com");
+    const isGitLab = url.includes("gitlab.com");
+    const shouldTrySSH = (response.status === 404 || response.status === 403) && (isGitHub || isGitLab);
+    throw new HttpFetchError(
+      `HTTP ${response.status} ${response.statusText}`,
+      response.status,
+      shouldTrySSH
+    );
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new HttpFetchError("Invalid JSON response", null, false);
+  }
+  const result = safeValidateRegistry(data);
+  if (!result.success) {
+    const errorMessages = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    throw new Error(`Invalid registry schema: ${errorMessages}`);
+  }
+  log.debug(`Successfully fetched registry via HTTP with ${result.data.contexts.length} contexts`);
+  return result.data;
+}
+async function fetchRegistry(registryUrl) {
+  const normalized = normalizeRegistryUrl(registryUrl);
+  log.debug(`Normalized registry URL: ${JSON.stringify(normalized, null, 2)}`);
+  if (!normalized.httpUrl && normalized.gitUrl) {
+    log.debug("No HTTP URL available, using Git directly");
+    return fetchRegistryViaGit(normalized.gitUrl, normalized.filePath, normalized.branch);
+  }
+  if (normalized.httpUrl) {
+    try {
+      log.debug(`Trying HTTP fetch: ${normalized.httpUrl}`);
+      const registry = await fetchRegistryViaHttp(normalized.httpUrl);
+      return registry;
+    } catch (error) {
+      if (error instanceof HttpFetchError && error.shouldTrySSH && normalized.gitUrl) {
+        log.debug(`HTTP failed (${error.status}), trying SSH fallback`);
+        try {
+          return await fetchRegistryViaGit(
+            normalized.gitUrl,
+            normalized.filePath,
+            normalized.branch
+          );
+        } catch (sshError) {
+          const sshMessage = sshError instanceof Error ? sshError.message : "Unknown error";
+          throw new Error(
+            `Could not fetch registry from: ${registryUrl}
+
+HTTP attempt: ${error.message}
+SSH attempt: ${sshMessage}
+
+Possible solutions:
+  \u2022 Check the URL is correct
+  \u2022 For private repos: ensure SSH keys are configured
+  \u2022 Run: ssh -T git@github.com (to test SSH access)`
+          );
+        }
+      }
+      if (error instanceof HttpFetchError) {
+        const hint = error.shouldTrySSH ? `
+
+This might be a private repository. Try using SSH:
+  nocaap config registry ${normalized.gitUrl || "git@github.com:org/repo.git"}` : "";
+        throw new Error(
+          `Failed to fetch registry: ${error.message}${hint}`
+        );
+      }
+      throw error;
+    }
+  }
+  throw new Error(`Could not determine how to fetch registry from: ${registryUrl}`);
+}
+async function fetchRegistryWithImports(url, options) {
+  const visited = options?.visited ?? /* @__PURE__ */ new Set();
+  const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const currentDepth = options?.currentDepth ?? 0;
+  const normalizedUrl = url.replace(/\/$/, "").replace(/#.*$/, "");
+  if (visited.has(normalizedUrl)) {
+    log.warn(`Circular import detected, skipping: ${url}`);
+    return { contexts: [] };
+  }
+  if (currentDepth >= maxDepth) {
+    log.warn(`Max import depth (${maxDepth}) exceeded, skipping: ${url}`);
+    return { contexts: [] };
+  }
+  visited.add(normalizedUrl);
+  const registry = await fetchRegistry(url);
+  if (!registry.imports || registry.imports.length === 0) {
+    return registry;
+  }
+  log.debug(`Registry has ${registry.imports.length} imports, fetching...`);
+  const importPromises = registry.imports.map(async (importUrl) => {
+    try {
+      return await fetchRegistryWithImports(importUrl, {
+        visited,
+        maxDepth,
+        currentDepth: currentDepth + 1
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      log.warn(`Failed to fetch imported registry ${importUrl}: ${message}`);
+      return { contexts: [] };
+    }
+  });
+  const importedRegistries = await Promise.all(importPromises);
+  return mergeRegistries([registry, ...importedRegistries]);
+}
+function getContextKey(context) {
+  const path2 = context.path ?? "";
+  return `${context.repo}::${path2}`;
+}
+function mergeRegistries(registries) {
+  const contextMap = /* @__PURE__ */ new Map();
+  for (const registry of registries) {
+    for (const context of registry.contexts) {
+      const key = getContextKey(context);
+      contextMap.set(key, context);
+    }
+  }
+  const mergedContexts = Array.from(contextMap.values());
+  log.debug(`Merged ${registries.length} registries into ${mergedContexts.length} unique contexts`);
+  return {
+    name: registries[0]?.name,
+    // Preserve root registry name
+    contexts: mergedContexts
+    // Don't include imports in merged result (they've been resolved)
+  };
+}
+var CHARS_PER_TOKEN = 4;
+var TOKEN_BUDGET_WARNING = 8e3;
+var MAX_PREVIEW_LINES = 5;
+var DOC_EXTENSIONS = [".md", ".mdx"];
+async function parseDocFile(filePath, basePath) {
+  const normalizedPath = toUnix(filePath);
+  const relativePath = relative(basePath, normalizedPath);
+  log.debug(`Parsing doc file: ${relativePath}`);
+  const content = await fs2.readFile(normalizedPath, "utf-8");
+  const { data: frontmatter, content: body } = matter(content);
+  const title = extractTitle(frontmatter, body, normalizedPath);
+  const summary = frontmatter.summary ?? frontmatter.description;
+  const type = frontmatter.type;
+  const tags = Array.isArray(frontmatter.tags) ? frontmatter.tags.filter((t) => typeof t === "string") : void 0;
+  const preview = summary || extractPreview(body);
+  return {
+    title,
+    summary,
+    type,
+    tags,
+    relativePath,
+    preview
+  };
+}
+function extractTitle(frontmatter, body, filePath) {
+  if (typeof frontmatter.title === "string" && frontmatter.title.trim()) {
+    return frontmatter.title.trim();
+  }
+  const h1Match = body.match(/^#\s+(.+)$/m);
+  if (h1Match?.[1]) {
+    return h1Match[1].trim();
+  }
+  const filename = basename(filePath, extname(filePath));
+  return filename.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function extractPreview(body) {
+  const lines = body.split("\n");
+  const previewLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    if (trimmed === "---") {
+      continue;
+    }
+    previewLines.push(trimmed);
+    if (previewLines.length >= MAX_PREVIEW_LINES) {
+      break;
+    }
+  }
+  let preview = previewLines.join(" ");
+  if (preview.length > 300) {
+    preview = preview.slice(0, 300);
+    const lastSpace = preview.lastIndexOf(" ");
+    if (lastSpace > 200) {
+      preview = preview.slice(0, lastSpace);
+    }
+    preview += "...";
+  }
+  return preview;
+}
+async function findDocFiles(dirPath) {
+  const results = [];
+  if (!await exists(dirPath)) {
+    return results;
+  }
+  const entries = await fs2.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const subFiles = await findDocFiles(fullPath);
+      results.push(...subFiles);
+    } else if (entry.isFile()) {
+      const ext = extname(entry.name).toLowerCase();
+      if (DOC_EXTENSIONS.includes(ext)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  return results;
+}
+async function generateIndex(projectRoot) {
+  const contextDir = getContextDir(projectRoot);
+  getPackagesDir(projectRoot);
+  const warnings = [];
+  log.debug(`Generating index for ${projectRoot}`);
+  const config = await readConfig(projectRoot);
+  if (!config || config.packages.length === 0) {
+    log.debug("No packages configured, generating empty index");
+    return {
+      content: generateEmptyIndex(),
+      fileCount: 0,
+      tokenEstimate: 0,
+      warnings: ["No packages configured"]
+    };
+  }
+  const packageIndexes = [];
+  let totalFiles = 0;
+  for (const pkg of config.packages) {
+    const packagePath = getPackagePath(projectRoot, pkg.alias);
+    if (!await exists(packagePath)) {
+      log.debug(`Package directory not found: ${pkg.alias}`);
+      warnings.push(`Package '${pkg.alias}' directory not found`);
+      continue;
+    }
+    const docFiles = await findDocFiles(packagePath);
+    if (docFiles.length === 0) {
+      log.debug(`No documentation files found in package: ${pkg.alias}`);
+      warnings.push(`No .md/.mdx files found in '${pkg.alias}'`);
+      continue;
+    }
+    const fileMetas = [];
+    for (const filePath of docFiles) {
+      try {
+        const meta = await parseDocFile(filePath, contextDir);
+        fileMetas.push(meta);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        log.debug(`Failed to parse ${filePath}: ${message}`);
+        warnings.push(`Failed to parse: ${relative(contextDir, filePath)}`);
+      }
+    }
+    fileMetas.sort((a, b) => a.title.localeCompare(b.title));
+    packageIndexes.push({
+      alias: pkg.alias,
+      files: fileMetas
+    });
+    totalFiles += fileMetas.length;
+  }
+  packageIndexes.sort((a, b) => a.alias.localeCompare(b.alias));
+  const content = generateIndexMarkdown(packageIndexes);
+  const tokenEstimate = Math.ceil(content.length / CHARS_PER_TOKEN);
+  if (tokenEstimate > TOKEN_BUDGET_WARNING) {
+    warnings.push(
+      `INDEX.md exceeds recommended token budget: ~${tokenEstimate.toLocaleString()} tokens (recommended: <${TOKEN_BUDGET_WARNING.toLocaleString()})`
+    );
+  }
+  log.debug(
+    `Index generated: ${totalFiles} files, ~${tokenEstimate.toLocaleString()} tokens`
+  );
+  return {
+    content,
+    fileCount: totalFiles,
+    tokenEstimate,
+    warnings
+  };
+}
+function generateEmptyIndex() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `# Context Index
+
+> Auto-generated by nocaap. Last updated: ${timestamp}
+
+No packages configured. Run \`nocaap setup\` or \`nocaap add <repo>\` to add context packages.
+`;
+}
+function generateIndexMarkdown(packages) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [
+    "# Context Index",
+    "",
+    `> Auto-generated by nocaap. Last updated: ${timestamp}`,
+    ""
+  ];
+  if (packages.length > 1) {
+    lines.push("## Table of Contents");
+    lines.push("");
+    for (const pkg of packages) {
+      const anchorId = pkg.alias.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      lines.push(`- [${pkg.alias}](#${anchorId}) (${pkg.files.length} files)`);
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  for (const pkg of packages) {
+    lines.push(`## ${pkg.alias} (${pkg.files.length} files)`);
+    lines.push("");
+    for (const file of pkg.files) {
+      lines.push(`### ${file.title}`);
+      lines.push("");
+      lines.push(`**Path:** \`${file.relativePath}\``);
+      if (file.type) {
+        lines.push(`**Type:** ${file.type}`);
+      }
+      if (file.tags && file.tags.length > 0) {
+        lines.push(`**Tags:** ${file.tags.join(", ")}`);
+      }
+      lines.push("");
+      lines.push(file.preview);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+async function writeIndex(projectRoot) {
+  const result = await generateIndex(projectRoot);
+  const indexPath = getIndexPath(projectRoot);
+  await fs2.writeFile(indexPath, result.content, "utf-8");
+  log.debug(`Wrote INDEX.md to ${indexPath}`);
+  return result;
+}
+async function generateIndexWithProgress(projectRoot) {
+  log.info("Regenerating INDEX.md...");
+  const result = await writeIndex(projectRoot);
+  if (result.fileCount === 0) {
+    log.warn("No documentation files found");
+  } else {
+    log.success(
+      `Generated INDEX.md: ${result.fileCount} files, ~${result.tokenEstimate.toLocaleString()} tokens`
+    );
+  }
+  for (const warning of result.warnings) {
+    log.warn(warning);
+  }
+  return result;
+}
+
+// src/commands/setup.ts
+var DEFAULT_REGISTRY_PROMPT = "Enter your organization's registry URL:";
+async function setupCommand(options) {
+  const projectRoot = process.cwd();
+  log.title("nocaap Setup Wizard");
+  log.newline();
+  if (await configExists(projectRoot)) {
+    const config = await readConfig(projectRoot);
+    if (config && config.packages.length > 0) {
+      log.warn("nocaap is already configured in this project.");
+      log.dim(`  ${config.packages.length} package(s) installed`);
+      log.newline();
+      const shouldContinue = await confirm({
+        message: "Do you want to add more packages?",
+        default: true
+      });
+      if (!shouldContinue) {
+        log.info("Setup cancelled.");
+        return;
+      }
+    }
+  }
+  let registryUrl = options.registry;
+  if (!registryUrl) {
+    const defaultRegistry = await getDefaultRegistry();
+    if (defaultRegistry) {
+      log.info(`Using default registry: ${style.url(defaultRegistry)}`);
+      log.dim("(from global config - run `nocaap config registry` to change)");
+      log.newline();
+      const useDefault = await confirm({
+        message: "Use this registry?",
+        default: true
+      });
+      if (useDefault) {
+        registryUrl = defaultRegistry;
+      }
+    }
+  }
+  if (!registryUrl) {
+    registryUrl = await input({
+      message: DEFAULT_REGISTRY_PROMPT,
+      validate: (value) => {
+        if (!value.trim()) {
+          return "Registry URL is required";
+        }
+        try {
+          new URL(value);
+          return true;
+        } catch {
+          return "Please enter a valid URL";
+        }
+      }
+    });
+    log.newline();
+    const saveAsDefault = await confirm({
+      message: "Save this as your default registry?",
+      default: true
+    });
+    if (saveAsDefault) {
+      await setDefaultRegistry(registryUrl);
+      log.success("Saved to global config!");
+    }
+  }
+  log.newline();
+  const fetchSpinner = createSpinner("Fetching registry...").start();
+  let registry;
+  try {
+    registry = await fetchRegistryWithImports(registryUrl);
+    fetchSpinner.succeed(
+      `Fetched registry: ${registry.contexts.length} context(s) available`
+    );
+  } catch (error) {
+    fetchSpinner.fail("Failed to fetch registry");
+    throw error;
+  }
+  if (registry.contexts.length === 0) {
+    log.warn("No contexts found in registry.");
+    return;
+  }
+  log.newline();
+  const accessSpinner = createSpinner("Checking repository access...").start();
+  const accessResults = [];
+  for (const context of registry.contexts) {
+    const hasAccess = await checkAccess(context.repo);
+    accessResults.push({ context, hasAccess });
+  }
+  const accessibleContexts = accessResults.filter((r) => r.hasAccess);
+  const inaccessibleContexts = accessResults.filter((r) => !r.hasAccess);
+  accessSpinner.succeed(
+    `Access check complete: ${accessibleContexts.length} accessible, ${inaccessibleContexts.length} restricted`
+  );
+  if (inaccessibleContexts.length > 0) {
+    log.newline();
+    log.dim("Restricted contexts (no access):");
+    for (const { context } of inaccessibleContexts) {
+      log.dim(`  - ${context.name}`);
+    }
+  }
+  if (accessibleContexts.length === 0) {
+    log.newline();
+    log.error("No accessible contexts found. Check your SSH keys and permissions.");
+    return;
+  }
+  log.newline();
+  const choices = accessibleContexts.map(({ context }) => ({
+    name: formatContextChoice(context),
+    value: context.name,
+    checked: false
+  }));
+  const selectedNames = await checkbox({
+    message: "Select contexts to install:",
+    choices,
+    pageSize: 15
+  });
+  if (selectedNames.length === 0) {
+    log.warn("No contexts selected. Setup cancelled.");
+    return;
+  }
+  log.newline();
+  if (!await configExists(projectRoot)) {
+    const initSpinner = createSpinner("Initializing .context/ directory...").start();
+    await initContextDir(projectRoot);
+    initSpinner.succeed("Initialized .context/ directory");
+  }
+  const existingConfig = await readConfig(projectRoot) ?? { packages: [] };
+  existingConfig.registryUrl = registryUrl;
+  await writeConfig(projectRoot, existingConfig);
+  log.newline();
+  log.info(`Installing ${selectedNames.length} context(s)...`);
+  log.newline();
+  let successCount = 0;
+  let failCount = 0;
+  for (const name of selectedNames) {
+    const context = accessibleContexts.find((r) => r.context.name === name)?.context;
+    if (!context) continue;
+    const alias = generateAlias(context);
+    const spinner = createSpinner(`Installing ${style.bold(context.name)}...`).start();
+    try {
+      const targetDir = getPackagePath(projectRoot, alias);
+      const { commitHash } = await sparseClone({
+        repoUrl: context.repo,
+        targetDir,
+        sparsePath: context.path
+      });
+      await upsertPackage(projectRoot, {
+        alias,
+        source: context.repo,
+        path: context.path,
+        version: "main"
+      });
+      await updateLockEntry(projectRoot, alias, {
+        commitHash,
+        sparsePath: context.path || "",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      spinner.succeed(`Installed ${context.name} \u2192 ${alias}`);
+      successCount++;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      spinner.fail(`Failed to install ${context.name}: ${message}`);
+      failCount++;
+    }
+  }
+  log.newline();
+  if (successCount > 0) {
+    await generateIndexWithProgress(projectRoot);
+  }
+  if (successCount > 0) {
+    log.newline();
+    log.hr();
+    log.newline();
+    log.info("IDE Integration (optional)");
+    log.newline();
+    const addCursor = await confirm({
+      message: "Add nocaap reference to Cursor rules?",
+      default: true
+    });
+    if (addCursor) {
+      const updated = await updateCursorRules(projectRoot);
+      if (updated) {
+        log.success("Added nocaap reference to Cursor rules");
+      } else {
+        log.dim("Cursor rules already configured");
+      }
+    }
+    const addClaude = await confirm({
+      message: "Add nocaap reference to CLAUDE.md?",
+      default: true
+    });
+    if (addClaude) {
+      const updated = await updateClaudeMd(projectRoot);
+      if (updated) {
+        log.success("Added nocaap reference to CLAUDE.md");
+      } else {
+        log.dim("CLAUDE.md already configured");
+      }
+    }
+  }
+  log.newline();
+  log.hr();
+  log.newline();
+  if (successCount > 0) {
+    log.success(`Setup complete! ${successCount} context(s) installed.`);
+    log.newline();
+    log.info("Next steps:");
+    log.dim("  1. Review .context/INDEX.md for available documentation");
+    log.dim("  2. Run `nocaap update` to pull latest changes");
+  }
+  if (failCount > 0) {
+    log.newline();
+    log.warn(`${failCount} context(s) failed to install.`);
+  }
+}
+function formatContextChoice(context) {
+  let display = context.name;
+  if (context.description) {
+    display += ` - ${context.description}`;
+  }
+  if (context.tags && context.tags.length > 0) {
+    display += ` [${context.tags.join(", ")}]`;
+  }
+  return display;
+}
+function generateAlias(context) {
+  if (context.path) {
+    const leafFolder = context.path.split("/").filter(Boolean).pop();
+    if (leafFolder) {
+      return leafFolder.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+    }
+  }
+  return context.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+
+// src/commands/add.ts
+function extractAliasFromUrl(url) {
+  const cleaned = url.replace(/\.git$/, "");
+  const segments = cleaned.split(/[/:]/);
+  const lastSegment = segments[segments.length - 1];
+  return lastSegment?.replace(/[^a-zA-Z0-9-_]/g, "") || "context";
+}
+function deriveAlias(url, path2) {
+  if (path2) {
+    const leafFolder = path2.split("/").filter(Boolean).pop();
+    if (leafFolder) {
+      return leafFolder.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+    }
+  }
+  return extractAliasFromUrl(url);
+}
+function validateAlias(alias) {
+  return /^[a-zA-Z0-9][a-zA-Z0-9-_]{0,49}$/.test(alias);
+}
+async function addCommand(repo, options) {
+  const projectRoot = process.cwd();
+  const alias = options.alias || deriveAlias(repo, options.path);
+  log.title("Adding context package");
+  log.info(`Repository: ${repo}`);
+  log.info(`Alias: ${alias}`);
+  if (options.path) {
+    log.info(`Path: ${options.path}`);
+  }
+  if (options.branch && options.branch !== "main") {
+    log.info(`Branch: ${options.branch}`);
+  }
+  log.newline();
+  if (!validateAlias(alias)) {
+    throw new Error(
+      `Invalid alias '${alias}'. Must be alphanumeric (can include - or _), 1-50 characters.`
+    );
+  }
+  const accessSpinner = createSpinner("Checking repository access...").start();
+  const hasAccess = await checkAccess(repo);
+  if (!hasAccess) {
+    accessSpinner.fail("Repository access denied");
+    throw new Error(
+      `Cannot access repository: ${repo}
+Please check:
+  - The URL is correct
+  - You have SSH keys configured (for git@ URLs)
+  - You have read access to the repository`
+    );
+  }
+  accessSpinner.succeed("Repository access confirmed");
+  if (!await configExists(projectRoot)) {
+    const initSpinner = createSpinner("Initializing .context/ directory...").start();
+    await initContextDir(projectRoot);
+    initSpinner.succeed("Initialized .context/ directory");
+  }
+  const targetDir = getPackagePath(projectRoot, alias);
+  const cloneSpinner = createSpinner("Cloning repository...").start();
+  try {
+    const { commitHash } = await sparseClone({
+      repoUrl: repo,
+      targetDir,
+      sparsePath: options.path,
+      branch: options.branch
+    });
+    cloneSpinner.succeed(`Cloned to .context/packages/${alias}`);
+    const configSpinner = createSpinner("Updating configuration...").start();
+    await upsertPackage(projectRoot, {
+      alias,
+      source: repo,
+      path: options.path,
+      version: options.branch || "main"
+    });
+    await updateLockEntry(projectRoot, alias, {
+      commitHash,
+      sparsePath: options.path || "",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    configSpinner.succeed("Configuration updated");
+    log.newline();
+    await generateIndexWithProgress(projectRoot);
+    log.newline();
+    log.success(`Package '${alias}' added successfully!`);
+    log.dim(`  Location: .context/packages/${alias}`);
+    log.dim(`  Commit: ${commitHash.slice(0, 8)}`);
+  } catch (error) {
+    cloneSpinner.fail("Clone failed");
+    throw error;
+  }
+}
+
+// src/commands/update.ts
+async function updateCommand(alias, options) {
+  const projectRoot = process.cwd();
+  log.title("Updating context packages");
+  const config = await readConfig(projectRoot);
+  if (!config || config.packages.length === 0) {
+    throw new Error(
+      "No packages configured. Run `nocaap setup` or `nocaap add <repo>` first."
+    );
+  }
+  const packagesToUpdate = alias ? config.packages.filter((p) => p.alias === alias) : config.packages;
+  if (alias && packagesToUpdate.length === 0) {
+    throw new Error(`Package '${alias}' not found in configuration.`);
+  }
+  log.info(`Updating ${packagesToUpdate.length} package(s)...`);
+  log.newline();
+  const results = [];
+  for (const pkg of packagesToUpdate) {
+    const result = await updatePackage(projectRoot, pkg, options);
+    results.push(result);
+  }
+  log.newline();
+  log.hr();
+  log.newline();
+  const updated = results.filter((r) => r.status === "updated");
+  const upToDate = results.filter((r) => r.status === "up-to-date");
+  const skipped = results.filter((r) => r.status === "skipped");
+  const errors = results.filter((r) => r.status === "error");
+  if (updated.length > 0) {
+    log.success(`${updated.length} package(s) updated`);
+    for (const r of updated) {
+      log.dim(`  ${r.alias}: ${r.oldCommit?.slice(0, 8)} \u2192 ${r.newCommit?.slice(0, 8)}`);
+    }
+  }
+  if (upToDate.length > 0) {
+    log.info(`${upToDate.length} package(s) already up-to-date`);
+  }
+  if (skipped.length > 0) {
+    log.warn(`${skipped.length} package(s) skipped`);
+    for (const r of skipped) {
+      log.dim(`  ${r.alias}: ${r.error}`);
+    }
+  }
+  if (errors.length > 0) {
+    log.error(`${errors.length} package(s) failed`);
+    for (const r of errors) {
+      log.dim(`  ${r.alias}: ${r.error}`);
+    }
+  }
+  if (updated.length > 0) {
+    log.newline();
+    await generateIndexWithProgress(projectRoot);
+  }
+  if (errors.length > 0) {
+    throw new Error(`${errors.length} package(s) failed to update`);
+  }
+}
+async function updatePackage(projectRoot, pkg, options) {
+  const packagePath = getPackagePath(projectRoot, pkg.alias);
+  const spinner = createSpinner(`Updating ${style.bold(pkg.alias)}...`).start();
+  try {
+    if (!await exists(packagePath)) {
+      spinner.warn(`${pkg.alias}: Package directory not found`);
+      return {
+        alias: pkg.alias,
+        status: "skipped",
+        error: "Directory not found"
+      };
+    }
+    if (!await isGitRepo(packagePath)) {
+      spinner.warn(`${pkg.alias}: Not a git repository`);
+      return {
+        alias: pkg.alias,
+        status: "skipped",
+        error: "Not a git repository"
+      };
+    }
+    if (await isDirty(packagePath)) {
+      spinner.warn(`${pkg.alias}: Has uncommitted changes`);
+      return {
+        alias: pkg.alias,
+        status: "skipped",
+        error: "Uncommitted changes (commit or discard first)"
+      };
+    }
+    const lockEntry = await getLockEntry(projectRoot, pkg.alias);
+    if (lockEntry && lockEntry.sparsePath !== (pkg.path || "")) {
+      spinner.warn(`${pkg.alias}: Sparse path changed in config`);
+      log.dim(`    Config: ${pkg.path || "(root)"}`);
+      log.dim(`    Locked: ${lockEntry.sparsePath || "(root)"}`);
+      return {
+        alias: pkg.alias,
+        status: "skipped",
+        error: "Sparse path changed (run `nocaap remove` then `nocaap add` to re-clone)"
+      };
+    }
+    const oldCommit = await getHeadCommit(packagePath);
+    const { commitHash: newCommit } = await pull(packagePath);
+    if (oldCommit === newCommit && !options.force) {
+      spinner.info(`${pkg.alias}: Already up-to-date`);
+      return {
+        alias: pkg.alias,
+        status: "up-to-date",
+        oldCommit,
+        newCommit
+      };
+    }
+    await updateLockEntry(projectRoot, pkg.alias, {
+      commitHash: newCommit,
+      sparsePath: pkg.path || "",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    spinner.succeed(`${pkg.alias}: Updated`);
+    return {
+      alias: pkg.alias,
+      status: "updated",
+      oldCommit,
+      newCommit
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail(`${pkg.alias}: Failed`);
+    return {
+      alias: pkg.alias,
+      status: "error",
+      error: message
+    };
+  }
+}
+
+// src/commands/list.ts
+async function listCommand() {
+  const projectRoot = process.cwd();
+  const config = await readConfig(projectRoot);
+  const lockfile = await readLockfile(projectRoot);
+  if (!config || config.packages.length === 0) {
+    log.info("No packages installed.");
+    log.dim("Run `nocaap setup` or `nocaap add <repo>` to get started.");
+    return;
+  }
+  log.title("Installed Packages");
+  if (config.registryUrl) {
+    log.dim(`Registry: ${config.registryUrl}`);
+    log.newline();
+  }
+  for (const pkg of config.packages) {
+    const lock = lockfile[pkg.alias];
+    const commit = lock?.commitHash?.slice(0, 8) ?? "unknown";
+    const packagePath = getPackagePath(projectRoot, pkg.alias);
+    let statusIndicator = style.success("\u25CF");
+    let statusText = "";
+    if (!await exists(packagePath)) {
+      statusIndicator = style.error("\u25CB");
+      statusText = " (missing)";
+    } else if (await isGitRepo(packagePath)) {
+      try {
+        if (await isDirty(packagePath)) {
+          statusIndicator = style.warn("\u25CF");
+          statusText = " (modified)";
+        }
+      } catch {
+      }
+    }
+    log.plain(`${statusIndicator} ${style.bold(pkg.alias)}${statusText}`);
+    log.dim(`    Source: ${pkg.source}`);
+    if (pkg.path) {
+      log.dim(`    Path:   ${pkg.path}`);
+    }
+    log.dim(`    Branch: ${pkg.version || "main"}`);
+    log.dim(`    Commit: ${commit}`);
+    if (lock?.updatedAt) {
+      const updated = new Date(lock.updatedAt).toLocaleDateString();
+      log.dim(`    Updated: ${updated}`);
+    }
+    log.newline();
+  }
+  log.hr();
+  log.dim(`${config.packages.length} package(s) installed`);
+}
+async function removeCommand(alias, options) {
+  const projectRoot = process.cwd();
+  log.title("Removing context package");
+  const pkg = await getPackage(projectRoot, alias);
+  if (!pkg) {
+    throw new Error(
+      `Package '${alias}' not found in configuration.
+Run \`nocaap list\` to see installed packages.`
+    );
+  }
+  log.info(`Package: ${alias}`);
+  log.dim(`  Source: ${pkg.source}`);
+  if (pkg.path) {
+    log.dim(`  Path: ${pkg.path}`);
+  }
+  log.newline();
+  const packagePath = getPackagePath(projectRoot, alias);
+  if (!options.force && await exists(packagePath)) {
+    if (await isGitRepo(packagePath)) {
+      try {
+        if (await isDirty(packagePath)) {
+          log.warn("Package has uncommitted changes.");
+          log.newline();
+          const shouldContinue = await confirm({
+            message: "Remove anyway? Local changes will be lost.",
+            default: false
+          });
+          if (!shouldContinue) {
+            log.info("Removal cancelled.");
+            return;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  const dirSpinner = createSpinner("Removing package directory...").start();
+  try {
+    if (await exists(packagePath)) {
+      const fs8 = await import('fs-extra');
+      await fs8.default.remove(packagePath);
+    }
+    dirSpinner.succeed("Removed package directory");
+  } catch (error) {
+    dirSpinner.fail("Failed to remove directory");
+    throw error;
+  }
+  const configSpinner = createSpinner("Updating configuration...").start();
+  try {
+    await removePackage(projectRoot, alias);
+    await removeLockEntry(projectRoot, alias);
+    configSpinner.succeed("Configuration updated");
+  } catch (error) {
+    configSpinner.fail("Failed to update configuration");
+    throw error;
+  }
+  log.newline();
+  await generateIndexWithProgress(projectRoot);
+  log.newline();
+  log.success(`Package '${alias}' removed successfully.`);
+}
+
+// src/commands/config.ts
+async function configCommand(key, value, options) {
+  if (options.list || !key && !value) {
+    await showAllConfig();
+    return;
+  }
+  switch (key) {
+    case "registry":
+      await handleRegistryConfig(value, options.clear);
+      break;
+    default:
+      log.error(`Unknown config key: ${style.code(key ?? "")}`);
+      log.newline();
+      log.info("Available keys:");
+      log.dim("  registry  - Default registry URL for `nocaap setup`");
+      break;
+  }
+}
+async function showAllConfig() {
+  const config = await getGlobalConfig();
+  const configPath = getGlobalConfigPath();
+  log.title("Global Configuration");
+  log.dim(`Location: ${configPath}`);
+  log.newline();
+  if (Object.keys(config).length === 0 || !config.defaultRegistry) {
+    log.info("No configuration set.");
+    log.newline();
+    log.dim("Set your organization's registry:");
+    log.dim("  nocaap config registry <url>");
+    return;
+  }
+  if (config.defaultRegistry) {
+    log.info(`${style.bold("registry")}: ${config.defaultRegistry}`);
+  }
+  if (config.updatedAt) {
+    log.newline();
+    log.dim(`Last updated: ${new Date(config.updatedAt).toLocaleString()}`);
+  }
+}
+async function handleRegistryConfig(value, clear) {
+  if (clear) {
+    await clearDefaultRegistry();
+    log.success("Default registry cleared.");
+    return;
+  }
+  if (value) {
+    try {
+      new URL(value);
+    } catch {
+      throw new Error(
+        `Invalid URL: ${value}
+Please provide a valid URL, e.g.:
+  https://raw.githubusercontent.com/your-org/hub/main/nocaap-registry.json`
+      );
+    }
+    await setDefaultRegistry(value);
+    log.success("Default registry set!");
+    log.newline();
+    log.info(`Registry: ${style.url(value)}`);
+    log.newline();
+    log.dim("Now you can run `nocaap setup` without the --registry flag.");
+    return;
+  }
+  const registry = await getDefaultRegistry();
+  if (registry) {
+    const envVar = process.env.NOCAAP_DEFAULT_REGISTRY;
+    log.info(`Default registry: ${style.url(registry)}`);
+    if (envVar) {
+      log.dim("  (from NOCAAP_DEFAULT_REGISTRY environment variable)");
+    } else {
+      log.dim("  (from global config)");
+    }
+  } else {
+    log.info("No default registry configured.");
+    log.newline();
+    log.dim("Set one with:");
+    log.dim("  nocaap config registry <url>");
+    log.newline();
+    log.dim("Example:");
+    log.dim(
+      "  nocaap config registry https://raw.githubusercontent.com/your-org/hub/main/nocaap-registry.json"
+    );
+  }
+}
+
+// src/utils/providers.ts
+function detectProvider(url) {
+  const normalized = url.toLowerCase();
+  if (normalized.includes("github.com") || normalized.includes("github:")) {
+    return "github";
+  }
+  if (normalized.includes("gitlab.com") || normalized.includes("gitlab:")) {
+    return "gitlab";
+  }
+  if (normalized.includes("bitbucket.org") || normalized.includes("bitbucket:")) {
+    return "bitbucket";
+  }
+  return "unknown";
+}
+function parseRepoInfo(url) {
+  const provider = detectProvider(url);
+  const cleaned = url.replace(/\.git$/, "");
+  const sshMatch = cleaned.match(/git@[^:]+:([^/]+)\/(.+)/);
+  if (sshMatch && sshMatch[1] && sshMatch[2]) {
+    return {
+      provider,
+      owner: sshMatch[1],
+      repo: sshMatch[2]
+    };
+  }
+  const httpsMatch = cleaned.match(/https?:\/\/[^/]+\/([^/]+)\/(.+)/);
+  if (httpsMatch && httpsMatch[1] && httpsMatch[2]) {
+    return {
+      provider,
+      owner: httpsMatch[1],
+      repo: httpsMatch[2]
+    };
+  }
+  return {
+    provider,
+    owner: "",
+    repo: ""
+  };
+}
+function buildNewPrUrl(info, branch) {
+  const { provider, owner, repo } = info;
+  switch (provider) {
+    case "github":
+      return `https://github.com/${owner}/${repo}/compare/main...${branch}?expand=1`;
+    case "gitlab":
+      return `https://gitlab.com/${owner}/${repo}/-/merge_requests/new?merge_request[source_branch]=${branch}`;
+    case "bitbucket":
+      return `https://bitbucket.org/${owner}/${repo}/pull-requests/new?source=${branch}`;
+    default:
+      return `https://github.com/${owner}/${repo}`;
+  }
+}
+var execAsync = promisify(exec);
+async function isGhAvailable() {
+  try {
+    await execAsync("gh auth status");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasGitHubToken() {
+  return Boolean(process.env.GITHUB_TOKEN);
+}
+async function detectPrMethod() {
+  if (await isGhAvailable()) {
+    log.debug("gh CLI available and authenticated");
+    return "gh";
+  }
+  if (hasGitHubToken()) {
+    log.debug("GITHUB_TOKEN available for API");
+    return "api";
+  }
+  log.debug("No automated PR method available, will use manual URL");
+  return "manual";
+}
+async function createPrViaGh(repoDir, branch, title, body) {
+  log.debug(`Creating PR via gh CLI in ${repoDir}`);
+  try {
+    const { stdout } = await execAsync(
+      `gh pr create --title "${escapeShell(title)}" --body "${escapeShell(body)}" --head "${branch}"`,
+      { cwd: repoDir }
+    );
+    const url = stdout.trim();
+    log.debug(`PR created via gh: ${url}`);
+    return url;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    log.debug(`gh pr create failed: ${message}`);
+    return null;
+  }
+}
+async function createPrViaApi(owner, repo, branch, baseBranch, title, body) {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    log.debug("No GITHUB_TOKEN available for API");
+    return null;
+  }
+  log.debug(`Creating PR via GitHub API for ${owner}/${repo}`);
+  try {
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "Content-Type": "application/json",
+        "X-GitHub-Api-Version": "2022-11-28"
+      },
+      body: JSON.stringify({
+        title,
+        body,
+        head: branch,
+        base: baseBranch
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      log.debug(`GitHub API error: ${response.status} - ${JSON.stringify(errorData)}`);
+      return null;
+    }
+    const data = await response.json();
+    const url = data.html_url || null;
+    if (url) {
+      log.debug(`PR created via API: ${url}`);
+    }
+    return url;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    log.debug(`GitHub API request failed: ${message}`);
+    return null;
+  }
+}
+async function createPr(options) {
+  const method = await detectPrMethod();
+  switch (method) {
+    case "gh": {
+      const url = await createPrViaGh(
+        options.repoDir,
+        options.branch,
+        options.title,
+        options.body
+      );
+      if (url) {
+        return { url, method: "gh", success: true };
+      }
+      log.debug("gh CLI failed, trying GitHub API");
+      if (hasGitHubToken()) {
+        const apiUrl = await createPrViaApi(
+          options.owner,
+          options.repo,
+          options.branch,
+          options.baseBranch,
+          options.title,
+          options.body
+        );
+        if (apiUrl) {
+          return { url: apiUrl, method: "api", success: true };
+        }
+      }
+      return {
+        url: options.manualUrl,
+        method: "manual",
+        success: false,
+        error: "Could not create PR automatically. Please create it manually."
+      };
+    }
+    case "api": {
+      const url = await createPrViaApi(
+        options.owner,
+        options.repo,
+        options.branch,
+        options.baseBranch,
+        options.title,
+        options.body
+      );
+      if (url) {
+        return { url, method: "api", success: true };
+      }
+      return {
+        url: options.manualUrl,
+        method: "manual",
+        success: false,
+        error: "Could not create PR via API. Please create it manually."
+      };
+    }
+    case "manual":
+    default:
+      return {
+        url: options.manualUrl,
+        method: "manual",
+        success: false,
+        error: "No automated PR creation method available."
+      };
+  }
+}
+function escapeShell(str) {
+  return str.replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+
+// src/commands/push.ts
+function getDateString() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}${month}${day}`;
+}
+function generateBranchName(alias) {
+  return `nocaap/${alias}-${getDateString()}`;
+}
+async function getAllPackages(projectRoot) {
+  const config = await readConfig(projectRoot);
+  const lockfile = await readLockfile(projectRoot);
+  if (!config) {
+    return [];
+  }
+  return config.packages.map((pkg) => ({
+    alias: pkg.alias,
+    source: pkg.source,
+    path: pkg.path,
+    localCommit: lockfile[pkg.alias]?.commitHash || ""
+  }));
+}
+async function selectPackagesToPush(packages) {
+  if (packages.length === 0) {
+    return [];
+  }
+  const choices = packages.map((pkg) => ({
+    name: `${pkg.alias} (${pkg.source})`,
+    value: pkg.alias,
+    checked: false
+  }));
+  const selected = await checkbox({
+    message: "Select packages to push:",
+    choices,
+    pageSize: 15
+  });
+  return selected;
+}
+async function pushSinglePackage(projectRoot, pkg, commitMessage) {
+  const packagePath = getPackagePath(projectRoot, pkg.alias);
+  const branchName = generateBranchName(pkg.alias);
+  const repoInfo = parseRepoInfo(pkg.source);
+  const checkSpinner = createSpinner("Checking upstream...").start();
+  try {
+    const defaultBranch = await getDefaultBranch(pkg.source);
+    const remoteCommit = await getRemoteCommitHash(pkg.source, defaultBranch);
+    if (remoteCommit !== pkg.localCommit) {
+      checkSpinner.fail("Upstream has diverged");
+      return {
+        success: false,
+        error: `Upstream has changed. Run 'nocaap update ${pkg.alias}' first.`
+      };
+    }
+    checkSpinner.succeed("Upstream in sync");
+  } catch (error) {
+    checkSpinner.fail("Failed to check upstream");
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: msg };
+  }
+  const cloneSpinner = createSpinner("Cloning upstream...").start();
+  let tempDir;
+  let cleanup;
+  try {
+    const defaultBranch = await getDefaultBranch(pkg.source);
+    const result = await cloneToTemp(pkg.source, defaultBranch);
+    tempDir = result.tempDir;
+    cleanup = result.cleanup;
+    cloneSpinner.succeed("Cloned to temp directory");
+  } catch (error) {
+    cloneSpinner.fail("Clone failed");
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: msg };
+  }
+  try {
+    const branchSpinner = createSpinner("Creating branch...").start();
+    await createBranch(tempDir, branchName);
+    branchSpinner.succeed(`Created branch: ${branchName}`);
+    const copySpinner = createSpinner("Copying changes...").start();
+    const targetPath = pkg.path ? join(tempDir, pkg.path.replace(/^\/+/, "")) : tempDir;
+    await ensureDir(targetPath);
+    const items = await fs2.readdir(packagePath);
+    for (const item of items) {
+      if (item === ".git") continue;
+      const srcPath = join(packagePath, item);
+      const destPath = join(targetPath, item);
+      await fs2.copy(srcPath, destPath, { overwrite: true });
+    }
+    copySpinner.succeed("Changes copied");
+    const commitSpinner = createSpinner("Committing...").start();
+    try {
+      await commitAll(tempDir, commitMessage);
+      commitSpinner.succeed("Changes committed");
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "";
+      if (msg.includes("nothing to commit")) {
+        commitSpinner.warn("No changes to commit");
+        await cleanup();
+        return { success: true, error: "No changes detected" };
+      }
+      throw error;
+    }
+    const pushSpinner = createSpinner("Pushing to remote...").start();
+    try {
+      await pushBranch(tempDir, branchName);
+      pushSpinner.succeed("Pushed to remote");
+    } catch (error) {
+      pushSpinner.fail("Push failed");
+      throw error;
+    }
+    const prSpinner = createSpinner("Creating PR...").start();
+    const defaultBranch = await getDefaultBranch(pkg.source);
+    const manualUrl = buildNewPrUrl(repoInfo, branchName);
+    const prResult = await createPr({
+      repoDir: tempDir,
+      owner: repoInfo.owner,
+      repo: repoInfo.repo,
+      branch: branchName,
+      baseBranch: defaultBranch,
+      title: `Update ${pkg.alias} context via nocaap`,
+      body: `This PR was created automatically by nocaap.
+
+**Commit message:** ${commitMessage}`,
+      manualUrl
+    });
+    if (prResult.success) {
+      prSpinner.succeed("PR created");
+    } else {
+      prSpinner.warn("PR not created automatically");
+    }
+    await cleanup();
+    return {
+      success: true,
+      prUrl: prResult.url || manualUrl
+    };
+  } catch (error) {
+    await cleanup();
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: msg };
+  }
+}
+async function pushCommand(alias, options) {
+  const projectRoot = process.cwd();
+  log.title("nocaap Push");
+  log.newline();
+  const allPackages = await getAllPackages(projectRoot);
+  if (allPackages.length === 0) {
+    log.error("No packages configured. Run `nocaap setup` or `nocaap add` first.");
+    return;
+  }
+  let packagesToPush;
+  if (options.all) {
+    packagesToPush = allPackages;
+    log.info(`Pushing all ${packagesToPush.length} package(s)...`);
+  } else if (alias) {
+    const pkg = allPackages.find((p) => p.alias === alias);
+    if (!pkg) {
+      log.error(`Package '${alias}' not found in config.`);
+      log.dim("Available packages:");
+      for (const p of allPackages) {
+        log.dim(`  - ${p.alias}`);
+      }
+      return;
+    }
+    packagesToPush = [pkg];
+  } else {
+    log.info("Select packages to push:");
+    log.newline();
+    const selectedAliases = await selectPackagesToPush(allPackages);
+    if (selectedAliases.length === 0) {
+      log.warn("No packages selected. Push cancelled.");
+      return;
+    }
+    packagesToPush = allPackages.filter((p) => selectedAliases.includes(p.alias));
+  }
+  log.newline();
+  const defaultMessage = packagesToPush.length === 1 && packagesToPush[0] ? `Update ${packagesToPush[0].alias} context via nocaap` : "Update context via nocaap";
+  const commitMessage = options.message || defaultMessage;
+  const results = [];
+  for (const pkg of packagesToPush) {
+    log.hr();
+    log.newline();
+    log.info(`Pushing ${style.bold(pkg.alias)}...`);
+    log.dim(`  Source: ${pkg.source}`);
+    if (pkg.path) {
+      log.dim(`  Path: ${pkg.path}`);
+    }
+    log.newline();
+    const result = await pushSinglePackage(projectRoot, pkg, commitMessage);
+    results.push({ alias: pkg.alias, ...result });
+    if (result.success && result.prUrl) {
+      log.newline();
+      log.success(`PR created for ${pkg.alias}:`);
+      log.info(`  ${style.url(result.prUrl)}`);
+    } else if (result.error) {
+      log.newline();
+      log.error(`Failed: ${result.error}`);
+    }
+  }
+  log.newline();
+  log.hr();
+  log.newline();
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  if (successCount > 0) {
+    log.success(`${successCount} package(s) pushed successfully.`);
+    const withPrs = results.filter((r) => r.success && r.prUrl);
+    if (withPrs.length > 0) {
+      log.newline();
+      log.info("Pull Requests:");
+      for (const r of withPrs) {
+        log.dim(`  ${r.alias}: ${r.prUrl}`);
+      }
+    }
+  }
+  if (failCount > 0) {
+    log.newline();
+    log.warn(`${failCount} package(s) failed.`);
+    for (const r of results.filter((r2) => !r2.success)) {
+      log.dim(`  ${r.alias}: ${r.error}`);
+    }
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("nocaap").description(
+  "Normalized Organizational Context-as-a-Package\n\nStandardize your AI agent context across teams.\nRun `nocaap setup` to get started."
+).version("0.1.0");
+program.command("setup").description("Interactive setup wizard to configure context packages").option("-r, --registry <url>", "Registry URL to fetch contexts from").action(async (options) => {
+  try {
+    await setupCommand({ registry: options.registry });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process.exit(1);
+  }
+});
+program.command("add <repo>").description("Add a context package from a Git repository").option("-p, --path <path>", "Sparse checkout path within the repo").option("-a, --alias <name>", "Local alias for the package").option("-b, --branch <branch>", "Branch or tag to checkout", "main").action(async (repo, options) => {
+  try {
+    await addCommand(repo, {
+      path: options.path,
+      alias: options.alias,
+      branch: options.branch
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process.exit(1);
+  }
+});
+program.command("update [alias]").description("Update context packages and regenerate index").option("--force", "Force update even if clean").action(async (alias, options) => {
+  try {
+    await updateCommand(alias, { force: options.force });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process.exit(1);
+  }
+});
+program.command("list").alias("ls").description("List installed context packages").action(async () => {
+  try {
+    await listCommand();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process.exit(1);
+  }
+});
+program.command("remove <alias>").alias("rm").description("Remove a context package").option("--force", "Force removal even if dirty").action(async (alias, options) => {
+  try {
+    await removeCommand(alias, { force: options.force });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process.exit(1);
+  }
+});
+program.command("config [key] [value]").description("Manage global nocaap configuration").option("-l, --list", "Show all configuration").option("--clear", "Clear the specified config key").action(async (key, value, options) => {
+  try {
+    await configCommand(key, value, {
+      list: options.list,
+      clear: options.clear
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process.exit(1);
+  }
+});
+program.command("push [alias]").description("Push local changes to upstream as a PR").option("-m, --message <message>", "Commit message").option("-a, --all", "Push all packages with changes").action(async (alias, options) => {
+  try {
+    await pushCommand(alias, {
+      message: options.message,
+      all: options.all
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process.exit(1);
+  }
+});
+program.command("generate").alias("index").description("Regenerate INDEX.md without updating packages").action(async () => {
+  try {
+    const projectRoot = process.cwd();
+    await generateIndexWithProgress(projectRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(message);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map