@offworld/sdk 0.2.2 → 0.3.0

package/dist/public-DbZeh2Mr.mjs

@@ -0,0 +1,1823 @@
+import { f as Paths, l as toMetaDirName, o as getRepoRoot, p as expandTilde, s as loadConfig, u as toReferenceFileName } from "./config-DW8J4gl5.mjs";
+import { _ as upsertGlobalMapEntry, g as removeGlobalMapEntry, h as readGlobalMap, m as updateRepo, n as GitError, v as writeGlobalMap } from "./clone-DyLvmbJZ.mjs";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { ModelsDevDataSchema, NpmPackageResponseSchema, WorkOSTokenResponseSchema } from "@offworld/types";
+import { createHash } from "node:crypto";
+import { GlobalMapSchema as GlobalMapSchema$1, ProjectMapSchema as ProjectMapSchema$1 } from "@offworld/types/schemas";
+import { z } from "zod";
+
+//#region src/constants.ts
+/**
+* SDK Constants
+*/
+/** SDK version - must match package.json */
+const VERSION = "0.3.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/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/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/auth.ts
+/**
+* Authentication utilities for offworld CLI
+*/
+const AuthDataSchema = z.object({
+	token: z.string(),
+	expiresAt: z.string().optional(),
+	workosId: z.string().optional(),
+	refreshToken: z.string().optional(),
+	email: z.string().optional()
+});
+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";
+	}
+};
+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;
+	}
+}
+function getAuthPath() {
+	return Paths.authFile;
+}
+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 json = JSON.parse(content);
+		const parsed = AuthDataSchema.safeParse(json);
+		if (!parsed.success) return null;
+		return parsed.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;
+	}
+}
+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;
+	}
+}
+async function isLoggedIn() {
+	return await getTokenOrNull() !== null;
+}
+async function getAuthStatus() {
+	const data = loadAuthData();
+	if (!data) return { isLoggedIn: false };
+	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 {
+				const refreshed = await refreshAccessToken();
+				return {
+					isLoggedIn: true,
+					email: refreshed.email,
+					workosId: refreshed.workosId,
+					expiresAt: refreshed.expiresAt
+				};
+			} catch {
+				return { isLoggedIn: false };
+			}
+			return { isLoggedIn: false };
+		}
+		if (expiresAt.getTime() - now.getTime() < oneMinute) {
+			if (data.refreshToken) try {
+				const refreshed = await refreshAccessToken();
+				return {
+					isLoggedIn: true,
+					email: refreshed.email,
+					workosId: refreshed.workosId,
+					expiresAt: refreshed.expiresAt
+				};
+			} catch {
+				return {
+					isLoggedIn: true,
+					email: data.email,
+					workosId: data.workosId,
+					expiresAt: expiresAtStr
+				};
+			}
+		}
+	}
+	return {
+		isLoggedIn: true,
+		email: data.email,
+		workosId: data.workosId,
+		expiresAt: expiresAtStr
+	};
+}
+const WORKOS_API = "https://api.workos.com";
+const PRODUCTION_WORKOS_CLIENT_ID = "client_01KFAD76TNGN02AP96982HG35E";
+function getWorkosClientId() {
+	return process.env.WORKOS_CLIENT_ID ?? PRODUCTION_WORKOS_CLIENT_ID;
+}
+async function refreshAccessToken() {
+	const data = loadAuthData();
+	if (!data?.refreshToken) throw new AuthError("No refresh token available. Please log in again.");
+	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: getWorkosClientId()
+			})
+		});
+		if (!response.ok) throw new AuthError(`Token refresh failed: ${await response.text()}`);
+		const json = await response.json();
+		const tokenData = WorkOSTokenResponseSchema.parse(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/reference.ts
+const PackageJsonKeywordsSchema = z.object({
+	name: z.string().optional(),
+	keywords: z.array(z.string()).optional()
+});
+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 json = JSON.parse(content);
+		const parsed = PackageJsonKeywordsSchema.safeParse(json);
+		if (parsed.success) {
+			if (parsed.data.name) addKeywords(parsed.data.name);
+			if (parsed.data.keywords) for (const keyword of parsed.data.keywords) addKeywords(keyword);
+		}
+	} catch {}
+	return Array.from(keywords);
+}
+/**
+* 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
+
+Use \`ow\` to locate and read Offworld reference files for dependencies.
+
+## What This Does
+
+- Finds references for libraries and repos
+- Returns paths for reference files and local clones
+- Helps you read the right context fast
+
+## When to Use
+
+- You need docs or patterns for a dependency
+- You want the verified reference instead of web search
+- You are about to work inside a repo clone
+
+## Prerequisites
+
+Check that the CLI is available:
+
+\`\`\`bash
+ow --version
+\`\`\`
+
+If \`ow\` is not available, install it:
+
+\`\`\`bash
+curl -fsSL https://offworld.sh/install | bash
+\`\`\`
+
+## Setup
+
+Initialize Offworld once per machine:
+
+\`\`\`bash
+ow init
+\`\`\`
+
+For a specific project, build a project map:
+
+\`\`\`bash
+ow project init
+\`\`\`
+
+## 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
+\`\`\`
+
+## 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
+
+## Additional Resources
+
+- Docs: https://offworld.sh/cli
+`;
+/**
+* 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
+*/
+const DEFAULT_IGNORED_DIRS = new Set([
+	".git",
+	".offworld",
+	".turbo",
+	"build",
+	"dist",
+	"node_modules",
+	"out"
+]);
+/**
+* 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 parseNpmDependencies(dir);
+		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 [];
+	}
+}
+function parseNpmDependencies(dir) {
+	return mergeDependencies(parsePackageJson(join(dir, "package.json")), parseWorkspaceDependencies(dir)).sort((a, b) => a.name.localeCompare(b.name));
+}
+function parseWorkspaceDependencies(dir) {
+	const workspacePatterns = getWorkspacePatterns(dir);
+	if (workspacePatterns.length === 0) return [];
+	const packageJsonPaths = resolveWorkspacePackageJsonPaths(dir, workspacePatterns);
+	const deps = [];
+	for (const path of packageJsonPaths) deps.push(...parsePackageJson(path));
+	return mergeDependencies([], deps);
+}
+function getWorkspacePatterns(dir) {
+	const patterns = /* @__PURE__ */ new Set();
+	const packageJsonPath = join(dir, "package.json");
+	if (existsSync(packageJsonPath)) {
+		const workspaces = readJson(packageJsonPath)?.workspaces;
+		if (Array.isArray(workspaces)) {
+			for (const pattern of workspaces) if (typeof pattern === "string") patterns.add(pattern);
+		} else if (workspaces && typeof workspaces === "object") {
+			const packagesField = workspaces.packages;
+			if (Array.isArray(packagesField)) {
+				for (const pattern of packagesField) if (typeof pattern === "string") patterns.add(pattern);
+			}
+		}
+	}
+	const pnpmWorkspacePath = existsSync(join(dir, "pnpm-workspace.yaml")) ? join(dir, "pnpm-workspace.yaml") : existsSync(join(dir, "pnpm-workspace.yml")) ? join(dir, "pnpm-workspace.yml") : null;
+	if (pnpmWorkspacePath) for (const pattern of parsePnpmWorkspacePackages(pnpmWorkspacePath)) patterns.add(pattern);
+	return Array.from(patterns);
+}
+function resolveWorkspacePackageJsonPaths(dir, patterns) {
+	const includePatterns = patterns.filter((pattern) => !pattern.startsWith("!"));
+	const excludePatterns = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+	if (includePatterns.length === 0) return [];
+	const includeRegexes = includePatterns.map(patternToRegex);
+	const excludeRegexes = excludePatterns.map(patternToRegex);
+	const matches = [];
+	const directories = walkDirectories(dir);
+	for (const relativePath of directories) {
+		if (!includeRegexes.some((regex) => regex.test(relativePath))) continue;
+		if (excludeRegexes.some((regex) => regex.test(relativePath))) continue;
+		const packageJsonPath = join(dir, relativePath, "package.json");
+		if (existsSync(packageJsonPath)) matches.push(packageJsonPath);
+	}
+	return Array.from(new Set(matches));
+}
+function walkDirectories(root) {
+	const results = [];
+	const stack = [""];
+	while (stack.length > 0) {
+		const relativePath = stack.pop();
+		const currentPath = relativePath ? join(root, relativePath) : root;
+		let entries;
+		try {
+			entries = readdirSync(currentPath, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			if (DEFAULT_IGNORED_DIRS.has(entry.name)) continue;
+			const nextRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+			results.push(nextRelative);
+			stack.push(nextRelative);
+		}
+	}
+	return results;
+}
+function patternToRegex(pattern) {
+	let normalized = pattern.trim().replace(/\\/g, "/");
+	if (normalized.startsWith("./")) normalized = normalized.slice(2);
+	if (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+	const withGlob = normalized.replace(/[.+^${}()|[\]\\*]/g, "\\$&").replace(/\\\*\\\*/g, ".*").replace(/\\\*/g, "[^/]+");
+	return new RegExp(`^${withGlob}$`);
+}
+function parsePnpmWorkspacePackages(path) {
+	try {
+		const lines = readFileSync(path, "utf-8").split("\n");
+		const patterns = [];
+		let inPackages = false;
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			if (/^packages\s*:/.test(trimmed)) {
+				inPackages = true;
+				continue;
+			}
+			if (!inPackages) continue;
+			const entryMatch = trimmed.match(/^-\s*(.+)$/);
+			if (entryMatch?.[1]) {
+				const value = entryMatch[1].trim().replace(/^['"]|['"]$/g, "");
+				if (value) patterns.push(value);
+				continue;
+			}
+			if (!line.startsWith(" ") && !line.startsWith("	")) break;
+		}
+		return patterns;
+	} catch {
+		return [];
+	}
+}
+function readJson(path) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+function mergeDependencies(base, incoming) {
+	const map = /* @__PURE__ */ new Map();
+	for (const dep of [...base, ...incoming]) {
+		const existing = map.get(dep.name);
+		if (!existing) {
+			map.set(dep.name, { ...dep });
+			continue;
+		}
+		const dev = existing.dev && dep.dev;
+		const version = existing.version ?? dep.version;
+		map.set(dep.name, {
+			name: dep.name,
+			version,
+			dev
+		});
+	}
+	return Array.from(map.values());
+}
+/**
+* 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
+		});
+		if (pkg.peerDependencies && typeof pkg.peerDependencies === "object") for (const [name, version] of Object.entries(pkg.peerDependencies)) deps.push({
+			name,
+			version,
+			dev: false
+		});
+		if (pkg.optionalDependencies && typeof pkg.optionalDependencies === "object") for (const [name, version] of Object.entries(pkg.optionalDependencies)) deps.push({
+			name,
+			version,
+			dev: false
+		});
+		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
+/**
+* Dependency name to GitHub repo resolution:
+* 1. Query npm registry for repository.url
+* 2. Fall back to FALLBACK_MAPPINGS for packages missing repository field
+* 3. Return unknown (caller handles)
+*/
+/**
+* Fallback mappings for packages where npm registry doesn't have repository.url.
+* Only add packages here that genuinely don't have the field set.
+*/
+const FALLBACK_MAPPINGS = {
+	"@convex-dev/react-query": "get-convex/convex-react-query",
+	"@opencode-ai/sdk": "anomalyco/opencode-sdk-js"
+};
+/**
+* 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 json = await res.json();
+		const result = NpmPackageResponseSchema.safeParse(json);
+		if (!result.success) return null;
+		const repoUrl = result.data.repository?.url;
+		if (!repoUrl) return null;
+		return parseGitHubUrl(repoUrl);
+	} catch {
+		return null;
+	}
+}
+/**
+* Resolution order:
+* 1. Query npm registry for repository.url
+* 2. Check FALLBACK_MAPPINGS for packages missing repository field
+* 3. Return unknown
+*/
+async function resolveDependencyRepo(dep) {
+	const npmRepo = await resolveFromNpm(dep);
+	if (npmRepo) return {
+		dep,
+		repo: npmRepo,
+		source: "npm"
+	};
+	if (dep in FALLBACK_MAPPINGS) return {
+		dep,
+		repo: FALLBACK_MAPPINGS[dep] ?? null,
+		source: "fallback"
+	};
+	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, remote, 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/
+* - remote: Reference exists on offworld.sh (quick pull)
+* - generate: Has valid GitHub repo but needs AI generation (slow, uses tokens)
+* - unknown: No GitHub repo found
+*
+* @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: "generate",
+			source: dep.source
+		};
+	});
+}
+/**
+* Match dependencies to their reference availability status with remote check.
+* This is async because it checks the remote server for each dependency.
+*
+* Status logic:
+* - installed: {owner-repo}.md exists in offworld/references/
+* - remote: Reference exists on offworld.sh (quick pull)
+* - generate: Has valid GitHub repo but needs AI generation (slow, uses tokens)
+* - unknown: No GitHub repo found
+*
+* @param resolvedDeps - Array of resolved dependencies with repo info
+* @returns Promise of array of reference matches with status
+*/
+async function matchDependenciesToReferencesWithRemoteCheck(resolvedDeps) {
+	const { checkRemote } = await import("./sync-DuLJ5wla.mjs");
+	return await Promise.all(resolvedDeps.map(async (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
+		};
+		try {
+			if ((await checkRemote(dep.repo)).exists) return {
+				dep: dep.dep,
+				repo: dep.repo,
+				status: "remote",
+				source: dep.source
+			};
+		} catch {}
+		return {
+			dep: dep.dep,
+			repo: dep.repo,
+			status: "generate",
+			source: dep.source
+		};
+	}));
+}
+
+//#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}`);
+	const json = await res.json();
+	const parsed = ModelsDevDataSchema.safeParse(json);
+	if (!parsed.success) throw new Error(`Invalid models.dev response: ${parsed.error.message}`);
+	cachedData = parsed.data;
+	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 ?? false,
+			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 ?? false,
+			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
+export { getToken as A, NotGitRepoError as B, getAllAgentConfigs as C, clearAuthData as D, TokenExpiredError as E, saveAuthData as F, DEFAULT_IGNORE_PATTERNS as G, RepoSourceError as H, getMapEntry as I, VERSION as K, getProjectMapPath as L, isLoggedIn as M, loadAuthData as N, getAuthPath as O, refreshAccessToken as P, resolveRepoKey as R, getAgentConfig as S, NotLoggedInError as T, getReferenceFileNameForSource as U, PathNotFoundError as V, parseRepoInput as W, parseDependencies as _, discoverRepos as a, agents as b, pruneRepos as c, matchDependenciesToReferences as d, matchDependenciesToReferencesWithRemoteCheck as f, detectManifestType as g, resolveFromNpm as h, validateProviderModel as i, getTokenOrNull as j, getAuthStatus as k, updateAllRepos as l, resolveDependencyRepo as m, listProviders as n, gcRepos as o, FALLBACK_MAPPINGS as p, listProvidersWithModels as r, getRepoStatus as s, getProvider as t, isReferenceInstalled as u, installGlobalSkill as v, AuthError as w, detectInstalledAgents as x, installReference as y, searchMap as z };
+//# sourceMappingURL=public-DbZeh2Mr.mjs.map