@offworld/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3670 @@
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { ConfigSchema, GlobalMapSchema, ProjectMapSchema } from "@offworld/types";
+import { xdgConfig, xdgData, xdgState } from "xdg-basedir";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+import { GlobalMapSchema as GlobalMapSchema$1, ProjectMapSchema as ProjectMapSchema$1 } from "@offworld/types/schemas";
+import { execFileSync, execSync, spawn } from "node:child_process";
+import { z } from "zod";
+import { ConvexHttpClient } from "convex/browser";
+import { api } from "@offworld/backend-api/api";
+
+//#region src/constants.ts
+/**
+* SDK Constants
+*/
+/** SDK version - must match package.json */
+const VERSION = "0.1.0";
+/**
+* Default patterns to ignore when scanning repositories.
+* Includes directories, binary files, IDE configs, and build outputs.
+*/
+const DEFAULT_IGNORE_PATTERNS = [
+	".git",
+	".git/**",
+	".svn",
+	".hg",
+	"node_modules",
+	"node_modules/**",
+	"vendor",
+	"vendor/**",
+	".pnpm",
+	".yarn",
+	"dist",
+	"dist/**",
+	"build",
+	"build/**",
+	"out",
+	"out/**",
+	".next",
+	".nuxt",
+	".output",
+	"target",
+	"__pycache__",
+	"*.pyc",
+	".vscode",
+	".vscode/**",
+	".idea",
+	".idea/**",
+	"*.swp",
+	"*.swo",
+	".DS_Store",
+	"*.jpg",
+	"*.jpeg",
+	"*.png",
+	"*.gif",
+	"*.ico",
+	"*.webp",
+	"*.svg",
+	"*.bmp",
+	"*.tiff",
+	"*.mp4",
+	"*.webm",
+	"*.mov",
+	"*.avi",
+	"*.mkv",
+	"*.mp3",
+	"*.wav",
+	"*.flac",
+	"*.ogg",
+	"*.pdf",
+	"*.zip",
+	"*.tar",
+	"*.gz",
+	"*.rar",
+	"*.7z",
+	"*.exe",
+	"*.dll",
+	"*.so",
+	"*.dylib",
+	"*.bin",
+	"*.wasm",
+	"*.woff",
+	"*.woff2",
+	"*.ttf",
+	"*.eot",
+	"*.otf",
+	"package-lock.json",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"bun.lockb",
+	"Cargo.lock",
+	"Gemfile.lock",
+	"poetry.lock",
+	"composer.lock",
+	"go.sum",
+	"coverage",
+	"coverage/**",
+	".nyc_output",
+	".coverage",
+	"htmlcov",
+	"*.log",
+	"logs",
+	"tmp",
+	"temp",
+	".tmp",
+	".temp",
+	".cache",
+	".env",
+	".env.*",
+	"*.pem",
+	"*.key"
+];
+
+//#endregion
+//#region src/paths.ts
+/**
+* XDG-based directory paths for offworld CLI
+* Uses xdg-basedir package for cross-platform compatibility (Linux/macOS)
+*/
+const APP_NAME = "offworld";
+/**
+* Main namespace for all XDG-compliant paths
+*/
+const Paths = {
+	get config() {
+		return join(xdgConfig ?? join(homedir(), ".config"), APP_NAME);
+	},
+	get data() {
+		return join(xdgData ?? join(homedir(), ".local", "share"), APP_NAME);
+	},
+	get state() {
+		return join(xdgState ?? join(homedir(), ".local", "state"), APP_NAME);
+	},
+	get configFile() {
+		return join(this.config, "offworld.json");
+	},
+	get authFile() {
+		return join(this.data, "auth.json");
+	},
+	get metaDir() {
+		return join(this.data, "meta");
+	},
+	get defaultRepoRoot() {
+		return join(homedir(), "ow");
+	},
+	get offworldSkillDir() {
+		return join(this.data, "skill", "offworld");
+	},
+	get offworldReferencesDir() {
+		return join(this.offworldSkillDir, "references");
+	},
+	get offworldAssetsDir() {
+		return join(this.offworldSkillDir, "assets");
+	},
+	get offworldGlobalMapPath() {
+		return join(this.offworldAssetsDir, "map.json");
+	}
+};
+/**
+* Expands ~ to user's home directory (for backward compatibility)
+*/
+function expandTilde(path) {
+	if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+	return path;
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* Config utilities for path management and configuration loading
+*/
+/**
+* Returns the repository root directory.
+* Uses configured repoRoot or defaults to ~/ow
+*/
+function getMetaRoot() {
+	return Paths.data;
+}
+function getRepoRoot(config) {
+	return expandTilde(config?.repoRoot ?? Paths.defaultRepoRoot);
+}
+/**
+* Returns the path for a specific repository.
+* Format: {repoRoot}/{provider}/{owner}/{repo}
+*
+* @param fullName - The repo identifier in "owner/repo" format
+* @param provider - Git provider (defaults to "github")
+* @param config - Optional config for custom repoRoot
+*/
+function getRepoPath(fullName, provider = "github", config) {
+	const root = getRepoRoot(config);
+	const [owner, repo] = fullName.split("/");
+	if (!owner || !repo) throw new Error(`Invalid fullName format: ${fullName}. Expected "owner/repo"`);
+	return join(root, provider, owner, repo);
+}
+/**
+* Convert owner/repo format to meta directory name.
+* Collapses owner==repo (e.g., better-auth/better-auth -> better-auth)
+*/
+function toMetaDirName(repoName) {
+	if (repoName.includes("/")) {
+		const [owner, repo] = repoName.split("/");
+		if (owner === repo) return repo;
+		return `${owner}-${repo}`;
+	}
+	return repoName;
+}
+/**
+* Convert owner/repo format to reference filename.
+* Collapses redundant owner/repo pairs by checking if repo name is contained in owner:
+* - honojs/hono -> hono.md (hono is in honojs)
+* - get-convex/convex-backend -> convex-backend.md (convex is in get-convex)
+* - tanstack/query -> tanstack-query.md (query is not in tanstack)
+*/
+function toReferenceFileName(repoName) {
+	if (repoName.includes("/")) {
+		const [owner, repo] = repoName.split("/");
+		const ownerLower = owner.toLowerCase();
+		const repoLower = repo.toLowerCase();
+		if (repoLower.split("-").find((part) => part.length >= 3 && ownerLower.includes(part)) || ownerLower === repoLower) return `${repoLower}.md`;
+		return `${ownerLower}-${repoLower}.md`;
+	}
+	return `${repoName.toLowerCase()}.md`;
+}
+function toReferenceName(repoName) {
+	return toReferenceFileName(repoName).replace(/\.md$/, "");
+}
+function getReferencePath(fullName) {
+	return join(Paths.offworldReferencesDir, toReferenceFileName(fullName));
+}
+function getMetaPath(fullName) {
+	return join(Paths.data, "meta", toMetaDirName(fullName));
+}
+/**
+* Returns the path to the configuration file
+* Uses XDG Base Directory specification
+*/
+function getConfigPath() {
+	return Paths.configFile;
+}
+/**
+* Loads configuration from ~/.config/offworld/offworld.json
+* Returns defaults if file doesn't exist
+*/
+function loadConfig() {
+	const configPath = getConfigPath();
+	if (!existsSync(configPath)) return ConfigSchema.parse({});
+	try {
+		const content = readFileSync(configPath, "utf-8");
+		const data = JSON.parse(content);
+		return ConfigSchema.parse(data);
+	} catch {
+		return ConfigSchema.parse({});
+	}
+}
+/**
+* Saves configuration to ~/.config/offworld/offworld.json
+* Creates directory if it doesn't exist
+* Merges with existing config
+*/
+function saveConfig(updates) {
+	const configPath = getConfigPath();
+	const configDir = dirname(configPath);
+	if (!existsSync(configDir)) mkdirSync(configDir, { recursive: true });
+	const merged = {
+		...loadConfig(),
+		...updates
+	};
+	const validated = ConfigSchema.parse(merged);
+	writeFileSync(configPath, JSON.stringify(validated, null, 2), "utf-8");
+	return validated;
+}
+
+//#endregion
+//#region src/repo-source.ts
+/**
+* Repository source parsing utilities
+*/
+var RepoSourceError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RepoSourceError";
+	}
+};
+var PathNotFoundError = class extends RepoSourceError {
+	constructor(path) {
+		super(`Path does not exist: ${path}`);
+		this.name = "PathNotFoundError";
+	}
+};
+var NotGitRepoError = class extends RepoSourceError {
+	constructor(path) {
+		super(`Directory is not a git repository: ${path}`);
+		this.name = "NotGitRepoError";
+	}
+};
+const PROVIDER_HOSTS = {
+	"github.com": "github",
+	"gitlab.com": "gitlab",
+	"bitbucket.org": "bitbucket"
+};
+const HTTPS_URL_REGEX = /^https?:\/\/(github\.com|gitlab\.com|bitbucket\.org)\/([^/]+)\/([^/]+?)(?:\.git)?$/;
+const SSH_URL_REGEX = /^git@(github\.com|gitlab\.com|bitbucket\.org):([^/]+)\/([^/]+?)(?:\.git)?$/;
+const SHORT_FORMAT_REGEX = /^([^/:@]+)\/([^/:@]+)$/;
+/**
+* Generates a short hash of a path for local repo identification
+*/
+function hashPath(path) {
+	return createHash("sha256").update(path).digest("hex").slice(0, 12);
+}
+/**
+* Builds a clone URL for a remote repository
+*/
+function buildCloneUrl(provider, owner, repo) {
+	return `https://${{
+		github: "github.com",
+		gitlab: "gitlab.com",
+		bitbucket: "bitbucket.org"
+	}[provider]}/${owner}/${repo}.git`;
+}
+/**
+* Parses a remote repository from HTTPS URL format
+*/
+function parseHttpsUrl(input) {
+	const match = input.match(HTTPS_URL_REGEX);
+	if (!match) return null;
+	const [, host, owner, repo] = match;
+	if (!host || !owner || !repo) return null;
+	const provider = PROVIDER_HOSTS[host];
+	if (!provider) return null;
+	const ownerLower = owner.toLowerCase();
+	const repoLower = repo.toLowerCase();
+	return {
+		type: "remote",
+		provider,
+		owner: ownerLower,
+		repo: repoLower,
+		fullName: `${ownerLower}/${repoLower}`,
+		qualifiedName: `${host}:${ownerLower}/${repoLower}`,
+		cloneUrl: buildCloneUrl(provider, ownerLower, repoLower)
+	};
+}
+/**
+* Parses a remote repository from SSH URL format
+*/
+function parseSshUrl(input) {
+	const match = input.match(SSH_URL_REGEX);
+	if (!match) return null;
+	const [, host, owner, repo] = match;
+	if (!host || !owner || !repo) return null;
+	const provider = PROVIDER_HOSTS[host];
+	if (!provider) return null;
+	const ownerLower = owner.toLowerCase();
+	const repoLower = repo.toLowerCase();
+	return {
+		type: "remote",
+		provider,
+		owner: ownerLower,
+		repo: repoLower,
+		fullName: `${ownerLower}/${repoLower}`,
+		qualifiedName: `${host}:${ownerLower}/${repoLower}`,
+		cloneUrl: buildCloneUrl(provider, ownerLower, repoLower)
+	};
+}
+/**
+* Parses a remote repository from short format (owner/repo)
+* Defaults to GitHub as provider
+*/
+function parseShortFormat(input) {
+	const match = input.match(SHORT_FORMAT_REGEX);
+	if (!match) return null;
+	const [, owner, repo] = match;
+	if (!owner || !repo) return null;
+	const provider = "github";
+	const host = "github.com";
+	const ownerLower = owner.toLowerCase();
+	const repoLower = repo.toLowerCase();
+	return {
+		type: "remote",
+		provider,
+		owner: ownerLower,
+		repo: repoLower,
+		fullName: `${ownerLower}/${repoLower}`,
+		qualifiedName: `${host}:${ownerLower}/${repoLower}`,
+		cloneUrl: buildCloneUrl(provider, ownerLower, repoLower)
+	};
+}
+/**
+* Parses a local repository path
+* Validates that the path exists and contains a .git directory
+*/
+function parseLocalPath(input) {
+	const absolutePath = resolve(expandTilde(input));
+	if (!existsSync(absolutePath)) throw new PathNotFoundError(absolutePath);
+	if (!statSync(absolutePath).isDirectory()) throw new RepoSourceError(`Path is not a directory: ${absolutePath}`);
+	if (!existsSync(resolve(absolutePath, ".git"))) throw new NotGitRepoError(absolutePath);
+	return {
+		type: "local",
+		path: absolutePath,
+		name: basename(absolutePath),
+		qualifiedName: `local:${hashPath(absolutePath)}`
+	};
+}
+/**
+* Determines if input looks like a local path
+*/
+function isLocalPath(input) {
+	return input.startsWith(".") || input.startsWith("/") || input.startsWith("~");
+}
+/**
+* Parses a repository input and returns a structured RepoSource
+*
+* Supported formats:
+* - owner/repo (short format, defaults to GitHub)
+* - https://github.com/owner/repo
+* - https://gitlab.com/owner/repo
+* - https://bitbucket.org/owner/repo
+* - git@github.com:owner/repo.git (SSH format)
+* - . (current directory as local repo)
+* - /absolute/path (local repo)
+*
+* @throws PathNotFoundError if local path doesn't exist
+* @throws NotGitRepoError if local path is not a git repository
+* @throws RepoSourceError for other parsing failures
+*/
+function parseRepoInput(input) {
+	const trimmed = input.trim();
+	const httpsResult = parseHttpsUrl(trimmed);
+	if (httpsResult) return httpsResult;
+	const sshResult = parseSshUrl(trimmed);
+	if (sshResult) return sshResult;
+	if (isLocalPath(trimmed)) return parseLocalPath(trimmed);
+	const shortResult = parseShortFormat(trimmed);
+	if (shortResult) return shortResult;
+	throw new RepoSourceError(`Unable to parse repository input: ${input}. Expected formats: owner/repo, https://github.com/owner/repo, git@github.com:owner/repo.git, or a local path`);
+}
+function getReferenceFileNameForSource(source) {
+	if (source.type === "remote") return toReferenceFileName(source.fullName);
+	return toReferenceFileName(source.name);
+}
+
+//#endregion
+//#region src/index-manager.ts
+/**
+* Map manager for global and project maps
+*
+* Manages:
+* - Global map: ~/.local/share/offworld/skill/offworld/assets/map.json
+* - Project map: ./.offworld/map.json
+*/
+/**
+* Reads the global map from ~/.local/share/offworld/skill/offworld/assets/map.json
+* Returns empty map if file doesn't exist or is invalid
+*/
+function readGlobalMap() {
+	const mapPath = Paths.offworldGlobalMapPath;
+	if (!existsSync(mapPath)) return { repos: {} };
+	try {
+		const content = readFileSync(mapPath, "utf-8");
+		const data = JSON.parse(content);
+		return GlobalMapSchema.parse(data);
+	} catch {
+		return { repos: {} };
+	}
+}
+/**
+* Writes the global map to ~/.local/share/offworld/skill/offworld/assets/map.json
+* Creates directory if it doesn't exist
+*/
+function writeGlobalMap(map) {
+	const mapPath = Paths.offworldGlobalMapPath;
+	const mapDir = dirname(mapPath);
+	if (!existsSync(mapDir)) mkdirSync(mapDir, { recursive: true });
+	const validated = GlobalMapSchema.parse(map);
+	writeFileSync(mapPath, JSON.stringify(validated, null, 2), "utf-8");
+}
+/**
+* Adds or updates a repo entry in the global map
+*
+* @param qualifiedName - The qualified repo name (owner/repo)
+* @param entry - The map entry to add/update
+*/
+function upsertGlobalMapEntry(qualifiedName, entry) {
+	const map = readGlobalMap();
+	map.repos[qualifiedName] = entry;
+	writeGlobalMap(map);
+}
+/**
+* Removes a repo entry from the global map
+*
+* @param qualifiedName - The qualified repo name (owner/repo)
+* @returns true if repo was removed, false if not found
+*/
+function removeGlobalMapEntry(qualifiedName) {
+	const map = readGlobalMap();
+	if (!(qualifiedName in map.repos)) return false;
+	delete map.repos[qualifiedName];
+	writeGlobalMap(map);
+	return true;
+}
+/**
+* Writes a project map to ./.offworld/map.json
+*
+* @param projectRoot - Absolute path to project root
+* @param entries - Map of qualified repo names to project map entries
+*/
+function writeProjectMap(projectRoot, entries) {
+	const mapPath = join(projectRoot, ".offworld", "map.json");
+	const mapDir = dirname(mapPath);
+	if (!existsSync(mapDir)) mkdirSync(mapDir, { recursive: true });
+	const projectMap = {
+		version: 1,
+		scope: "project",
+		globalMapPath: Paths.offworldGlobalMapPath,
+		repos: entries
+	};
+	const validated = ProjectMapSchema.parse(projectMap);
+	writeFileSync(mapPath, JSON.stringify(validated, null, 2), "utf-8");
+}
+
+//#endregion
+//#region src/map.ts
+/**
+* Map query helpers for fast routing without reading full map.json
+*/
+function readGlobalMapSafe() {
+	const mapPath = Paths.offworldGlobalMapPath;
+	if (!existsSync(mapPath)) return null;
+	try {
+		const content = readFileSync(mapPath, "utf-8");
+		return GlobalMapSchema$1.parse(JSON.parse(content));
+	} catch {
+		return null;
+	}
+}
+function readProjectMapSafe(cwd) {
+	const mapPath = resolve(cwd, ".offworld/map.json");
+	if (!existsSync(mapPath)) return null;
+	try {
+		const content = readFileSync(mapPath, "utf-8");
+		return ProjectMapSchema$1.parse(JSON.parse(content));
+	} catch {
+		return null;
+	}
+}
+/**
+* Normalize input to match against repo keys.
+* Accepts: github.com:owner/repo, owner/repo, repo
+*/
+function normalizeInput(input) {
+	const trimmed = input.trim().toLowerCase();
+	if (trimmed.includes(":")) {
+		const parts = trimmed.split(":", 2);
+		const provider = parts[0];
+		const fullName = parts[1] ?? "";
+		return {
+			provider,
+			fullName,
+			repoName: fullName.split("/").pop() ?? fullName
+		};
+	}
+	if (trimmed.includes("/")) return {
+		fullName: trimmed,
+		repoName: trimmed.split("/").pop() ?? trimmed
+	};
+	return {
+		fullName: trimmed,
+		repoName: trimmed
+	};
+}
+/**
+* Tokenize a string for search matching.
+* Lowercase, strip @, split on /_- and whitespace.
+*/
+function tokenize(str) {
+	return str.toLowerCase().replace(/@/g, "").split(/[/_\-\s]+/).filter(Boolean);
+}
+/**
+* Resolve an input string to a qualified repo key in a map.
+*
+* @param input - Accepts github.com:owner/repo, owner/repo, or repo name
+* @param map - A global or project map
+* @returns The matching qualified name or null
+*/
+function resolveRepoKey(input, map) {
+	const { provider, fullName, repoName } = normalizeInput(input);
+	const keys = Object.keys(map.repos);
+	if (provider) {
+		const qualifiedKey = `${provider}:${fullName}`;
+		if (keys.includes(qualifiedKey)) return qualifiedKey;
+	}
+	for (const key of keys) if ((key.includes(":") ? key.split(":")[1] : key)?.toLowerCase() === fullName) return key;
+	for (const key of keys) if (key.split("/").pop()?.toLowerCase() === repoName) return key;
+	return null;
+}
+/**
+* Get a map entry for a repo, preferring project map if available.
+*
+* @param input - Repo identifier (github.com:owner/repo, owner/repo, or repo)
+* @param options - Options for lookup
+* @returns Entry with scope and qualified name, or null if not found
+*/
+function getMapEntry(input, options = {}) {
+	const { preferProject = true, cwd = process.cwd() } = options;
+	const projectMap = preferProject ? readProjectMapSafe(cwd) : null;
+	const globalMap = readGlobalMapSafe();
+	if (projectMap) {
+		const key = resolveRepoKey(input, projectMap);
+		if (key && projectMap.repos[key]) return {
+			scope: "project",
+			qualifiedName: key,
+			entry: projectMap.repos[key]
+		};
+	}
+	if (globalMap) {
+		const key = resolveRepoKey(input, globalMap);
+		if (key && globalMap.repos[key]) return {
+			scope: "global",
+			qualifiedName: key,
+			entry: globalMap.repos[key]
+		};
+	}
+	return null;
+}
+/**
+* Search the map for repos matching a term.
+*
+* Scoring:
+* - Exact fullName match: 100
+* - Keyword hit: 50 per keyword
+* - Partial contains in fullName: 25
+* - Partial contains in keywords: 10
+*
+* @param term - Search term
+* @param options - Search options
+* @returns Sorted list of matches
+*/
+function searchMap(term, options = {}) {
+	const { limit = 10 } = options;
+	const globalMap = readGlobalMapSafe();
+	if (!globalMap) return [];
+	const termTokens = tokenize(term);
+	const termLower = term.toLowerCase();
+	const results = [];
+	for (const qualifiedName of Object.keys(globalMap.repos)) {
+		const entry = globalMap.repos[qualifiedName];
+		if (!entry) continue;
+		const fullName = qualifiedName.includes(":") ? qualifiedName.split(":")[1] ?? qualifiedName : qualifiedName;
+		const fullNameLower = fullName.toLowerCase();
+		const keywords = entry.keywords ?? [];
+		const keywordsLower = keywords.map((k) => k.toLowerCase());
+		let score = 0;
+		if (fullNameLower === termLower) score += 100;
+		for (const token of termTokens) if (keywordsLower.includes(token)) score += 50;
+		if (fullNameLower.includes(termLower) && score < 100) score += 25;
+		for (const kw of keywordsLower) if (kw.includes(termLower)) score += 10;
+		const fullNameTokens = tokenize(fullName);
+		for (const token of termTokens) if (fullNameTokens.includes(token)) score += 30;
+		if (score > 0) results.push({
+			qualifiedName,
+			fullName,
+			localPath: entry.localPath,
+			primary: entry.primary,
+			keywords,
+			score
+		});
+	}
+	results.sort((a, b) => {
+		if (b.score !== a.score) return b.score - a.score;
+		return a.fullName.localeCompare(b.fullName);
+	});
+	return results.slice(0, limit);
+}
+/**
+* Get the project map path if it exists in cwd.
+*/
+function getProjectMapPath(cwd = process.cwd()) {
+	const mapPath = resolve(cwd, ".offworld/map.json");
+	return existsSync(mapPath) ? mapPath : null;
+}
+
+//#endregion
+//#region src/clone.ts
+/**
+* Git clone and repository management utilities
+*/
+var CloneError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CloneError";
+	}
+};
+var RepoExistsError = class extends CloneError {
+	constructor(path) {
+		super(`Repository already exists at: ${path}`);
+		this.name = "RepoExistsError";
+	}
+};
+var RepoNotFoundError = class extends CloneError {
+	constructor(qualifiedName) {
+		super(`Repository not found in index: ${qualifiedName}`);
+		this.name = "RepoNotFoundError";
+	}
+};
+var GitError = class extends CloneError {
+	constructor(message, command, exitCode) {
+		super(`Git command failed: ${message}`);
+		this.command = command;
+		this.exitCode = exitCode;
+		this.name = "GitError";
+	}
+};
+function execGit(args, cwd) {
+	try {
+		return execFileSync("git", args, {
+			cwd,
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch (error) {
+		const err = error;
+		throw new GitError((err.stderr ? typeof err.stderr === "string" ? err.stderr : err.stderr.toString() : err.message || "Unknown error").trim(), `git ${args.join(" ")}`, err.status ?? null);
+	}
+}
+function execGitAsync(args, cwd) {
+	return new Promise((resolve, reject) => {
+		const proc = spawn("git", args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0"
+			}
+		});
+		let stdout = "";
+		let stderr = "";
+		proc.stdout.on("data", (data) => {
+			stdout += data.toString();
+		});
+		proc.stderr.on("data", (data) => {
+			stderr += data.toString();
+		});
+		proc.on("close", (code) => {
+			if (code === 0) resolve(stdout.trim());
+			else reject(new GitError(stderr.trim() || "Unknown error", `git ${args.join(" ")}`, code));
+		});
+		proc.on("error", (err) => {
+			reject(new GitError(err.message, `git ${args.join(" ")}`, null));
+		});
+	});
+}
+/**
+* Get the current commit SHA for a repository
+*/
+function getCommitSha(repoPath) {
+	return execGit(["rev-parse", "HEAD"], repoPath);
+}
+/**
+* Get the number of commits between two SHAs.
+* Returns the number of commits from `olderSha` to `newerSha`.
+* Returns null if the distance cannot be determined (e.g., shallow clone without the commit).
+*
+* @param repoPath - Path to the git repository
+* @param olderSha - The older commit SHA (e.g., remote skill's commit)
+* @param newerSha - The newer commit SHA (e.g., current HEAD), defaults to HEAD
+*/
+function getCommitDistance(repoPath, olderSha, newerSha = "HEAD") {
+	try {
+		try {
+			execGit([
+				"cat-file",
+				"-e",
+				olderSha
+			], repoPath);
+		} catch {
+			return null;
+		}
+		const count = execGit([
+			"rev-list",
+			"--count",
+			`${olderSha}..${newerSha}`
+		], repoPath);
+		return Number.parseInt(count, 10);
+	} catch {
+		return null;
+	}
+}
+const SPARSE_CHECKOUT_DIRS = [
+	"src",
+	"lib",
+	"packages",
+	"docs",
+	"README.md",
+	"package.json"
+];
+/**
+* Clone a remote repository to the local repo root.
+*
+* @param source - Remote repo source from parseRepoInput()
+* @param options - Clone options (shallow, branch, config)
+* @returns The local path where the repo was cloned
+* @throws RepoExistsError if repo already exists (unless force is true)
+* @throws GitError if clone fails
+*/
+async function cloneRepo(source, options = {}) {
+	const config = options.config ?? loadConfig();
+	const repoPath = getRepoPath(source.fullName, source.provider, config);
+	if (existsSync(repoPath)) if (options.force) rmSync(repoPath, {
+		recursive: true,
+		force: true
+	});
+	else throw new RepoExistsError(repoPath);
+	try {
+		if (options.sparse) await cloneSparse(source.cloneUrl, repoPath, options);
+		else await cloneStandard(source.cloneUrl, repoPath, options);
+	} catch (err) {
+		cleanupEmptyParentDirs(repoPath);
+		throw err;
+	}
+	const referenceFileName = toReferenceFileName(source.fullName);
+	const hasReference = existsSync(join(Paths.offworldReferencesDir, referenceFileName));
+	upsertGlobalMapEntry(source.qualifiedName, {
+		localPath: repoPath,
+		references: hasReference ? [referenceFileName] : [],
+		primary: hasReference ? referenceFileName : "",
+		keywords: [],
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return repoPath;
+}
+function cleanupEmptyParentDirs(repoPath) {
+	const ownerDir = dirname(repoPath);
+	if (existsSync(ownerDir) && readdirSync(ownerDir).length === 0) rmSync(ownerDir, {
+		recursive: true,
+		force: true
+	});
+}
+async function cloneStandard(cloneUrl, repoPath, options) {
+	const args = ["clone"];
+	if (options.shallow) args.push("--depth", "1");
+	if (options.branch) args.push("--branch", options.branch);
+	args.push(cloneUrl, repoPath);
+	await execGitAsync(args);
+}
+async function cloneSparse(cloneUrl, repoPath, options) {
+	const args = [
+		"clone",
+		"--filter=blob:none",
+		"--no-checkout",
+		"--sparse"
+	];
+	if (options.shallow) args.push("--depth", "1");
+	if (options.branch) args.push("--branch", options.branch);
+	args.push(cloneUrl, repoPath);
+	await execGitAsync(args);
+	await execGitAsync([
+		"sparse-checkout",
+		"set",
+		...SPARSE_CHECKOUT_DIRS
+	], repoPath);
+	await execGitAsync(["checkout"], repoPath);
+}
+/**
+* Check if a repository is a shallow clone.
+*/
+function isShallowClone(repoPath) {
+	try {
+		return execGit(["rev-parse", "--is-shallow-repository"], repoPath) === "true";
+	} catch {
+		return false;
+	}
+}
+/**
+* Convert a shallow clone to a full clone by fetching all history.
+* Returns true if the repo was shallow and is now unshallowed.
+* Returns false if the repo was already a full clone.
+*/
+async function unshallowRepo(repoPath) {
+	if (!isShallowClone(repoPath)) return false;
+	await execGitAsync(["fetch", "--unshallow"], repoPath);
+	return true;
+}
+/**
+* Update a cloned repository by running git fetch and pull.
+*
+* @param qualifiedName - The qualified name of the repo (e.g., "github.com:owner/repo")
+* @param options - Update options
+* @returns Update result with commit SHAs
+* @throws RepoNotFoundError if repo not in index
+* @throws GitError if fetch/pull fails
+*/
+async function updateRepo(qualifiedName, options = {}) {
+	const entry = readGlobalMap().repos[qualifiedName];
+	if (!entry) throw new RepoNotFoundError(qualifiedName);
+	const repoPath = entry.localPath;
+	if (!existsSync(repoPath)) throw new RepoNotFoundError(qualifiedName);
+	const previousSha = getCommitSha(repoPath);
+	let unshallowed = false;
+	if (options.unshallow) unshallowed = await unshallowRepo(repoPath);
+	await execGitAsync(["fetch"], repoPath);
+	await execGitAsync(["pull", "--ff-only"], repoPath);
+	const currentSha = getCommitSha(repoPath);
+	upsertGlobalMapEntry(qualifiedName, {
+		...entry,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return {
+		updated: previousSha !== currentSha,
+		previousSha,
+		currentSha,
+		unshallowed
+	};
+}
+/**
+* Remove a cloned repository and its reference data.
+*
+* @param qualifiedName - The qualified name of the repo
+* @param options - Remove options
+* @returns true if removed, false if not found
+*/
+async function removeRepo(qualifiedName, options = {}) {
+	const entry = readGlobalMap().repos[qualifiedName];
+	if (!entry) return false;
+	const { referenceOnly = false, repoOnly = false } = options;
+	const removeRepoFiles = !referenceOnly;
+	const removeReferenceFiles = !repoOnly;
+	if (removeRepoFiles && existsSync(entry.localPath)) {
+		rmSync(entry.localPath, {
+			recursive: true,
+			force: true
+		});
+		cleanupEmptyParentDirs(entry.localPath);
+	}
+	if (removeReferenceFiles) {
+		for (const referenceFileName of entry.references) {
+			const referencePath = join(Paths.offworldReferencesDir, referenceFileName);
+			if (existsSync(referencePath)) rmSync(referencePath, { force: true });
+		}
+		if (entry.primary) {
+			const metaDirName = entry.primary.replace(/\.md$/, "");
+			const metaPath = join(Paths.metaDir, metaDirName);
+			if (existsSync(metaPath)) rmSync(metaPath, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	if (removeRepoFiles) removeGlobalMapEntry(qualifiedName);
+	else if (removeReferenceFiles) upsertGlobalMapEntry(qualifiedName, {
+		...entry,
+		references: [],
+		primary: ""
+	});
+	return true;
+}
+/**
+* List all cloned repositories from the global map.
+*
+* @returns Array of qualified names
+*/
+function listRepos() {
+	const map = readGlobalMap();
+	return Object.keys(map.repos);
+}
+/**
+* Check if a repository is cloned and in the map.
+*
+* @param qualifiedName - The qualified name of the repo
+* @returns true if repo exists in map and on disk
+*/
+function isRepoCloned(qualifiedName) {
+	const entry = readGlobalMap().repos[qualifiedName];
+	if (!entry) return false;
+	return existsSync(entry.localPath);
+}
+/**
+* Get the local path for a cloned repository.
+*
+* @param qualifiedName - The qualified name of the repo
+* @returns The local path or undefined if not cloned
+*/
+function getClonedRepoPath(qualifiedName) {
+	const entry = readGlobalMap().repos[qualifiedName];
+	if (!entry) return void 0;
+	if (!existsSync(entry.localPath)) return void 0;
+	return entry.localPath;
+}
+
+//#endregion
+//#region src/ai/errors.ts
+/**
+* Base class for OpenCode reference errors
+*/
+var OpenCodeReferenceError = class extends Error {
+	_tag = "OpenCodeReferenceError";
+	constructor(message, details) {
+		super(message);
+		this.details = details;
+		this.name = "OpenCodeReferenceError";
+	}
+};
+/**
+* Error when the @opencode-ai/sdk package is not installed
+*/
+var OpenCodeSDKError = class extends OpenCodeReferenceError {
+	_tag = "OpenCodeSDKError";
+	constructor() {
+		super("Failed to import @opencode-ai/sdk. Install it with: bun add @opencode-ai/sdk");
+		this.name = "OpenCodeSDKError";
+	}
+};
+/**
+* Error when the requested provider is not found
+*/
+var InvalidProviderError = class extends OpenCodeReferenceError {
+	_tag = "InvalidProviderError";
+	hint;
+	constructor(providerID, availableProviders) {
+		const hint = availableProviders.length > 0 ? `Available providers: ${availableProviders.join(", ")}` : "No providers available. Check your OpenCode configuration.";
+		super(`Provider "${providerID}" not found. ${hint}`);
+		this.providerID = providerID;
+		this.availableProviders = availableProviders;
+		this.name = "InvalidProviderError";
+		this.hint = hint;
+	}
+};
+/**
+* Error when the provider exists but is not connected/authenticated
+*/
+var ProviderNotConnectedError = class extends OpenCodeReferenceError {
+	_tag = "ProviderNotConnectedError";
+	hint;
+	constructor(providerID, connectedProviders) {
+		const hint = connectedProviders.length > 0 ? `Connected providers: ${connectedProviders.join(", ")}. Run 'opencode auth ${providerID}' to connect.` : `No providers connected. Run 'opencode auth ${providerID}' to authenticate.`;
+		super(`Provider "${providerID}" is not connected. ${hint}`);
+		this.providerID = providerID;
+		this.connectedProviders = connectedProviders;
+		this.name = "ProviderNotConnectedError";
+		this.hint = hint;
+	}
+};
+/**
+* Error when the requested model is not found for a provider
+*/
+var InvalidModelError = class extends OpenCodeReferenceError {
+	_tag = "InvalidModelError";
+	hint;
+	constructor(modelID, providerID, availableModels) {
+		const hint = availableModels.length > 0 ? `Available models for ${providerID}: ${availableModels.slice(0, 10).join(", ")}${availableModels.length > 10 ? ` (and ${availableModels.length - 10} more)` : ""}` : `No models available for provider "${providerID}".`;
+		super(`Model "${modelID}" not found for provider "${providerID}". ${hint}`);
+		this.modelID = modelID;
+		this.providerID = providerID;
+		this.availableModels = availableModels;
+		this.name = "InvalidModelError";
+		this.hint = hint;
+	}
+};
+/**
+* Error when the OpenCode server fails to start
+*/
+var ServerStartError = class extends OpenCodeReferenceError {
+	_tag = "ServerStartError";
+	hint;
+	constructor(message, port, details) {
+		const hint = port ? `Failed to start server on port ${port}. Ensure no other process is using this port.` : "Failed to start OpenCode server. Check your OpenCode installation and configuration.";
+		super(`${message}. ${hint}`, details);
+		this.port = port;
+		this.name = "ServerStartError";
+		this.hint = hint;
+	}
+};
+/**
+* Error when a session operation fails
+*/
+var SessionError = class extends OpenCodeReferenceError {
+	_tag = "SessionError";
+	hint;
+	constructor(message, sessionId, sessionState, details) {
+		const hint = `Session operation failed${sessionId ? ` (session: ${sessionId})` : ""}.${sessionState ? ` State: ${sessionState}.` : ""} Try creating a new session.`;
+		super(`${message}. ${hint}`, details);
+		this.sessionId = sessionId;
+		this.sessionState = sessionState;
+		this.name = "SessionError";
+		this.hint = hint;
+	}
+};
+/**
+* Error when a request times out
+*/
+var TimeoutError = class extends OpenCodeReferenceError {
+	_tag = "TimeoutError";
+	hint;
+	constructor(timeoutMs, operation = "operation") {
+		const hint = `The ${operation} did not complete within ${timeoutMs}ms. Consider increasing the timeout or checking if the model is responding.`;
+		super(`Timeout: ${operation} did not complete within ${timeoutMs}ms. ${hint}`);
+		this.timeoutMs = timeoutMs;
+		this.operation = operation;
+		this.name = "TimeoutError";
+		this.hint = hint;
+	}
+};
+
+//#endregion
+//#region src/ai/stream/types.ts
+/**
+* Zod schemas for OpenCode stream events
+* Replaces inline `as` casts with runtime-validated types
+*/
+const PartBaseSchema = z.object({
+	id: z.string().optional(),
+	sessionID: z.string().optional(),
+	messageID: z.string().optional()
+});
+const TextPartSchema = PartBaseSchema.extend({
+	type: z.literal("text"),
+	text: z.string().optional()
+});
+const ToolStatePendingSchema = z.object({ status: z.literal("pending") });
+const ToolStateRunningSchema = z.object({
+	status: z.literal("running"),
+	title: z.string().optional(),
+	input: z.unknown().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	time: z.object({ start: z.number() }).optional()
+});
+const ToolStateCompletedSchema = z.object({
+	status: z.literal("completed"),
+	title: z.string().optional(),
+	input: z.record(z.string(), z.unknown()).optional(),
+	output: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	time: z.object({
+		start: z.number(),
+		end: z.number()
+	}).optional()
+});
+const ToolStateErrorSchema = z.object({
+	status: z.literal("error"),
+	error: z.string().optional(),
+	input: z.record(z.string(), z.unknown()).optional(),
+	time: z.object({
+		start: z.number(),
+		end: z.number()
+	}).optional()
+});
+const ToolStateSchema = z.discriminatedUnion("status", [
+	ToolStatePendingSchema,
+	ToolStateRunningSchema,
+	ToolStateCompletedSchema,
+	ToolStateErrorSchema
+]);
+const ToolPartSchema = PartBaseSchema.extend({
+	type: z.literal("tool"),
+	callID: z.string().optional(),
+	tool: z.string().optional(),
+	state: ToolStateSchema.optional()
+});
+const StepStartPartSchema = PartBaseSchema.extend({ type: z.literal("step-start") });
+const StepFinishPartSchema = PartBaseSchema.extend({
+	type: z.literal("step-finish"),
+	reason: z.string().optional()
+});
+const ToolUsePartSchema = PartBaseSchema.extend({
+	type: z.literal("tool-use"),
+	toolUseId: z.string().optional(),
+	name: z.string().optional()
+});
+const ToolResultPartSchema = PartBaseSchema.extend({
+	type: z.literal("tool-result"),
+	toolUseId: z.string().optional()
+});
+const MessagePartSchema = z.discriminatedUnion("type", [
+	TextPartSchema,
+	ToolPartSchema,
+	StepStartPartSchema,
+	StepFinishPartSchema,
+	ToolUsePartSchema,
+	ToolResultPartSchema
+]);
+/**
+* Session error payload
+*/
+const SessionErrorSchema = z.object({
+	name: z.string().optional(),
+	message: z.string().optional(),
+	code: z.string().optional()
+});
+const MessagePartUpdatedPropsSchema = z.object({ part: MessagePartSchema });
+/**
+* Properties for session.idle event
+*/
+const SessionIdlePropsSchema = z.object({ sessionID: z.string() });
+/**
+* Properties for session.error event
+*/
+const SessionErrorPropsSchema = z.object({
+	sessionID: z.string(),
+	error: SessionErrorSchema.optional()
+});
+/**
+* Properties for session.updated event
+*/
+const SessionUpdatedPropsSchema = z.object({
+	sessionID: z.string(),
+	status: z.string().optional()
+});
+/**
+* message.part.updated event
+*/
+const MessagePartUpdatedEventSchema = z.object({
+	type: z.literal("message.part.updated"),
+	properties: MessagePartUpdatedPropsSchema
+});
+/**
+* session.idle event
+*/
+const SessionIdleEventSchema = z.object({
+	type: z.literal("session.idle"),
+	properties: SessionIdlePropsSchema
+});
+/**
+* session.error event
+*/
+const SessionErrorEventSchema = z.object({
+	type: z.literal("session.error"),
+	properties: SessionErrorPropsSchema
+});
+/**
+* session.updated event
+*/
+const SessionUpdatedEventSchema = z.object({
+	type: z.literal("session.updated"),
+	properties: SessionUpdatedPropsSchema
+});
+/**
+* Generic event for unknown types (passthrough)
+*/
+const GenericEventSchema = z.object({
+	type: z.string(),
+	properties: z.record(z.string(), z.unknown())
+});
+
+//#endregion
+//#region src/ai/stream/accumulator.ts
+/**
+* Accumulates text from streaming message parts.
+* Tracks multiple parts by ID and provides delta text between updates.
+*/
+var TextAccumulator = class {
+	parts = /* @__PURE__ */ new Map();
+	_firstTextReceived = false;
+	/**
+	* Whether any text has been received
+	*/
+	get hasReceivedText() {
+		return this._firstTextReceived;
+	}
+	/**
+	* Accumulate text from a message part and return the delta (new text only).
+	* Returns null if the part should be skipped (non-text, no ID, no text).
+	*/
+	accumulatePart(part) {
+		if (part.type !== "text" || !part.text || !part.id) return null;
+		const partId = part.id;
+		const prevText = this.parts.get(partId) ?? "";
+		this.parts.set(partId, part.text);
+		if (!this._firstTextReceived) this._firstTextReceived = true;
+		if (part.text.length > prevText.length) return part.text.slice(prevText.length);
+		return null;
+	}
+	/**
+	* Get the full accumulated text from all parts
+	*/
+	getFullText() {
+		return Array.from(this.parts.values()).join("");
+	}
+	/**
+	* Clear accumulated text
+	*/
+	clear() {
+		this.parts.clear();
+		this._firstTextReceived = false;
+	}
+};
+
+//#endregion
+//#region src/ai/stream/transformer.ts
+/**
+* Stream event transformer and parser
+* Safely parses and validates stream events using Zod schemas
+*/
+/**
+* Parse a raw stream event into a typed result.
+* Uses safe parsing - returns type: "unknown" for unrecognized or invalid events.
+*/
+function parseStreamEvent(event) {
+	switch (event.type) {
+		case "message.part.updated": {
+			const propsResult = MessagePartUpdatedPropsSchema.safeParse(event.properties);
+			if (!propsResult.success) return {
+				type: "unknown",
+				rawType: event.type
+			};
+			const props = propsResult.data;
+			return {
+				type: "message.part.updated",
+				props,
+				textPart: props.part.type === "text" ? props.part : null,
+				toolPart: props.part.type === "tool" ? props.part : null
+			};
+		}
+		case "session.idle": {
+			const propsResult = SessionIdlePropsSchema.safeParse(event.properties);
+			if (!propsResult.success) return {
+				type: "unknown",
+				rawType: event.type
+			};
+			return {
+				type: "session.idle",
+				props: propsResult.data
+			};
+		}
+		case "session.error": {
+			const propsResult = SessionErrorPropsSchema.safeParse(event.properties);
+			if (!propsResult.success) return {
+				type: "unknown",
+				rawType: event.type
+			};
+			const props = propsResult.data;
+			let error = null;
+			if (props.error) {
+				const errorResult = SessionErrorSchema.safeParse(props.error);
+				if (errorResult.success) error = errorResult.data;
+			}
+			return {
+				type: "session.error",
+				props,
+				error
+			};
+		}
+		default: return {
+			type: "unknown",
+			rawType: event.type
+		};
+	}
+}
+function isEventForSession(event, sessionId) {
+	const props = event.properties;
+	if ("sessionID" in props && typeof props.sessionID === "string") return props.sessionID === sessionId;
+	if ("part" in props && typeof props.part === "object" && props.part !== null && "sessionID" in props.part && typeof props.part.sessionID === "string") return props.part.sessionID === sessionId;
+	return true;
+}
+
+//#endregion
+//#region src/ai/opencode.ts
+const DEFAULT_AI_PROVIDER = "opencode";
+const DEFAULT_AI_MODEL = "claude-opus-4-5";
+let cachedCreateOpencode = null;
+let cachedCreateOpencodeClient = null;
+async function getOpenCodeSDK() {
+	if (cachedCreateOpencode && cachedCreateOpencodeClient) return {
+		createOpencode: cachedCreateOpencode,
+		createOpencodeClient: cachedCreateOpencodeClient
+	};
+	try {
+		const sdk = await import("@opencode-ai/sdk");
+		cachedCreateOpencode = sdk.createOpencode;
+		cachedCreateOpencodeClient = sdk.createOpencodeClient;
+		return {
+			createOpencode: cachedCreateOpencode,
+			createOpencodeClient: cachedCreateOpencodeClient
+		};
+	} catch {
+		throw new OpenCodeSDKError();
+	}
+}
+function formatToolMessage(tool, state) {
+	if (state.title) return state.title;
+	if (!tool) return null;
+	const input = state.input;
+	if (!input) return `Running ${tool}...`;
+	switch (tool) {
+		case "read": {
+			const path = input.filePath ?? input.path;
+			if (typeof path === "string") return `Reading ${path.split("/").pop()}...`;
+			return "Reading file...";
+		}
+		case "glob": {
+			const pattern = input.pattern;
+			if (typeof pattern === "string") return `Globbing ${pattern}...`;
+			return "Searching files...";
+		}
+		case "grep": {
+			const pattern = input.pattern;
+			if (typeof pattern === "string") return `Searching for "${pattern.length > 30 ? `${pattern.slice(0, 30)}...` : pattern}"...`;
+			return "Searching content...";
+		}
+		case "list": {
+			const path = input.path;
+			if (typeof path === "string") return `Listing ${path}...`;
+			return "Listing directory...";
+		}
+		default: return `Running ${tool}...`;
+	}
+}
+async function streamPrompt(options) {
+	const { prompt, cwd, systemPrompt, provider: optProvider, model: optModel, timeoutMs, onDebug, onStream } = options;
+	const debug = onDebug ?? (() => {});
+	const stream = onStream ?? (() => {});
+	const startTime = Date.now();
+	debug("Loading OpenCode SDK...");
+	const { createOpencode, createOpencodeClient } = await getOpenCodeSDK();
+	const maxAttempts = 10;
+	let server = null;
+	let client = null;
+	let port = 0;
+	const config = {
+		plugin: [],
+		mcp: {},
+		instructions: [],
+		agent: {
+			build: { disable: true },
+			general: { disable: true },
+			plan: { disable: true },
+			explore: { disable: true },
+			analyze: {
+				prompt: [
+					"You are an expert at analyzing open source codebases and producing documentation.",
+					"",
+					"Your job is to read the codebase and produce structured output based on the user's request.",
+					"Use glob to discover files, grep to search for patterns, and read to examine file contents.",
+					"",
+					"Guidelines:",
+					"- Explore the codebase thoroughly before producing output",
+					"- Focus on understanding architecture, key abstractions, and usage patterns",
+					"- When asked for JSON output, respond with ONLY valid JSON - no markdown, no code blocks",
+					"- When asked for prose, write clear and concise documentation",
+					"- Always base your analysis on actual code you've read, never speculate"
+				].join("\n"),
+				mode: "primary",
+				description: "Analyze open source codebases and produce summaries and reference files",
+				tools: {
+					read: true,
+					grep: true,
+					glob: true,
+					list: true,
+					write: false,
+					bash: false,
+					delete: false,
+					edit: false,
+					patch: false,
+					path: false,
+					todowrite: false,
+					todoread: false,
+					websearch: false,
+					webfetch: false,
+					codesearch: false,
+					skill: false,
+					task: false,
+					mcp: false,
+					question: false,
+					plan_enter: false,
+					plan_exit: false
+				},
+				permission: {
+					edit: "deny",
+					bash: "deny",
+					webfetch: "deny",
+					external_directory: "deny"
+				}
+			}
+		}
+	};
+	debug("Starting embedded OpenCode server...");
+	for (let attempt = 0; attempt < maxAttempts; attempt++) {
+		port = Math.floor(Math.random() * 3e3) + 3e3;
+		try {
+			server = (await createOpencode({
+				port,
+				cwd,
+				config
+			})).server;
+			client = createOpencodeClient({
+				baseUrl: `http://localhost:${port}`,
+				directory: cwd
+			});
+			debug(`Server started on port ${port}`);
+			break;
+		} catch (err) {
+			if (err instanceof Error && err.message?.includes("port")) continue;
+			throw new ServerStartError("Failed to start OpenCode server", port, err);
+		}
+	}
+	if (!server || !client) throw new ServerStartError("Failed to start OpenCode server after all attempts");
+	const providerID = optProvider ?? DEFAULT_AI_PROVIDER;
+	const modelID = optModel ?? DEFAULT_AI_MODEL;
+	try {
+		debug("Creating session...");
+		const sessionResult = await client.session.create();
+		if (sessionResult.error) throw new SessionError("Failed to create session", void 0, void 0, sessionResult.error);
+		const sessionId = sessionResult.data.id;
+		debug(`Session created: ${sessionId}`);
+		debug("Validating provider and model...");
+		const providerResult = await client.provider.list();
+		if (providerResult.error) throw new OpenCodeReferenceError("Failed to fetch provider list", providerResult.error);
+		const { all: allProviders, connected: connectedProviders } = providerResult.data;
+		const allProviderIds = allProviders.map((p) => p.id);
+		const provider = allProviders.find((p) => p.id === providerID);
+		if (!provider) throw new InvalidProviderError(providerID, allProviderIds);
+		if (!connectedProviders.includes(providerID)) throw new ProviderNotConnectedError(providerID, connectedProviders);
+		const availableModelIds = Object.keys(provider.models);
+		if (!provider.models[modelID]) throw new InvalidModelError(modelID, providerID, availableModelIds);
+		debug(`Provider "${providerID}" and model "${modelID}" validated`);
+		debug("Subscribing to events...");
+		const { stream: eventStream } = await client.event.subscribe();
+		const fullPrompt = systemPrompt ? `${systemPrompt}\n\nAnalyzing codebase at: ${cwd}\n\n${prompt}` : `Analyzing codebase at: ${cwd}\n\n${prompt}`;
+		debug("Sending prompt...");
+		const promptPromise = client.session.prompt({
+			path: { id: sessionId },
+			body: {
+				agent: "analyze",
+				parts: [{
+					type: "text",
+					text: fullPrompt
+				}],
+				model: {
+					providerID,
+					modelID
+				}
+			}
+		});
+		const textAccumulator = new TextAccumulator();
+		debug("Waiting for response...");
+		let timeoutId = null;
+		const processEvents = async () => {
+			for await (const event of eventStream) {
+				if (!isEventForSession(event, sessionId)) continue;
+				const parsed = parseStreamEvent(event);
+				switch (parsed.type) {
+					case "message.part.updated":
+						if (parsed.toolPart?.state) {
+							const { state, tool } = parsed.toolPart;
+							if (state.status === "running") {
+								const message = formatToolMessage(tool, state);
+								if (message) debug(message);
+							}
+						}
+						if (parsed.textPart) {
+							const delta = textAccumulator.accumulatePart(parsed.textPart);
+							if (!textAccumulator.hasReceivedText) debug("Writing reference...");
+							if (delta) stream(delta);
+						}
+						break;
+					case "session.idle":
+						if (parsed.props.sessionID === sessionId) {
+							debug("Response complete");
+							return textAccumulator.getFullText();
+						}
+						break;
+					case "session.error":
+						if (parsed.props.sessionID === sessionId) {
+							const errorName = parsed.error?.name ?? "Unknown session error";
+							debug(`Session error: ${JSON.stringify(parsed.props.error)}`);
+							throw new SessionError(errorName, sessionId, "error", parsed.props.error);
+						}
+						break;
+					case "unknown": break;
+				}
+			}
+			return textAccumulator.getFullText();
+		};
+		let responseText;
+		if (timeoutMs && timeoutMs > 0) {
+			const timeoutPromise = new Promise((_, reject) => {
+				timeoutId = setTimeout(() => {
+					reject(new TimeoutError(timeoutMs, "session response"));
+				}, timeoutMs);
+			});
+			responseText = await Promise.race([processEvents(), timeoutPromise]);
+			if (timeoutId) clearTimeout(timeoutId);
+		} else responseText = await processEvents();
+		await promptPromise;
+		if (!responseText) throw new OpenCodeReferenceError("No response received from OpenCode");
+		debug(`Response received (${responseText.length} chars)`);
+		const durationMs = Date.now() - startTime;
+		debug(`Complete in ${durationMs}ms`);
+		return {
+			text: responseText,
+			sessionId,
+			durationMs
+		};
+	} finally {
+		debug("Closing server...");
+		server.close();
+	}
+}
+
+//#endregion
+//#region src/sync.ts
+/**
+* Sync utilities for CLI-Convex communication
+* Uses ConvexHttpClient for direct type-safe API calls
+*/
+function getConvexUrl() {
+	return process.env.CONVEX_URL || "";
+}
+const GITHUB_API_BASE = "https://api.github.com";
+var SyncError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SyncError";
+	}
+};
+var NetworkError = class extends SyncError {
+	constructor(message, statusCode) {
+		super(message);
+		this.statusCode = statusCode;
+		this.name = "NetworkError";
+	}
+};
+var AuthenticationError = class extends SyncError {
+	constructor(message = "Authentication required. Please run 'ow auth login' first.") {
+		super(message);
+		this.name = "AuthenticationError";
+	}
+};
+var RateLimitError = class extends SyncError {
+	constructor(message = "Rate limit exceeded. You can push up to 3 times per repo per day.") {
+		super(message);
+		this.name = "RateLimitError";
+	}
+};
+var ConflictError = class extends SyncError {
+	constructor(message = "A newer reference already exists on the server.", remoteCommitSha) {
+		super(message);
+		this.remoteCommitSha = remoteCommitSha;
+		this.name = "ConflictError";
+	}
+};
+var CommitExistsError = class extends SyncError {
+	constructor(message = "A reference already exists for this commit SHA.") {
+		super(message);
+		this.name = "CommitExistsError";
+	}
+};
+var InvalidInputError = class extends SyncError {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidInputError";
+	}
+};
+var InvalidReferenceError = class extends SyncError {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidReferenceError";
+	}
+};
+var RepoNotFoundError$1 = class extends SyncError {
+	constructor(message = "Repository not found on GitHub.") {
+		super(message);
+		this.name = "RepoNotFoundError";
+	}
+};
+var LowStarsError = class extends SyncError {
+	constructor(message = "Repository has less than 5 stars.") {
+		super(message);
+		this.name = "LowStarsError";
+	}
+};
+var PrivateRepoError = class extends SyncError {
+	constructor(message = "Private repositories are not supported.") {
+		super(message);
+		this.name = "PrivateRepoError";
+	}
+};
+var CommitNotFoundError = class extends SyncError {
+	constructor(message = "Commit not found in repository.") {
+		super(message);
+		this.name = "CommitNotFoundError";
+	}
+};
+var GitHubError = class extends SyncError {
+	constructor(message = "GitHub API error.") {
+		super(message);
+		this.name = "GitHubError";
+	}
+};
+var PushNotAllowedError = class extends SyncError {
+	constructor(message, reason) {
+		super(message);
+		this.reason = reason;
+		this.name = "PushNotAllowedError";
+	}
+};
+function createClient(token) {
+	const convexUrl = getConvexUrl();
+	if (!convexUrl) throw new SyncError("CONVEX_URL not configured. For local development, ensure apps/cli/.env contains CONVEX_URL=your_convex_url");
+	const client = new ConvexHttpClient(convexUrl);
+	if (token) client.setAuth(token);
+	return client;
+}
+/**
+* Fetches reference from the remote server
+* @param fullName - Repository full name (owner/repo)
+* @returns Reference data or null if not found
+*/
+async function pullReference(fullName) {
+	const client = createClient();
+	try {
+		let result = await client.query(api.references.pull, {
+			fullName,
+			referenceName: toReferenceName(fullName)
+		});
+		if (!result) result = await client.query(api.references.pull, { fullName });
+		if (!result) return null;
+		client.mutation(api.references.recordPull, {
+			fullName,
+			referenceName: result.referenceName
+		}).catch(() => {});
+		return {
+			fullName: result.fullName,
+			referenceName: result.referenceName,
+			referenceDescription: result.referenceDescription,
+			referenceContent: result.referenceContent,
+			commitSha: result.commitSha,
+			generatedAt: result.generatedAt
+		};
+	} catch (error) {
+		throw new NetworkError(`Failed to pull reference: ${error instanceof Error ? error.message : error}`);
+	}
+}
+/**
+* Fetches a specific reference by name from the remote server
+* @param fullName - Repository full name (owner/repo)
+* @param referenceName - Specific reference name to pull
+* @returns Reference data or null if not found
+*/
+async function pullReferenceByName(fullName, referenceName) {
+	const client = createClient();
+	try {
+		const result = await client.query(api.references.pull, {
+			fullName,
+			referenceName
+		});
+		if (!result) return null;
+		client.mutation(api.references.recordPull, {
+			fullName,
+			referenceName
+		}).catch(() => {});
+		return {
+			fullName: result.fullName,
+			referenceName: result.referenceName,
+			referenceDescription: result.referenceDescription,
+			referenceContent: result.referenceContent,
+			commitSha: result.commitSha,
+			generatedAt: result.generatedAt
+		};
+	} catch (error) {
+		throw new NetworkError(`Failed to pull reference: ${error instanceof Error ? error.message : error}`);
+	}
+}
+/**
+* Pushes reference to the remote server
+* All validation happens server-side
+* @param reference - Reference data to push
+* @param token - Authentication token
+* @returns Push result
+*/
+async function pushReference(reference, token) {
+	const client = createClient(token);
+	try {
+		const result = await client.action(api.references.push, {
+			fullName: reference.fullName,
+			referenceName: reference.referenceName,
+			referenceDescription: reference.referenceDescription,
+			referenceContent: reference.referenceContent,
+			commitSha: reference.commitSha,
+			generatedAt: reference.generatedAt
+		});
+		if (!result.success) switch (result.error) {
+			case "auth_required": throw new AuthenticationError();
+			case "rate_limit": throw new RateLimitError("Rate limit exceeded. You can push up to 20 times per day.");
+			case "commit_already_exists": throw new CommitExistsError(result.message);
+			case "invalid_input": throw new InvalidInputError(result.message ?? "Invalid input");
+			case "invalid_reference": throw new InvalidReferenceError(result.message ?? "Invalid reference content");
+			case "repo_not_found": throw new RepoNotFoundError$1(result.message);
+			case "low_stars": throw new LowStarsError(result.message);
+			case "private_repo": throw new PrivateRepoError(result.message);
+			case "commit_not_found": throw new CommitNotFoundError(result.message);
+			case "github_error": throw new GitHubError(result.message);
+			default: throw new SyncError(result.message ?? "Unknown error");
+		}
+		return { success: true };
+	} catch (error) {
+		if (error instanceof SyncError) throw error;
+		throw new NetworkError(`Failed to push reference: ${error instanceof Error ? error.message : error}`);
+	}
+}
+/**
+* Checks if reference exists on remote server (lightweight check)
+* @param fullName - Repository full name (owner/repo)
+* @returns Check result
+*/
+async function checkRemote(fullName) {
+	const client = createClient();
+	try {
+		let result = await client.query(api.references.check, {
+			fullName,
+			referenceName: toReferenceName(fullName)
+		});
+		if (!result.exists) result = await client.query(api.references.check, { fullName });
+		if (!result.exists) return { exists: false };
+		return {
+			exists: true,
+			commitSha: result.commitSha,
+			generatedAt: result.generatedAt
+		};
+	} catch (error) {
+		throw new NetworkError(`Failed to check remote: ${error instanceof Error ? error.message : error}`);
+	}
+}
+/**
+* Checks if a specific reference exists on the remote server
+* @param fullName - Repository full name (owner/repo)
+* @param referenceName - Specific reference name to check
+* @returns Check result
+*/
+async function checkRemoteByName(fullName, referenceName) {
+	const client = createClient();
+	try {
+		const result = await client.query(api.references.check, {
+			fullName,
+			referenceName
+		});
+		if (!result.exists) return { exists: false };
+		return {
+			exists: true,
+			commitSha: result.commitSha,
+			generatedAt: result.generatedAt
+		};
+	} catch (error) {
+		throw new NetworkError(`Failed to check remote: ${error instanceof Error ? error.message : error}`);
+	}
+}
+/**
+* Compares local vs remote commit SHA to check staleness
+* @param fullName - Repository full name (owner/repo)
+* @param localCommitSha - Local commit SHA
+* @returns Staleness result
+*/
+async function checkStaleness(fullName, localCommitSha) {
+	const remote = await checkRemote(fullName);
+	if (!remote.exists || !remote.commitSha) return {
+		isStale: false,
+		localCommitSha,
+		remoteCommitSha: void 0
+	};
+	return {
+		isStale: localCommitSha !== remote.commitSha,
+		localCommitSha,
+		remoteCommitSha: remote.commitSha
+	};
+}
+/**
+* Fetches GitHub repository metadata
+* @param owner - Repository owner
+* @param repo - Repository name
+* @returns Repository metadata or null on error
+*/
+async function fetchGitHubMetadata(owner, repo) {
+	try {
+		const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}`, { headers: {
+			Accept: "application/vnd.github.v3+json",
+			"User-Agent": "offworld-cli"
+		} });
+		if (!response.ok) return null;
+		const data = await response.json();
+		return {
+			stars: data.stargazers_count ?? 0,
+			description: data.description ?? void 0,
+			language: data.language ?? void 0,
+			defaultBranch: data.default_branch ?? "main"
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Fetches GitHub repository stars
+* @param owner - Repository owner
+* @param repo - Repository name
+* @returns Number of stars, or 0 on error
+*/
+async function fetchRepoStars(owner, repo) {
+	return (await fetchGitHubMetadata(owner, repo))?.stars ?? 0;
+}
+/**
+* Checks if a repository can be pushed to offworld.sh (client-side quick checks)
+* Note: Star count and other validations happen server-side
+*
+* @param source - Repository source
+* @returns Can push result
+*/
+function canPushToWeb(source) {
+	if (source.type === "local") return {
+		allowed: false,
+		reason: "Local repositories cannot be pushed to offworld.sh. Only remote repositories with a public URL are supported."
+	};
+	if (source.provider !== "github") return {
+		allowed: false,
+		reason: `${source.provider} repositories are not yet supported. GitHub support only for now - GitLab and Bitbucket coming soon!`
+	};
+	return { allowed: true };
+}
+/**
+* Validates that a source can be pushed and throws appropriate error if not
+* Note: This only does quick client-side checks. Full validation happens server-side.
+* @param source - Repository source
+* @throws PushNotAllowedError if push is not allowed
+*/
+function validatePushAllowed(source) {
+	const result = canPushToWeb(source);
+	if (!result.allowed) {
+		const reason = source.type === "local" ? "local" : "not-github";
+		throw new PushNotAllowedError(result.reason, reason);
+	}
+}
+
+//#endregion
+//#region src/auth.ts
+/**
+* Authentication utilities for offworld CLI
+*/
+var AuthError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AuthError";
+	}
+};
+var NotLoggedInError = class extends AuthError {
+	constructor(message = "Not logged in. Please run 'ow auth login' first.") {
+		super(message);
+		this.name = "NotLoggedInError";
+	}
+};
+var TokenExpiredError = class extends AuthError {
+	constructor(message = "Session expired. Please run 'ow auth login' again.") {
+		super(message);
+		this.name = "TokenExpiredError";
+	}
+};
+/**
+* Extracts expiration timestamp from JWT access token
+* @param token - JWT access token
+* @returns ISO string of expiration date, or undefined if extraction fails
+*/
+function extractJwtExpiration(token) {
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 3) return void 0;
+		const payload = parts[1];
+		if (!payload) return void 0;
+		const decoded = JSON.parse(Buffer.from(payload, "base64").toString("utf-8"));
+		if (typeof decoded.exp !== "number") return void 0;
+		return (/* @__PURE__ */ new Date(decoded.exp * 1e3)).toISOString();
+	} catch {
+		return;
+	}
+}
+/**
+* Returns the auth file path using XDG Base Directory spec
+* Location: ~/.local/share/offworld/auth.json
+*/
+function getAuthPath() {
+	return Paths.authFile;
+}
+/**
+* Saves authentication data to ~/.local/share/offworld/auth.json
+* Creates directory if it doesn't exist
+*/
+function saveAuthData(data) {
+	const authPath = getAuthPath();
+	const authDir = dirname(authPath);
+	if (!existsSync(authDir)) mkdirSync(authDir, { recursive: true });
+	writeFileSync(authPath, JSON.stringify(data, null, 2), "utf-8");
+	chmodSync(authPath, 384);
+}
+/**
+* Loads authentication data from ~/.local/share/offworld/auth.json
+* Returns null if file doesn't exist or is invalid
+*/
+function loadAuthData() {
+	const authPath = getAuthPath();
+	if (!existsSync(authPath)) return null;
+	try {
+		const content = readFileSync(authPath, "utf-8");
+		const data = JSON.parse(content);
+		if (!data.token || typeof data.token !== "string") return null;
+		return data;
+	} catch {
+		return null;
+	}
+}
+/**
+* Clears stored authentication data
+* @returns true if auth file was deleted, false if it didn't exist
+*/
+function clearAuthData() {
+	const authPath = getAuthPath();
+	if (!existsSync(authPath)) return false;
+	try {
+		unlinkSync(authPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Gets the current authentication token
+* Auto-refreshes if token expires within 1 minute
+* @throws NotLoggedInError if not logged in
+* @throws TokenExpiredError if token is expired and refresh fails
+*/
+async function getToken() {
+	const data = loadAuthData();
+	if (!data) throw new NotLoggedInError();
+	let expiresAtStr = data.expiresAt;
+	if (!expiresAtStr) {
+		expiresAtStr = extractJwtExpiration(data.token);
+		if (expiresAtStr) {
+			data.expiresAt = expiresAtStr;
+			saveAuthData(data);
+		}
+	}
+	if (expiresAtStr) {
+		const expiresAt = new Date(expiresAtStr);
+		const now = /* @__PURE__ */ new Date();
+		const oneMinute = 60 * 1e3;
+		if (expiresAt <= now) {
+			if (data.refreshToken) try {
+				return (await refreshAccessToken()).token;
+			} catch {
+				throw new TokenExpiredError();
+			}
+			throw new TokenExpiredError();
+		}
+		if (expiresAt.getTime() - now.getTime() < oneMinute) {
+			if (data.refreshToken) try {
+				return (await refreshAccessToken()).token;
+			} catch {
+				return data.token;
+			}
+		}
+	}
+	return data.token;
+}
+/**
+* Gets the current authentication token, or null if not logged in
+* Does not throw errors
+*/
+async function getTokenOrNull() {
+	try {
+		return await getToken();
+	} catch {
+		return null;
+	}
+}
+/**
+* Checks if user is logged in with valid token
+*/
+async function isLoggedIn() {
+	return await getTokenOrNull() !== null;
+}
+async function getAuthStatus() {
+	const data = loadAuthData();
+	if (!data) return { isLoggedIn: false };
+	if (data.expiresAt) {
+		if (new Date(data.expiresAt) <= /* @__PURE__ */ new Date()) {
+			if (data.refreshToken) try {
+				const refreshed = await refreshAccessToken();
+				return {
+					isLoggedIn: true,
+					email: refreshed.email,
+					workosId: refreshed.workosId,
+					expiresAt: refreshed.expiresAt
+				};
+			} catch {
+				return { isLoggedIn: false };
+			}
+			return { isLoggedIn: false };
+		}
+	}
+	return {
+		isLoggedIn: true,
+		email: data.email,
+		workosId: data.workosId,
+		expiresAt: data.expiresAt
+	};
+}
+const WORKOS_API = "https://api.workos.com";
+function getWorkosClientId() {
+	return process.env.WORKOS_CLIENT_ID || "";
+}
+/**
+* Refreshes the access token using the stored refresh token
+* @returns New auth data with refreshed token
+* @throws AuthError if refresh fails
+*/
+async function refreshAccessToken() {
+	const data = loadAuthData();
+	if (!data?.refreshToken) throw new AuthError("No refresh token available. Please log in again.");
+	const clientId = getWorkosClientId();
+	if (!clientId) throw new AuthError("WORKOS_CLIENT_ID not configured");
+	try {
+		const response = await fetch(`${WORKOS_API}/user_management/authenticate`, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams({
+				grant_type: "refresh_token",
+				refresh_token: data.refreshToken,
+				client_id: clientId
+			})
+		});
+		if (!response.ok) throw new AuthError(`Token refresh failed: ${await response.text()}`);
+		const tokenData = await response.json();
+		const newAuthData = {
+			token: tokenData.access_token,
+			email: tokenData.user.email,
+			workosId: tokenData.user.id,
+			refreshToken: tokenData.refresh_token,
+			expiresAt: tokenData.expires_at ? (/* @__PURE__ */ new Date(tokenData.expires_at * 1e3)).toISOString() : extractJwtExpiration(tokenData.access_token)
+		};
+		saveAuthData(newAuthData);
+		return newAuthData;
+	} catch (error) {
+		if (error instanceof AuthError) throw error;
+		throw new AuthError(`Failed to refresh token: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+
+//#endregion
+//#region src/agents.ts
+/**
+* Agent Registry & Auto-Detection
+*
+* Centralized registry of supported AI coding agents with their
+* skill directory locations and detection functions.
+*/
+const agents = {
+	opencode: {
+		name: "opencode",
+		displayName: "OpenCode",
+		skillsDir: ".opencode/skills",
+		globalSkillsDir: "~/.config/opencode/skills",
+		detectInstalled: () => existsSync(expandTilde("~/.config/opencode"))
+	},
+	"claude-code": {
+		name: "claude-code",
+		displayName: "Claude Code",
+		skillsDir: ".claude/skills",
+		globalSkillsDir: "~/.claude/skills",
+		detectInstalled: () => existsSync(expandTilde("~/.claude"))
+	},
+	codex: {
+		name: "codex",
+		displayName: "Codex (OpenAI)",
+		skillsDir: ".codex/skills",
+		globalSkillsDir: "~/.codex/skills",
+		detectInstalled: () => existsSync(expandTilde("~/.codex"))
+	},
+	amp: {
+		name: "amp",
+		displayName: "Amp",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: "~/.config/agents/skills",
+		detectInstalled: () => existsSync(expandTilde("~/.config/amp"))
+	},
+	antigravity: {
+		name: "antigravity",
+		displayName: "Antigravity",
+		skillsDir: ".agent/skills",
+		globalSkillsDir: "~/.gemini/antigravity/skills",
+		detectInstalled: () => existsSync(expandTilde("~/.gemini/antigravity"))
+	},
+	cursor: {
+		name: "cursor",
+		displayName: "Cursor",
+		skillsDir: ".cursor/skills",
+		globalSkillsDir: "~/.cursor/skills",
+		detectInstalled: () => existsSync(expandTilde("~/.cursor"))
+	}
+};
+/**
+* Detect which agents are installed on the system.
+* Checks for the existence of each agent's config directory.
+*
+* @returns Array of installed agent identifiers
+*/
+function detectInstalledAgents() {
+	const installed = [];
+	for (const config of Object.values(agents)) if (config.detectInstalled()) installed.push(config.name);
+	return installed;
+}
+/**
+* Get the configuration for a specific agent.
+*
+* @param type - Agent identifier
+* @returns AgentConfig for the specified agent
+*/
+function getAgentConfig(type) {
+	return agents[type];
+}
+/**
+* Get all agent configurations as an array.
+*
+* @returns Array of all agent configurations
+*/
+function getAllAgentConfigs() {
+	return Object.values(agents);
+}
+
+//#endregion
+//#region src/generate.ts
+/**
+* Simplified AI-only reference generation
+*
+* This module provides a streamlined approach to generating reference files
+* by delegating all codebase exploration to the AI agent via OpenCode.
+*/
+function normalizeKeyword(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return [];
+	const normalized = trimmed.toLowerCase();
+	const tokens = /* @__PURE__ */ new Set();
+	const addToken = (token) => {
+		const cleaned = token.trim().toLowerCase();
+		if (cleaned.length < 2) return;
+		tokens.add(cleaned);
+	};
+	addToken(normalized);
+	addToken(normalized.replaceAll("/", "-"));
+	addToken(normalized.replaceAll("/", ""));
+	for (const token of normalized.split(/[\s/_-]+/)) addToken(token);
+	if (normalized.startsWith("@")) addToken(normalized.slice(1));
+	return Array.from(tokens);
+}
+function deriveKeywords(fullName, localPath, referenceContent) {
+	const keywords = /* @__PURE__ */ new Set();
+	const addKeywords = (value) => {
+		for (const token of normalizeKeyword(value)) keywords.add(token);
+	};
+	addKeywords(fullName);
+	const headingMatch = referenceContent.match(/^#\s+(.+)$/m);
+	if (headingMatch?.[1]) addKeywords(headingMatch[1]);
+	const packageJsonPath = join(localPath, "package.json");
+	if (existsSync(packageJsonPath)) try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const data = JSON.parse(content);
+		if (data.name) addKeywords(data.name);
+		if (Array.isArray(data.keywords)) {
+			for (const keyword of data.keywords) if (typeof keyword === "string") addKeywords(keyword);
+		}
+	} catch {}
+	return Array.from(keywords);
+}
+function createReferenceGenerationPrompt(referenceName) {
+	return `You are an expert at analyzing open source libraries and producing reference documentation for AI coding agents.
+
+## PRIMARY GOAL
+
+Generate a reference markdown file that helps developers USE this library effectively. This is NOT a contribution guide - it's a usage reference for developers consuming this library in their own projects.
+
+## CRITICAL RULES
+
+1. **USER PERSPECTIVE ONLY**: Write for developers who will npm/pip/cargo install this library and use it in THEIR code.
+   - DO NOT include: how to contribute, internal test commands, repo-specific policies
+   - DO NOT include: "never mock in tests" or similar internal dev guidelines
+   - DO NOT include: commands like "npx hereby", "just ready", "bun test" that run the library's own tests
+   - DO include: how to install, import, configure, and use the public API
+
+2. **NO FRONTMATTER**: Output pure markdown with NO YAML frontmatter. Start directly with the library name heading.
+
+3. **QUICK REFERENCES**: Include a "Quick References" section with paths to key entry points in the repo:
+   - Paths must be relative from repo root (e.g., \`src/index.ts\`, \`docs/api.md\`)
+   - Include: main entry point, type definitions, README, key docs
+   - DO NOT include absolute paths or user-specific paths
+   - Keep to 3-5 most important files that help users understand the library
+
+4. **PUBLIC API FOCUS**: Document what users import and call, not internal implementation details.
+   - Entry points: what to import from the package
+   - Configuration: how to set up/initialize
+   - Core methods/functions: the main API surface
+   - Types: key TypeScript interfaces users need
+
+5. **MONOREPO AWARENESS**: Many libraries are monorepos with multiple packages:
+   - Check for \`packages/\`, \`apps/\`, \`crates/\`, or \`libs/\` directories
+   - Check root package.json for \`workspaces\` field
+   - If monorepo: document the package structure and key packages users would install
+   - Use full paths from repo root (e.g., \`packages/core/src/index.ts\`)
+   - Identify which packages are publishable vs internal
+
+## EXPLORATION STEPS
+
+Use Read, Grep, Glob tools to explore:
+1. Root package.json / Cargo.toml - check for workspaces/monorepo config
+2. Check for \`packages/\`, \`apps/\`, \`crates/\` directories
+3. README.md - official usage documentation
+4. For monorepos: explore each publishable package's entry point
+5. docs/ or website/ - find documentation
+6. examples/ - real usage patterns
+7. TypeScript definitions (.d.ts) - public API surface
+
+## OUTPUT FORMAT
+
+IMPORTANT: Reference name is "${referenceName}" (for internal tracking only - do NOT include in output).
+
+\`\`\`markdown
+# {Library Name}
+
+{2-3 sentence overview of what this library does and its key value proposition}
+
+## Quick References
+
+| File | Purpose |
+|------|---------|
+| \`packages/{pkg}/src/index.ts\` | Main entry point (monorepo example) |
+| \`src/index.ts\` | Main entry point (single-package example) |
+| \`README.md\` | Documentation |
+
+(For monorepos, include paths to key publishable packages)
+
+## Packages (for monorepos only)
+
+| Package | npm name | Description |
+|---------|----------|-------------|
+| \`packages/core\` | \`@scope/core\` | Core functionality |
+| \`packages/react\` | \`@scope/react\` | React bindings |
+
+(OMIT this section for single-package repos)
+
+## When to Use
+
+- {Practical scenario where a developer would reach for this library}
+- {Another real-world use case}
+- {Problem this library solves}
+
+## Installation
+
+\`\`\`bash
+# Single package
+npm install {package-name}
+
+# Monorepo (show key packages)
+npm install @scope/core @scope/react
+\`\`\`
+
+## Best Practices
+
+1. {Actionable best practice for USERS of this library}
+2. {Common mistake to avoid when using this library}
+3. {Performance or correctness tip}
+
+## Common Patterns
+
+**{Pattern Name}:**
+\`\`\`{language}
+{Minimal working code example}
+\`\`\`
+
+**{Another Pattern}:**
+\`\`\`{language}
+{Another code example}
+\`\`\`
+
+## API Quick Reference
+
+| Export | Type | Description |
+|--------|------|-------------|
+| \`{main export}\` | {type} | {what it does} |
+| \`{another export}\` | {type} | {what it does} |
+
+{Add more sections as appropriate for the library: Configuration, Types, CLI Commands (if user-facing), etc.}
+\`\`\`
+
+## QUALITY CHECKLIST
+
+Before outputting, verify:
+- [ ] NO YAML frontmatter - start directly with # heading
+- [ ] Every code example is something a USER would write, not a contributor
+- [ ] No internal test commands or contribution workflows
+- [ ] Quick References paths are relative from repo root (no absolute/user paths)
+- [ ] Best practices are for using the library, not developing it
+- [ ] If monorepo: Packages section lists publishable packages with npm names
+- [ ] If monorepo: paths include package directory (e.g., \`packages/core/src/index.ts\`)
+
+Now explore the codebase and generate the reference content.
+
+CRITICAL: Wrap your final reference output in XML tags exactly like this:
+<reference_output>
+# {Library Name}
+(the complete markdown content with NO frontmatter)
+</reference_output>
+
+Output ONLY the reference content inside the tags. No explanations before or after the tags.`;
+}
+/**
+* Extract the actual reference markdown content from AI response.
+* The response may include echoed prompt/system context before the actual reference.
+* We look for the LAST occurrence of XML tags: <reference_output>...</reference_output>
+* (Using last occurrence avoids extracting example tags from echoed prompt)
+*/
+function extractReferenceContent(rawResponse) {
+	const openTag = "<reference_output>";
+	const closeIndex = rawResponse.lastIndexOf("</reference_output>");
+	if (closeIndex !== -1) {
+		const openIndex = rawResponse.lastIndexOf(openTag, closeIndex);
+		if (openIndex !== -1) {
+			let content = rawResponse.slice(openIndex + 18, closeIndex).trim();
+			if (content.startsWith("```")) {
+				content = content.replace(/^```(?:markdown)?\s*\n?/, "");
+				content = content.replace(/\n?```\s*$/, "");
+			}
+			content = content.trim();
+			validateReferenceContent(content);
+			return content;
+		}
+	}
+	throw new Error("Failed to extract reference content: no <reference_output> tags found in AI response. The AI may have failed to follow the output format instructions.");
+}
+/**
+* Validate extracted reference content has minimum required structure.
+* Throws if content is invalid.
+*/
+function validateReferenceContent(content) {
+	if (content.length < 500) throw new Error(`Invalid reference content: too short (${content.length} chars, minimum 500). The AI may have produced placeholder or incomplete content.`);
+	if (!content.startsWith("#")) throw new Error("Invalid reference content: must start with markdown heading. Content must begin with '# Library Name' (no YAML frontmatter).");
+}
+/**
+* Generate a reference markdown file for a repository using AI.
+*
+* Opens an OpenCode session and instructs the AI agent to explore the codebase
+* using Read, Grep, and Glob tools, then produce a comprehensive reference.
+*
+* @param repoPath - Path to the repository to analyze
+* @param repoName - Qualified name of the repo (e.g., "tanstack/query" or "my-local-repo")
+* @param options - Generation options (provider, model, callbacks)
+* @returns The generated reference content and commit SHA
+*/
+async function generateReferenceWithAI(repoPath, repoName, options = {}) {
+	const { provider, model, onDebug, onStream } = options;
+	const [configProvider, configModel] = loadConfig().defaultModel?.split("/") ?? [];
+	const aiProvider = provider ?? configProvider;
+	const aiModel = model ?? configModel;
+	onDebug?.(`Starting AI reference generation for ${repoName}`);
+	onDebug?.(`Repo path: ${repoPath}`);
+	onDebug?.(`Provider: ${aiProvider ?? "default"}, Model: ${aiModel ?? "default"}`);
+	const commitSha = getCommitSha(repoPath);
+	onDebug?.(`Commit SHA: ${commitSha}`);
+	const referenceName = toReferenceName(repoName);
+	onDebug?.(`Reference name: ${referenceName}`);
+	const result = await streamPrompt({
+		prompt: createReferenceGenerationPrompt(referenceName),
+		cwd: repoPath,
+		provider: aiProvider,
+		model: aiModel,
+		onDebug,
+		onStream
+	});
+	onDebug?.(`Generation complete (${result.durationMs}ms, ${result.text.length} chars)`);
+	const referenceContent = extractReferenceContent(result.text);
+	onDebug?.(`Extracted reference content (${referenceContent.length} chars)`);
+	return {
+		referenceContent,
+		commitSha
+	};
+}
+/**
+* Ensure a symlink exists, removing any existing file/directory at the path
+*/
+function ensureSymlink(target, linkPath) {
+	try {
+		const stat = lstatSync(linkPath);
+		if (stat.isSymbolicLink()) unlinkSync(linkPath);
+		else if (stat.isDirectory()) rmSync(linkPath, { recursive: true });
+		else unlinkSync(linkPath);
+	} catch {}
+	mkdirSync(join(linkPath, ".."), { recursive: true });
+	symlinkSync(target, linkPath, "dir");
+}
+/**
+* Static template for the global SKILL.md file.
+* This is the single routing skill that all agents see.
+*/
+const GLOBAL_SKILL_TEMPLATE = `---
+name: offworld
+description: Routes queries to Offworld reference files. Find and read per-repo references for dependency knowledge.
+allowed-tools: Bash(ow:*) Read
+---
+
+# Offworld Reference Router
+
+Look up dependency/library documentation via CLI, then read the reference file.
+
+## Usage
+
+**Find a reference:**
+\`\`\`bash
+ow map search <term>     # search by name or keyword
+ow map show <repo>       # get info for specific repo
+\`\`\`
+
+**Get paths for tools:**
+\`\`\`bash
+ow map show <repo> --ref   # reference file path (use with Read)
+ow map show <repo> --path  # clone directory path
+\`\`\`
+
+**Example workflow:**
+\`\`\`bash
+# 1. Find the repo
+ow map search zod
+
+# 2. Get reference path
+ow map show colinhacks/zod --ref
+# Output: /Users/.../.local/share/offworld/skill/offworld/references/colinhacks-zod.md
+
+# 3. Read the reference with the path from step 2
+\`\`\`
+
+## If Reference Not Found
+
+\`\`\`bash
+ow pull <owner/repo>    # clone + generate reference
+ow project init         # scan project deps, install references
+\`\`\`
+
+## All Commands
+
+| Command | Description |
+|---------|-------------|
+| \`ow map search <term>\` | Find repos by name/keyword |
+| \`ow map show <repo>\` | Show repo info |
+| \`ow map show <repo> --ref\` | Print reference file path |
+| \`ow map show <repo> --path\` | Print clone directory path |
+| \`ow list\` | List all installed repos |
+| \`ow pull <repo>\` | Clone + generate reference |
+
+## Notes
+
+- Project map (\`.offworld/map.json\`) takes precedence over global map when present
+- Reference files are markdown with API docs, patterns, best practices
+- Clone paths useful for exploring source code after reading reference
+`;
+/**
+* Ensures the global SKILL.md exists and symlinks the offworld/ directory to all agent skill directories.
+*
+* Creates:
+* - ~/.local/share/offworld/skill/offworld/SKILL.md (static routing template)
+* - ~/.local/share/offworld/skill/offworld/assets/ (for map.json)
+* - ~/.local/share/offworld/skill/offworld/references/ (for reference files)
+* - Symlinks entire offworld/ directory to each agent's skill directory
+*/
+function installGlobalSkill() {
+	const config = loadConfig();
+	mkdirSync(Paths.offworldSkillDir, { recursive: true });
+	mkdirSync(Paths.offworldAssetsDir, { recursive: true });
+	mkdirSync(Paths.offworldReferencesDir, { recursive: true });
+	const skillPath = join(Paths.offworldSkillDir, "SKILL.md");
+	if (!existsSync(skillPath)) writeFileSync(skillPath, GLOBAL_SKILL_TEMPLATE, "utf-8");
+	const configuredAgents = config.agents ?? [];
+	for (const agentName of configuredAgents) {
+		const agentConfig = agents[agentName];
+		if (agentConfig) {
+			const agentSkillDir = expandTilde(join(agentConfig.globalSkillsDir, "offworld"));
+			ensureSymlink(Paths.offworldSkillDir, agentSkillDir);
+		}
+	}
+}
+/**
+* Install a reference file for a specific repository.
+*
+* Creates:
+* - ~/.local/share/offworld/skill/offworld/references/{owner-repo}.md
+* - ~/.local/share/offworld/meta/{owner-repo}/meta.json
+* - Updates global map with reference info
+*
+* @param qualifiedName - Qualified key for map storage (e.g., "github.com:owner/repo" or "local:name")
+* @param fullName - Full repo name for file naming (e.g., "owner/repo")
+* @param localPath - Absolute path to the cloned repository
+* @param referenceContent - The generated reference markdown content
+* @param meta - Metadata about the generation (referenceUpdatedAt, commitSha, version)
+* @param keywords - Optional array of keywords for search/routing
+*/
+function installReference(qualifiedName, fullName, localPath, referenceContent, meta, keywords) {
+	installGlobalSkill();
+	const referenceFileName = toReferenceFileName(fullName);
+	const metaDirName = toMetaDirName(fullName);
+	const referencePath = join(Paths.offworldReferencesDir, referenceFileName);
+	mkdirSync(Paths.offworldReferencesDir, { recursive: true });
+	writeFileSync(referencePath, referenceContent, "utf-8");
+	const metaDir = join(Paths.metaDir, metaDirName);
+	mkdirSync(metaDir, { recursive: true });
+	const metaJson = JSON.stringify(meta, null, 2);
+	writeFileSync(join(metaDir, "meta.json"), metaJson, "utf-8");
+	const map = readGlobalMap();
+	const existingEntry = map.repos[qualifiedName];
+	const legacyProviderMap = {
+		"github.com": "github",
+		"gitlab.com": "gitlab",
+		"bitbucket.org": "bitbucket"
+	};
+	const [host] = qualifiedName.split(":");
+	const legacyProvider = host ? legacyProviderMap[host] : void 0;
+	const legacyQualifiedName = legacyProvider ? `${legacyProvider}:${fullName}` : void 0;
+	const legacyEntry = legacyQualifiedName ? map.repos[legacyQualifiedName] : void 0;
+	const references = [...existingEntry?.references ?? [], ...legacyEntry?.references ?? []];
+	if (!references.includes(referenceFileName)) references.push(referenceFileName);
+	const derivedKeywords = keywords ?? deriveKeywords(fullName, localPath, referenceContent);
+	const keywordsSet = new Set([
+		...existingEntry?.keywords ?? [],
+		...legacyEntry?.keywords ?? [],
+		...derivedKeywords
+	]);
+	map.repos[qualifiedName] = {
+		localPath,
+		references,
+		primary: referenceFileName,
+		keywords: Array.from(keywordsSet),
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (legacyQualifiedName && legacyQualifiedName in map.repos) delete map.repos[legacyQualifiedName];
+	writeGlobalMap(map);
+}
+
+//#endregion
+//#region src/manifest.ts
+/**
+* Dependency manifest parsing for multiple package ecosystems
+*/
+/**
+* Detects the manifest type in a directory
+*/
+function detectManifestType(dir) {
+	if (existsSync(join(dir, "package.json"))) return "npm";
+	if (existsSync(join(dir, "pyproject.toml"))) return "python";
+	if (existsSync(join(dir, "Cargo.toml"))) return "rust";
+	if (existsSync(join(dir, "go.mod"))) return "go";
+	if (existsSync(join(dir, "requirements.txt"))) return "python";
+	return "unknown";
+}
+/**
+* Parses dependencies from manifest files
+*/
+function parseDependencies(dir) {
+	switch (detectManifestType(dir)) {
+		case "npm": return parsePackageJson(join(dir, "package.json"));
+		case "python": return existsSync(join(dir, "pyproject.toml")) ? parsePyprojectToml(join(dir, "pyproject.toml")) : parseRequirementsTxt(join(dir, "requirements.txt"));
+		case "rust": return parseCargoToml(join(dir, "Cargo.toml"));
+		case "go": return parseGoMod(join(dir, "go.mod"));
+		default: return [];
+	}
+}
+/**
+* Parse package.json dependencies
+*/
+function parsePackageJson(path) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		const pkg = JSON.parse(content);
+		const deps = [];
+		if (pkg.dependencies && typeof pkg.dependencies === "object") for (const [name, version] of Object.entries(pkg.dependencies)) deps.push({
+			name,
+			version,
+			dev: false
+		});
+		if (pkg.devDependencies && typeof pkg.devDependencies === "object") for (const [name, version] of Object.entries(pkg.devDependencies)) deps.push({
+			name,
+			version,
+			dev: true
+		});
+		return deps;
+	} catch {
+		return [];
+	}
+}
+/**
+* Parse pyproject.toml dependencies
+*/
+function parsePyprojectToml(path) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		const deps = [];
+		const depsSection = content.match(/\[project\.dependencies\]([\s\S]*?)(?=\[|$)/);
+		if (!depsSection?.[1]) return [];
+		const lines = depsSection[1].split("\n");
+		for (const line of lines) {
+			const match = line.match(/["']([a-zA-Z0-9_-]+)(?:[>=<~!]+([^"']+))?["']/);
+			if (match?.[1]) deps.push({
+				name: match[1],
+				version: match[2]?.trim(),
+				dev: false
+			});
+		}
+		return deps;
+	} catch {
+		return [];
+	}
+}
+/**
+* Parse Cargo.toml dependencies
+*/
+function parseCargoToml(path) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		const deps = [];
+		const depsSection = content.match(/\[dependencies\]([\s\S]*?)(?=\[|$)/);
+		if (!depsSection?.[1]) return [];
+		const lines = depsSection[1].split("\n");
+		for (const line of lines) {
+			const simpleMatch = line.match(/^([a-zA-Z0-9_-]+)\s*=\s*"([^"]+)"/);
+			const tableMatch = line.match(/^([a-zA-Z0-9_-]+)\s*=\s*{.*version\s*=\s*"([^"]+)"/);
+			if (simpleMatch?.[1] && simpleMatch[2]) deps.push({
+				name: simpleMatch[1],
+				version: simpleMatch[2],
+				dev: false
+			});
+			else if (tableMatch?.[1] && tableMatch[2]) deps.push({
+				name: tableMatch[1],
+				version: tableMatch[2],
+				dev: false
+			});
+		}
+		return deps;
+	} catch {
+		return [];
+	}
+}
+/**
+* Parse go.mod dependencies
+*/
+function parseGoMod(path) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		const deps = [];
+		const requireSection = content.match(/require\s*\(([\s\S]*?)\)/);
+		if (!requireSection?.[1]) {
+			const singleRequire = content.match(/require\s+([^\s]+)\s+([^\s]+)/);
+			if (singleRequire?.[1] && singleRequire[2]) deps.push({
+				name: singleRequire[1],
+				version: singleRequire[2],
+				dev: false
+			});
+			return deps;
+		}
+		const lines = requireSection[1].split("\n");
+		for (const line of lines) {
+			const match = line.match(/^\s*([^\s]+)\s+([^\s]+)/);
+			if (match?.[1] && match[2]) deps.push({
+				name: match[1],
+				version: match[2],
+				dev: false
+			});
+		}
+		return deps;
+	} catch {
+		return [];
+	}
+}
+/**
+* Parse requirements.txt dependencies
+*/
+function parseRequirementsTxt(path) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		const deps = [];
+		const lines = content.split("\n");
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const match = trimmed.match(/^([a-zA-Z0-9_-]+)(?:[>=<~!]+(.+))?/);
+			if (match?.[1]) deps.push({
+				name: match[1],
+				version: match[2]?.trim(),
+				dev: false
+			});
+		}
+		return deps;
+	} catch {
+		return [];
+	}
+}
+
+//#endregion
+//#region src/dep-mappings.ts
+/**
+* Hardcoded mappings for popular packages.
+* Covers top ecosystems: React, Vue, Svelte, backend, database, validation, styling.
+*/
+const KNOWN_MAPPINGS = {
+	react: "facebook/react",
+	"react-dom": "facebook/react",
+	next: "vercel/next.js",
+	remix: "remix-run/remix",
+	"@remix-run/react": "remix-run/remix",
+	"@remix-run/node": "remix-run/remix",
+	vue: "vuejs/core",
+	nuxt: "nuxt/nuxt",
+	"@nuxt/kit": "nuxt/nuxt",
+	svelte: "sveltejs/svelte",
+	sveltekit: "sveltejs/kit",
+	"@sveltejs/kit": "sveltejs/kit",
+	"@tanstack/query": "tanstack/query",
+	"@tanstack/react-query": "tanstack/query",
+	"@tanstack/vue-query": "tanstack/query",
+	"@tanstack/router": "tanstack/router",
+	"@tanstack/react-router": "tanstack/router",
+	"@tanstack/start": "tanstack/router",
+	zustand: "pmndrs/zustand",
+	jotai: "pmndrs/jotai",
+	valtio: "pmndrs/valtio",
+	redux: "reduxjs/redux",
+	"@reduxjs/toolkit": "reduxjs/redux-toolkit",
+	express: "expressjs/express",
+	hono: "honojs/hono",
+	fastify: "fastify/fastify",
+	koa: "koajs/koa",
+	nestjs: "nestjs/nest",
+	"@nestjs/core": "nestjs/nest",
+	trpc: "trpc/trpc",
+	"@trpc/server": "trpc/trpc",
+	"@trpc/client": "trpc/trpc",
+	"@trpc/react-query": "trpc/trpc",
+	graphql: "graphql/graphql-js",
+	"apollo-server": "apollographql/apollo-server",
+	"@apollo/client": "apollographql/apollo-client",
+	"drizzle-orm": "drizzle-team/drizzle-orm",
+	prisma: "prisma/prisma",
+	"@prisma/client": "prisma/prisma",
+	typeorm: "typeorm/typeorm",
+	sequelize: "sequelize/sequelize",
+	mongoose: "Automattic/mongoose",
+	knex: "knex/knex",
+	zod: "colinhacks/zod",
+	valibot: "fabian-hiller/valibot",
+	yup: "jquense/yup",
+	joi: "hapijs/joi",
+	tailwindcss: "tailwindlabs/tailwindcss",
+	"styled-components": "styled-components/styled-components",
+	"@emotion/react": "emotion-js/emotion",
+	sass: "sass/sass",
+	vite: "vitejs/vite",
+	webpack: "webpack/webpack",
+	esbuild: "evanw/esbuild",
+	rollup: "rollup/rollup",
+	"@vitejs/plugin-react": "vitejs/vite-plugin-react",
+	vitest: "vitest-dev/vitest",
+	jest: "jestjs/jest",
+	"@testing-library/react": "testing-library/react-testing-library",
+	cypress: "cypress-io/cypress",
+	playwright: "microsoft/playwright",
+	convex: "get-convex/convex-backend",
+	"better-auth": "better-auth/better-auth",
+	lodash: "lodash/lodash",
+	"date-fns": "date-fns/date-fns",
+	axios: "axios/axios",
+	ky: "sindresorhus/ky",
+	turborepo: "vercel/turborepo",
+	nx: "nrwl/nx"
+};
+/**
+* Parse GitHub repo from various git URL formats.
+* Handles:
+* - git+https://github.com/owner/repo.git
+* - https://github.com/owner/repo
+* - git://github.com/owner/repo.git
+* - github:owner/repo
+*/
+function parseGitHubUrl(url) {
+	for (const pattern of [/github\.com[/:]([\w-]+)\/([\w.-]+?)(?:\.git)?$/, /^github:([\w-]+)\/([\w.-]+)$/]) {
+		const match = url.match(pattern);
+		if (match) return `${match[1]}/${match[2]}`;
+	}
+	return null;
+}
+/**
+* Fallback to npm registry to extract repository.url.
+* Returns null if package not found, no repo field, or not a GitHub repo.
+*/
+async function resolveFromNpm(packageName) {
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${packageName}`);
+		if (!res.ok) return null;
+		const repoUrl = (await res.json()).repository?.url;
+		if (!repoUrl) return null;
+		return parseGitHubUrl(repoUrl);
+	} catch {
+		return null;
+	}
+}
+/**
+* Three-tier resolution:
+* 1. Check KNOWN_MAPPINGS
+* 2. Query npm registry
+* 3. Return unknown (caller prompts user)
+*/
+async function resolveDependencyRepo(dep) {
+	if (dep in KNOWN_MAPPINGS) return {
+		dep,
+		repo: KNOWN_MAPPINGS[dep] ?? null,
+		source: "known"
+	};
+	const npmRepo = await resolveFromNpm(dep);
+	if (npmRepo) return {
+		dep,
+		repo: npmRepo,
+		source: "npm"
+	};
+	return {
+		dep,
+		repo: null,
+		source: "unknown"
+	};
+}
+
+//#endregion
+//#region src/reference-matcher.ts
+/**
+* Reference matching utilities for dependency resolution
+*
+* Maps dependencies to their reference status (installed, available, generate, unknown)
+*/
+/**
+* Check if a reference is installed locally.
+* A reference is considered installed if {owner-repo}.md exists in offworld/references/.
+*
+* @param repo - Repo name in owner/repo format
+* @returns true if reference is installed locally
+*/
+function isReferenceInstalled(repo) {
+	const referenceFileName = toReferenceFileName(repo);
+	return existsSync(join(Paths.offworldReferencesDir, referenceFileName));
+}
+/**
+* Match dependencies to their reference availability status.
+*
+* Status logic:
+* - installed: {owner-repo}.md exists in offworld/references/
+* - available: Has valid GitHub repo (can be cloned)
+* - generate: Has valid GitHub repo but will need AI generation
+* - unknown: No GitHub repo found
+*
+* Note: Since we don't have a reference registry/index, "available" and "generate"
+* are the same. We use "available" for consistency and reserve "generate" for
+* future use when we can distinguish pre-existing vs needs-generation.
+*
+* @param resolvedDeps - Array of resolved dependencies with repo info
+* @returns Array of reference matches with status
+*/
+function matchDependenciesToReferences(resolvedDeps) {
+	return resolvedDeps.map((dep) => {
+		if (!dep.repo) return {
+			dep: dep.dep,
+			repo: null,
+			status: "unknown",
+			source: dep.source
+		};
+		if (isReferenceInstalled(dep.repo)) return {
+			dep: dep.dep,
+			repo: dep.repo,
+			status: "installed",
+			source: dep.source
+		};
+		return {
+			dep: dep.dep,
+			repo: dep.repo,
+			status: "available",
+			source: dep.source
+		};
+	});
+}
+
+//#endregion
+//#region src/agents-md.ts
+/**
+* AGENTS.md manipulation utilities
+*
+* Manages updating project AGENTS.md and agent-specific files with reference information.
+*/
+/**
+* Generate markdown table for project references section.
+*
+* @param references - Array of installed references
+* @returns Markdown string with table
+*/
+function generateReferencesTable(references) {
+	const lines = [
+		"## Project References",
+		"",
+		"References installed for this project's dependencies:",
+		"",
+		"| Dependency | Reference | Path |",
+		"| --- | --- | --- |"
+	];
+	for (const reference of references) lines.push(`| ${reference.dependency} | ${reference.reference} | ${reference.path} |`);
+	lines.push("");
+	lines.push("To update references: `ow pull <dependency>`");
+	lines.push("To regenerate all: `ow project init --all --generate`");
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Update or append Project References section in a markdown file.
+* If the section exists, replaces its content. Otherwise, appends to end.
+*
+* @param filePath - Path to markdown file
+* @param references - Array of installed references
+*/
+function appendReferencesSection(filePath, references) {
+	const content = existsSync(filePath) ? readFileSync(filePath, "utf-8") : "";
+	const referencesMarkdown = generateReferencesTable(references);
+	const sectionRegex = /^## Project References\n(?:.*\n)*?(?=^## |$)/m;
+	const match = content.match(sectionRegex);
+	let updatedContent;
+	if (match) updatedContent = content.replace(sectionRegex, referencesMarkdown);
+	else updatedContent = content.trim() + "\n\n" + referencesMarkdown;
+	writeFileSync(filePath, updatedContent, "utf-8");
+}
+/**
+* Update AGENTS.md and agent-specific files with project references.
+* Creates files if they don't exist.
+*
+* @param projectRoot - Project root directory
+* @param references - Array of installed references to document
+*/
+function updateAgentFiles(projectRoot, references) {
+	const agentsMdPath = join(projectRoot, "AGENTS.md");
+	const claudeMdPath = join(projectRoot, "CLAUDE.md");
+	appendReferencesSection(agentsMdPath, references);
+	if (existsSync(claudeMdPath)) appendReferencesSection(claudeMdPath, references);
+}
+
+//#endregion
+//#region src/repo-manager.ts
+function getDirSize(dirPath) {
+	if (!existsSync(dirPath)) return 0;
+	let size = 0;
+	try {
+		const entries = readdirSync(dirPath, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dirPath, entry.name);
+			if (entry.isDirectory()) size += getDirSize(fullPath);
+			else if (entry.isFile()) try {
+				size += statSync(fullPath).size;
+			} catch {}
+		}
+	} catch {}
+	return size;
+}
+function getLastAccessTime(dirPath) {
+	if (!existsSync(dirPath)) return null;
+	let latestTime = null;
+	try {
+		latestTime = statSync(dirPath).mtime;
+		const fetchHead = join(dirPath, ".git", "FETCH_HEAD");
+		if (existsSync(fetchHead)) {
+			const fetchStat = statSync(fetchHead);
+			if (!latestTime || fetchStat.mtime > latestTime) latestTime = fetchStat.mtime;
+		}
+	} catch {}
+	return latestTime;
+}
+function matchesPattern(name, pattern) {
+	if (!pattern || pattern === "*") return true;
+	return new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i").test(name);
+}
+const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+async function getRepoStatus(options = {}) {
+	const { onProgress } = options;
+	const map = readGlobalMap();
+	const qualifiedNames = Object.keys(map.repos);
+	const total = qualifiedNames.length;
+	let withReference = 0;
+	let missing = 0;
+	let diskBytes = 0;
+	for (let i = 0; i < qualifiedNames.length; i++) {
+		const qualifiedName = qualifiedNames[i];
+		const entry = map.repos[qualifiedName];
+		onProgress?.(i + 1, total, qualifiedName);
+		await yieldToEventLoop();
+		if (!existsSync(entry.localPath)) {
+			missing++;
+			continue;
+		}
+		if (entry.references.length > 0) withReference++;
+		diskBytes += getDirSize(entry.localPath);
+	}
+	return {
+		total,
+		withReference,
+		missing,
+		diskBytes
+	};
+}
+async function updateAllRepos(options = {}) {
+	const { pattern, dryRun = false, unshallow = false, onProgress } = options;
+	const map = readGlobalMap();
+	const qualifiedNames = Object.keys(map.repos);
+	const updated = [];
+	const skipped = [];
+	const unshallowed = [];
+	const errors = [];
+	for (const qualifiedName of qualifiedNames) {
+		const entry = map.repos[qualifiedName];
+		if (pattern && !matchesPattern(qualifiedName, pattern)) continue;
+		if (!existsSync(entry.localPath)) {
+			skipped.push(qualifiedName);
+			onProgress?.(qualifiedName, "skipped", "missing on disk");
+			continue;
+		}
+		if (dryRun) {
+			updated.push(qualifiedName);
+			onProgress?.(qualifiedName, "updated", "would update");
+			continue;
+		}
+		onProgress?.(qualifiedName, "updating");
+		try {
+			const result = await updateRepo(qualifiedName, { unshallow });
+			if (result.unshallowed) {
+				unshallowed.push(qualifiedName);
+				onProgress?.(qualifiedName, "unshallowed", "converted to full clone");
+			}
+			if (result.updated) {
+				updated.push(qualifiedName);
+				onProgress?.(qualifiedName, "updated", `${result.previousSha.slice(0, 7)} → ${result.currentSha.slice(0, 7)}`);
+			} else if (!result.unshallowed) {
+				skipped.push(qualifiedName);
+				onProgress?.(qualifiedName, "skipped", "already up to date");
+			}
+		} catch (err) {
+			const message = err instanceof GitError ? err.message : String(err);
+			errors.push({
+				repo: qualifiedName,
+				error: message
+			});
+			onProgress?.(qualifiedName, "error", message);
+		}
+	}
+	return {
+		updated,
+		skipped,
+		unshallowed,
+		errors
+	};
+}
+async function pruneRepos(options = {}) {
+	const { dryRun = false, onProgress } = options;
+	const map = readGlobalMap();
+	const qualifiedNames = Object.keys(map.repos);
+	const removedFromIndex = [];
+	const orphanedDirs = [];
+	for (const qualifiedName of qualifiedNames) {
+		const entry = map.repos[qualifiedName];
+		await yieldToEventLoop();
+		if (!existsSync(entry.localPath)) {
+			onProgress?.(qualifiedName, "missing on disk");
+			removedFromIndex.push(qualifiedName);
+			if (!dryRun) removeGlobalMapEntry(qualifiedName);
+		}
+	}
+	const repoRoot = getRepoRoot(loadConfig());
+	if (existsSync(repoRoot)) {
+		const indexedPaths = new Set(Object.values(map.repos).map((r) => r.localPath));
+		try {
+			const providers = readdirSync(repoRoot, { withFileTypes: true });
+			for (const provider of providers) {
+				if (!provider.isDirectory()) continue;
+				const providerPath = join(repoRoot, provider.name);
+				const owners = readdirSync(providerPath, { withFileTypes: true });
+				for (const owner of owners) {
+					if (!owner.isDirectory()) continue;
+					const ownerPath = join(providerPath, owner.name);
+					const repoNames = readdirSync(ownerPath, { withFileTypes: true });
+					for (const repoName of repoNames) {
+						await yieldToEventLoop();
+						if (!repoName.isDirectory()) continue;
+						const repoPath = join(ownerPath, repoName.name);
+						if (!existsSync(join(repoPath, ".git"))) continue;
+						if (!indexedPaths.has(repoPath)) {
+							const fullName = `${owner.name}/${repoName.name}`;
+							onProgress?.(fullName, "not in map");
+							orphanedDirs.push(repoPath);
+						}
+					}
+				}
+			}
+		} catch {}
+	}
+	return {
+		removedFromIndex,
+		orphanedDirs
+	};
+}
+async function gcRepos(options = {}) {
+	const { olderThanDays, withoutReference = false, dryRun = false, onProgress } = options;
+	const map = readGlobalMap();
+	const qualifiedNames = Object.keys(map.repos);
+	const removed = [];
+	let freedBytes = 0;
+	const now = /* @__PURE__ */ new Date();
+	const cutoffDate = olderThanDays ? /* @__PURE__ */ new Date(now.getTime() - olderThanDays * 24 * 60 * 60 * 1e3) : null;
+	for (const qualifiedName of qualifiedNames) {
+		const entry = map.repos[qualifiedName];
+		await yieldToEventLoop();
+		if (!existsSync(entry.localPath)) continue;
+		let shouldRemove = false;
+		let reason = "";
+		if (cutoffDate) {
+			const lastAccess = getLastAccessTime(entry.localPath);
+			if (lastAccess && lastAccess < cutoffDate) {
+				shouldRemove = true;
+				reason = `not accessed in ${olderThanDays}+ days`;
+			}
+		}
+		if (withoutReference && entry.references.length === 0) {
+			shouldRemove = true;
+			reason = reason ? `${reason}, no reference` : "no reference";
+		}
+		if (!shouldRemove) continue;
+		const sizeBytes = getDirSize(entry.localPath);
+		onProgress?.(qualifiedName, reason, sizeBytes);
+		if (!dryRun) {
+			rmSync(entry.localPath, {
+				recursive: true,
+				force: true
+			});
+			for (const refFile of entry.references) {
+				const refPath = join(Paths.offworldReferencesDir, refFile);
+				if (existsSync(refPath)) rmSync(refPath, { force: true });
+			}
+			if (entry.primary) {
+				const metaDirName = entry.primary.replace(/\.md$/, "");
+				const metaPath = join(Paths.metaDir, metaDirName);
+				if (existsSync(metaPath)) rmSync(metaPath, {
+					recursive: true,
+					force: true
+				});
+			}
+			removeGlobalMapEntry(qualifiedName);
+		}
+		removed.push({
+			repo: qualifiedName,
+			reason,
+			sizeBytes
+		});
+		freedBytes += sizeBytes;
+	}
+	return {
+		removed,
+		freedBytes
+	};
+}
+async function discoverRepos(options = {}) {
+	const { dryRun = false, onProgress } = options;
+	const config = loadConfig();
+	const repoRoot = options.repoRoot ?? getRepoRoot(config);
+	const discovered = [];
+	let alreadyIndexed = 0;
+	if (!existsSync(repoRoot)) return {
+		discovered,
+		alreadyIndexed
+	};
+	const map = readGlobalMap();
+	const indexedPaths = new Set(Object.values(map.repos).map((r) => r.localPath));
+	try {
+		const providers = readdirSync(repoRoot, { withFileTypes: true });
+		for (const provider of providers) {
+			if (!provider.isDirectory()) continue;
+			const providerPath = join(repoRoot, provider.name);
+			const providerHost = {
+				github: "github.com",
+				gitlab: "gitlab.com",
+				bitbucket: "bitbucket.org"
+			}[provider.name] ?? provider.name;
+			const owners = readdirSync(providerPath, { withFileTypes: true });
+			for (const owner of owners) {
+				if (!owner.isDirectory()) continue;
+				const ownerPath = join(providerPath, owner.name);
+				const repoNames = readdirSync(ownerPath, { withFileTypes: true });
+				for (const repoName of repoNames) {
+					await yieldToEventLoop();
+					if (!repoName.isDirectory()) continue;
+					const repoPath = join(ownerPath, repoName.name);
+					if (!existsSync(join(repoPath, ".git"))) continue;
+					if (indexedPaths.has(repoPath)) {
+						alreadyIndexed++;
+						continue;
+					}
+					const fullName = `${owner.name}/${repoName.name}`;
+					const qualifiedName = `${providerHost}:${fullName}`;
+					onProgress?.(fullName, providerHost);
+					if (!dryRun) upsertGlobalMapEntry(qualifiedName, {
+						localPath: repoPath,
+						references: [],
+						primary: "",
+						keywords: [],
+						updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+					});
+					discovered.push({
+						fullName,
+						qualifiedName,
+						localPath: repoPath
+					});
+				}
+			}
+		}
+	} catch {}
+	return {
+		discovered,
+		alreadyIndexed
+	};
+}
+
+//#endregion
+//#region src/models.ts
+const MODELS_DEV_URL = "https://models.dev/api.json";
+let cachedData = null;
+let cacheTime = 0;
+const CACHE_TTL_MS = 300 * 1e3;
+/**
+* Fetch raw data from models.dev with caching
+*/
+async function fetchModelsDevData() {
+	const now = Date.now();
+	if (cachedData && now - cacheTime < CACHE_TTL_MS) return cachedData;
+	const res = await fetch(MODELS_DEV_URL, { signal: AbortSignal.timeout(1e4) });
+	if (!res.ok) throw new Error(`Failed to fetch models.dev: ${res.status} ${res.statusText}`);
+	cachedData = await res.json();
+	cacheTime = now;
+	return cachedData;
+}
+/**
+* List all available providers from models.dev
+*/
+async function listProviders() {
+	const data = await fetchModelsDevData();
+	return Object.values(data).map((p) => ({
+		id: p.id,
+		name: p.name,
+		env: p.env
+	})).sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Get a specific provider with all its models
+*/
+async function getProvider(providerId) {
+	const provider = (await fetchModelsDevData())[providerId];
+	if (!provider) return null;
+	return {
+		id: provider.id,
+		name: provider.name,
+		env: provider.env,
+		models: Object.values(provider.models).filter((m) => m.status !== "deprecated").map((m) => ({
+			id: m.id,
+			name: m.name,
+			reasoning: m.reasoning,
+			experimental: m.experimental,
+			status: m.status
+		})).sort((a, b) => a.name.localeCompare(b.name))
+	};
+}
+/**
+* Get all providers with their models
+*/
+async function listProvidersWithModels() {
+	const data = await fetchModelsDevData();
+	return Object.values(data).map((p) => ({
+		id: p.id,
+		name: p.name,
+		env: p.env,
+		models: Object.values(p.models).filter((m) => m.status !== "deprecated").map((m) => ({
+			id: m.id,
+			name: m.name,
+			reasoning: m.reasoning,
+			experimental: m.experimental,
+			status: m.status
+		})).sort((a, b) => a.name.localeCompare(b.name))
+	})).sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Validate that a provider/model combination exists
+*/
+async function validateProviderModel(providerId, modelId) {
+	const provider = await getProvider(providerId);
+	if (!provider) {
+		const providers = await listProviders();
+		return {
+			valid: false,
+			error: `Provider "${providerId}" not found. Available: ${providers.slice(0, 10).map((p) => p.id).join(", ")}${providers.length > 10 ? "..." : ""}`
+		};
+	}
+	if (!provider.models.find((m) => m.id === modelId)) return {
+		valid: false,
+		error: `Model "${modelId}" not found for provider "${providerId}". Available: ${provider.models.slice(0, 10).map((m) => m.id).join(", ")}${provider.models.length > 10 ? "..." : ""}`
+	};
+	return { valid: true };
+}
+
+//#endregion
+//#region src/installation.ts
+/**
+* Installation utilities for upgrade/uninstall commands
+*/
+const GITHUB_REPO = "oscabriel/offworld";
+const NPM_PACKAGE = "offworld";
+/**
+* Detect how offworld was installed
+*/
+function detectInstallMethod() {
+	const execPath = process.execPath;
+	if (execPath.includes(".local/bin")) return "curl";
+	const checks = [
+		{
+			name: "npm",
+			test: () => {
+				try {
+					return execSync("npm list -g --depth=0 2>/dev/null", { encoding: "utf-8" }).includes(NPM_PACKAGE);
+				} catch {
+					return false;
+				}
+			}
+		},
+		{
+			name: "pnpm",
+			test: () => {
+				try {
+					return execSync("pnpm list -g --depth=0 2>/dev/null", { encoding: "utf-8" }).includes(NPM_PACKAGE);
+				} catch {
+					return false;
+				}
+			}
+		},
+		{
+			name: "bun",
+			test: () => {
+				try {
+					return execSync("bun pm ls -g 2>/dev/null", { encoding: "utf-8" }).includes(NPM_PACKAGE);
+				} catch {
+					return false;
+				}
+			}
+		},
+		{
+			name: "brew",
+			test: () => {
+				try {
+					execSync("brew list --formula offworld 2>/dev/null", { encoding: "utf-8" });
+					return true;
+				} catch {
+					return false;
+				}
+			}
+		}
+	];
+	if (execPath.includes("npm")) {
+		if (checks.find((c) => c.name === "npm")?.test()) return "npm";
+	}
+	if (execPath.includes("pnpm")) {
+		if (checks.find((c) => c.name === "pnpm")?.test()) return "pnpm";
+	}
+	if (execPath.includes("bun")) {
+		if (checks.find((c) => c.name === "bun")?.test()) return "bun";
+	}
+	if (execPath.includes("Cellar") || execPath.includes("homebrew")) {
+		if (checks.find((c) => c.name === "brew")?.test()) return "brew";
+	}
+	for (const check of checks) if (check.test()) return check.name;
+	return "unknown";
+}
+/**
+* Get current installed version
+*/
+function getCurrentVersion() {
+	return VERSION;
+}
+/**
+* Fetch latest version from appropriate source
+*/
+async function fetchLatestVersion(method) {
+	const installMethod = method ?? detectInstallMethod();
+	try {
+		if (installMethod === "npm" || installMethod === "pnpm" || installMethod === "bun") {
+			const response = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`);
+			if (!response.ok) return null;
+			return (await response.json()).version ?? null;
+		}
+		const response = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, { headers: {
+			Accept: "application/vnd.github.v3+json",
+			"User-Agent": "offworld-cli"
+		} });
+		if (!response.ok) return null;
+		return (await response.json()).tag_name?.replace(/^v/, "") ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Execute upgrade for given method
+*/
+function executeUpgrade(method, version) {
+	return new Promise((resolve, reject) => {
+		let cmd;
+		let args;
+		switch (method) {
+			case "curl":
+				cmd = "bash";
+				args = ["-c", `curl -fsSL https://offworld.sh/install | VERSION=${version} bash`];
+				break;
+			case "npm":
+				cmd = "npm";
+				args = [
+					"install",
+					"-g",
+					`${NPM_PACKAGE}@${version}`
+				];
+				break;
+			case "pnpm":
+				cmd = "pnpm";
+				args = [
+					"install",
+					"-g",
+					`${NPM_PACKAGE}@${version}`
+				];
+				break;
+			case "bun":
+				cmd = "bun";
+				args = [
+					"install",
+					"-g",
+					`${NPM_PACKAGE}@${version}`
+				];
+				break;
+			case "brew":
+				cmd = "brew";
+				args = ["upgrade", "offworld"];
+				break;
+			default:
+				reject(/* @__PURE__ */ new Error(`Cannot upgrade: unknown installation method`));
+				return;
+		}
+		const proc = spawn(cmd, args, { stdio: "inherit" });
+		proc.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`Upgrade failed with exit code ${code}`));
+		});
+		proc.on("error", reject);
+	});
+}
+/**
+* Execute uninstall for given method
+*/
+function executeUninstall(method) {
+	return new Promise((resolve, reject) => {
+		let cmd;
+		let args;
+		switch (method) {
+			case "curl":
+				try {
+					const binPath = join(homedir(), ".local", "bin", "ow");
+					if (existsSync(binPath)) execSync(`rm -f "${binPath}"`, { stdio: "inherit" });
+					resolve();
+				} catch (err) {
+					reject(err);
+				}
+				return;
+			case "npm":
+				cmd = "npm";
+				args = [
+					"uninstall",
+					"-g",
+					NPM_PACKAGE
+				];
+				break;
+			case "pnpm":
+				cmd = "pnpm";
+				args = [
+					"uninstall",
+					"-g",
+					NPM_PACKAGE
+				];
+				break;
+			case "bun":
+				cmd = "bun";
+				args = [
+					"remove",
+					"-g",
+					NPM_PACKAGE
+				];
+				break;
+			case "brew":
+				cmd = "brew";
+				args = ["uninstall", "offworld"];
+				break;
+			default:
+				reject(/* @__PURE__ */ new Error(`Cannot uninstall: unknown installation method`));
+				return;
+		}
+		const proc = spawn(cmd, args, { stdio: "inherit" });
+		proc.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`Uninstall failed with exit code ${code}`));
+		});
+		proc.on("error", reject);
+	});
+}
+/**
+* Get shell config files to clean
+*/
+function getShellConfigFiles() {
+	const home = homedir();
+	const configs = [];
+	for (const file of [
+		".bashrc",
+		".bash_profile",
+		".profile",
+		".zshrc",
+		".zshenv",
+		".config/fish/config.fish"
+	]) {
+		const path = join(home, file);
+		if (existsSync(path)) configs.push(path);
+	}
+	return configs;
+}
+/**
+* Clean PATH entries from shell config
+*/
+function cleanShellConfig(filePath) {
+	try {
+		const lines = readFileSync(filePath, "utf-8").split("\n");
+		const filtered = [];
+		let modified = false;
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (trimmed.includes(".local/bin") && (trimmed.startsWith("export PATH=") || trimmed.startsWith("fish_add_path"))) {
+				if (trimmed.includes("# offworld") || trimmed === "export PATH=\"$HOME/.local/bin:$PATH\"") {
+					modified = true;
+					continue;
+				}
+			}
+			filtered.push(line);
+		}
+		if (modified) writeFileSync(filePath, filtered.join("\n"), "utf-8");
+		return modified;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { AuthError, AuthenticationError, CloneError, CommitExistsError, CommitNotFoundError, ConflictError, DEFAULT_IGNORE_PATTERNS, GitError, GitHubError, InvalidInputError, InvalidReferenceError, KNOWN_MAPPINGS, LowStarsError, NetworkError, NotGitRepoError, NotLoggedInError, OpenCodeSDKError, PathNotFoundError, Paths, PrivateRepoError, PushNotAllowedError, RateLimitError, RepoExistsError, RepoNotFoundError, RepoSourceError, SyncError, RepoNotFoundError$1 as SyncRepoNotFoundError, TokenExpiredError, VERSION, agents, appendReferencesSection, canPushToWeb, checkRemote, checkRemoteByName, checkStaleness, cleanShellConfig, clearAuthData, cloneRepo, detectInstallMethod, detectInstalledAgents, detectManifestType, discoverRepos, executeUninstall, executeUpgrade, expandTilde, fetchGitHubMetadata, fetchLatestVersion, fetchRepoStars, gcRepos, generateReferenceWithAI, getAgentConfig, getAllAgentConfigs, getAuthPath, getAuthStatus, getClonedRepoPath, getCommitDistance, getCommitSha, getConfigPath, getCurrentVersion, getMapEntry, getMetaPath, getMetaRoot, getProjectMapPath, getProvider, getReferenceFileNameForSource, getReferencePath, getRepoPath, getRepoRoot, getRepoStatus, getShellConfigFiles, getToken, getTokenOrNull, installGlobalSkill, installReference, isLoggedIn, isReferenceInstalled, isRepoCloned, isShallowClone, listProviders, listProvidersWithModels, listRepos, loadAuthData, loadConfig, matchDependenciesToReferences, parseDependencies, parseRepoInput, pruneRepos, pullReference, pullReferenceByName, pushReference, readGlobalMap, refreshAccessToken, removeGlobalMapEntry, removeRepo, resolveDependencyRepo, resolveFromNpm, resolveRepoKey, saveAuthData, saveConfig, searchMap, streamPrompt, toMetaDirName, toReferenceFileName, toReferenceName, unshallowRepo, updateAgentFiles, updateAllRepos, updateRepo, upsertGlobalMapEntry, validateProviderModel, validatePushAllowed, writeGlobalMap, writeProjectMap };
+//# sourceMappingURL=index.mjs.map