headlesscode 1.0.2

package/src/vendor/zoo-code/src/services/roo-config/index.ts

@@ -0,0 +1,441 @@
+import * as path from "path"
+import * as os from "os"
+import fs from "fs/promises"
+
+/**
+ * Gets the GLOBAL shared-config directory used for the mode-agnostic rules
+ * (`<dir>/rules/`) and per-mode rules (`<dir>/rules-<mode>/`) that
+ * `addCustomInstructions()` scans (see src/core/prompts/sections/
+ * custom-instructions.ts).
+ *
+ * DELIBERATE DEVIATION FROM THE VENDORED UPSTREAM: upstream returns
+ * `~/.roo` (the Zoo-Code-branded location). headlesscode relocated the global
+ * shared instructions to its own native data location,
+ * `~/.local/share/headlesscode/shared/` (see src/project-store.ts), to
+ * complete the decoupling from Zoo Code as a tool — the file FORMAT and the
+ * rules-directory-scanning convention are unchanged, only the lookup path
+ * moved. Project-local `.roo/rules(-<mode>)/` is untouched (the project dir
+ * still wins on any overlap).
+ *
+ * @returns The absolute path to the global shared-instructions directory:
+ *          `~/.local/share/headlesscode/shared` on macOS/Linux
+ */
+export function getGlobalRooDirectory(): string {
+	const homeDir = os.homedir()
+	return path.join(homeDir, ".local", "share", "headlesscode", "shared")
+}
+
+/**
+ * Gets the global .agents directory path based on the current platform.
+ * This is a shared directory for agent skills across different AI coding tools.
+ *
+ * @returns The absolute path to the global .agents directory
+ *
+ * @example Platform-specific paths:
+ * ```
+ * // macOS/Linux: ~/.agents/
+ * // Example: /Users/john/.agents
+ *
+ * // Windows: %USERPROFILE%\.agents\
+ * // Example: C:\Users\john\.agents
+ * ```
+ *
+ * @example Usage:
+ * ```typescript
+ * const globalAgentsDir = getGlobalAgentsDirectory()
+ * // Returns: "/Users/john/.agents" (on macOS/Linux)
+ * // Returns: "C:\\Users\\john\\.agents" (on Windows)
+ * ```
+ */
+export function getGlobalAgentsDirectory(): string {
+	const homeDir = os.homedir()
+	return path.join(homeDir, ".agents")
+}
+
+/**
+ * Gets the project-local .agents directory path for a given cwd.
+ * This is a shared directory for agent skills across different AI coding tools.
+ *
+ * @param cwd - Current working directory (project path)
+ * @returns The absolute path to the project-local .agents directory
+ *
+ * @example
+ * ```typescript
+ * const projectAgentsDir = getProjectAgentsDirectoryForCwd('/Users/john/my-project')
+ * // Returns: "/Users/john/my-project/.agents"
+ * ```
+ */
+export function getProjectAgentsDirectoryForCwd(cwd: string): string {
+	return path.join(cwd, ".agents")
+}
+
+/**
+ * Gets the project-local .roo directory path for a given cwd
+ *
+ * @param cwd - Current working directory (project path)
+ * @returns The absolute path to the project-local .roo directory
+ *
+ * @example
+ * ```typescript
+ * const projectDir = getProjectRooDirectoryForCwd('/Users/john/my-project')
+ * // Returns: "/Users/john/my-project/.roo"
+ *
+ * const windowsProjectDir = getProjectRooDirectoryForCwd('C:\\Users\\john\\my-project')
+ * // Returns: "C:\\Users\\john\\my-project\\.roo"
+ * ```
+ *
+ * @example Directory structure:
+ * ```
+ * /Users/john/my-project/
+ * ├── .roo/                    # Project-local configuration directory
+ * │   ├── rules/
+ * │   │   └── rules.md
+ * │   ├── custom-instructions.md
+ * │   └── config/
+ * │       └── settings.json
+ * ├── src/
+ * │   └── index.ts
+ * └── package.json
+ * ```
+ */
+export function getProjectRooDirectoryForCwd(cwd: string): string {
+	return path.join(cwd, ".roo")
+}
+
+/**
+ * Checks if a directory exists
+ */
+export async function directoryExists(dirPath: string): Promise<boolean> {
+	try {
+		const stat = await fs.stat(dirPath)
+		return stat.isDirectory()
+	} catch (error: any) {
+		// Only catch expected "not found" errors
+		if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+			return false
+		}
+		// Re-throw unexpected errors (permission, I/O, etc.)
+		throw error
+	}
+}
+
+/**
+ * Checks if a file exists
+ */
+export async function fileExists(filePath: string): Promise<boolean> {
+	try {
+		const stat = await fs.stat(filePath)
+		return stat.isFile()
+	} catch (error: any) {
+		// Only catch expected "not found" errors
+		if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+			return false
+		}
+		// Re-throw unexpected errors (permission, I/O, etc.)
+		throw error
+	}
+}
+
+/**
+ * Reads a file safely, returning null if it doesn't exist
+ */
+export async function readFileIfExists(filePath: string): Promise<string | null> {
+	try {
+		return await fs.readFile(filePath, "utf-8")
+	} catch (error: any) {
+		// Only catch expected "not found" errors
+		if (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EISDIR") {
+			return null
+		}
+		// Re-throw unexpected errors (permission, I/O, etc.)
+		throw error
+	}
+}
+
+/**
+ * Discovers all .roo directories in subdirectories of the workspace
+ *
+ * @param cwd - Current working directory (workspace root)
+ * @returns Array of absolute paths to .roo directories found in subdirectories,
+ *          sorted alphabetically. Does not include the root .roo directory.
+ *
+ * @example
+ * ```typescript
+ * const subfolderRoos = await discoverSubfolderRooDirectories('/Users/john/monorepo')
+ * // Returns:
+ * // [
+ * //   '/Users/john/monorepo/package-a/.roo',
+ * //   '/Users/john/monorepo/package-b/.roo',
+ * //   '/Users/john/monorepo/packages/shared/.roo'
+ * // ]
+ * ```
+ *
+ * @example Directory structure:
+ * ```
+ * /Users/john/monorepo/
+ * ├── .roo/                    # Root .roo (NOT included - use getProjectRooDirectoryForCwd)
+ * ├── package-a/
+ * │   └── .roo/                # Included
+ * │       └── rules/
+ * ├── package-b/
+ * │   └── .roo/                # Included
+ * │       └── rules-code/
+ * └── packages/
+ *     └── shared/
+ *         └── .roo/            # Included (nested)
+ *             └── rules/
+ * ```
+ */
+export async function discoverSubfolderRooDirectories(cwd: string): Promise<string[]> {
+	try {
+		// Dynamic import to avoid vscode dependency at module load time
+		// This is necessary because file-search.ts imports vscode, which is not
+		// available in the webview context
+		const { executeRipgrep } = await import("../search/file-search")
+
+		// Use ripgrep to find any file inside any .roo directory
+		// This efficiently discovers all .roo folders regardless of their content
+		const args = [
+			"--files",
+			"--hidden",
+			"--follow",
+			"-g",
+			"**/.roo/**",
+			"-g",
+			"!node_modules/**",
+			"-g",
+			"!.git/**",
+			cwd,
+		]
+
+		const results = await executeRipgrep({ args, workspacePath: cwd })
+
+		// Extract unique .roo directory paths
+		const rooDirs = new Set<string>()
+		const rootRooDir = path.join(cwd, ".roo")
+
+		for (const result of results) {
+			// Match paths like "subfolder/.roo/anything" or "subfolder/nested/.roo/anything"
+			// Handle both forward slashes (Unix) and backslashes (Windows)
+			const match = result.path.match(/^(.+?)[/\\]\.roo[/\\]/)
+			if (match) {
+				const rooDir = path.join(cwd, match[1], ".roo")
+				// Exclude the root .roo directory (already handled by getProjectRooDirectoryForCwd)
+				if (rooDir !== rootRooDir) {
+					rooDirs.add(rooDir)
+				}
+			}
+		}
+
+		// Return sorted alphabetically
+		return Array.from(rooDirs).sort()
+	} catch (error) {
+		// If discovery fails (e.g., ripgrep not available), return empty array
+		return []
+	}
+}
+
+/**
+ * Gets the ordered list of .roo directories to check (global first, then project-local)
+ *
+ * @param cwd - Current working directory (project path)
+ * @returns Array of directory paths to check in order [global, project-local]
+ *
+ * @example
+ * ```typescript
+ * // For a project at /Users/john/my-project
+ * const directories = getRooDirectoriesForCwd('/Users/john/my-project')
+ * // Returns:
+ * // [
+ * //   '/Users/john/.roo',           // Global directory
+ * //   '/Users/john/my-project/.roo' // Project-local directory
+ * // ]
+ * ```
+ *
+ * @example Directory structure:
+ * ```
+ * /Users/john/
+ * ├── .roo/                    # Global configuration
+ * │   ├── rules/
+ * │   │   └── rules.md
+ * │   └── custom-instructions.md
+ * └── my-project/
+ *     ├── .roo/                # Project-specific configuration
+ *     │   ├── rules/
+ *     │   │   └── rules.md     # Overrides global rules
+ *     │   └── project-notes.md
+ *     └── src/
+ *         └── index.ts
+ * ```
+ */
+export function getRooDirectoriesForCwd(cwd: string): string[] {
+	const directories: string[] = []
+
+	// Add global directory first
+	directories.push(getGlobalRooDirectory())
+
+	// Add project-local directory second
+	directories.push(getProjectRooDirectoryForCwd(cwd))
+
+	return directories
+}
+
+/**
+ * Gets the ordered list of all .roo directories including subdirectories
+ *
+ * @param cwd - Current working directory (project path)
+ * @returns Array of directory paths in order: [global, project-local, ...subfolders (alphabetically)]
+ *
+ * @example
+ * ```typescript
+ * // For a monorepo at /Users/john/monorepo with .roo in subfolders
+ * const directories = await getAllRooDirectoriesForCwd('/Users/john/monorepo')
+ * // Returns:
+ * // [
+ * //   '/Users/john/.roo',                    // Global directory
+ * //   '/Users/john/monorepo/.roo',           // Project-local directory
+ * //   '/Users/john/monorepo/package-a/.roo', // Subfolder (alphabetical)
+ * //   '/Users/john/monorepo/package-b/.roo'  // Subfolder (alphabetical)
+ * // ]
+ * ```
+ */
+export async function getAllRooDirectoriesForCwd(cwd: string): Promise<string[]> {
+	const directories: string[] = []
+
+	// Add global directory first
+	directories.push(getGlobalRooDirectory())
+
+	// Add project-local directory second
+	directories.push(getProjectRooDirectoryForCwd(cwd))
+
+	// Discover and add subfolder .roo directories
+	const subfolderDirs = await discoverSubfolderRooDirectories(cwd)
+	directories.push(...subfolderDirs)
+
+	return directories
+}
+
+/**
+ * Gets parent directories containing .roo folders, in order from root to subfolders
+ *
+ * @param cwd - Current working directory (project path)
+ * @returns Array of parent directory paths (not .roo paths) containing AGENTS.md or .roo
+ *
+ * @example
+ * ```typescript
+ * const dirs = await getAgentsDirectoriesForCwd('/Users/john/monorepo')
+ * // Returns: ['/Users/john/monorepo', '/Users/john/monorepo/package-a', ...]
+ * ```
+ */
+export async function getAgentsDirectoriesForCwd(cwd: string): Promise<string[]> {
+	const directories: string[] = []
+
+	// Always include the root directory
+	directories.push(cwd)
+
+	// Get all subfolder .roo directories
+	const subfolderRooDirs = await discoverSubfolderRooDirectories(cwd)
+
+	// Extract parent directories (remove .roo from path)
+	for (const rooDir of subfolderRooDirs) {
+		const parentDir = path.dirname(rooDir)
+		directories.push(parentDir)
+	}
+
+	return directories
+}
+
+/**
+ * Loads configuration from multiple .roo directories with project overriding global
+ *
+ * @param relativePath - The relative path within each .roo directory (e.g., 'rules/rules.md')
+ * @param cwd - Current working directory (project path)
+ * @returns Object with global and project content, plus merged content
+ *
+ * @example
+ * ```typescript
+ * // Load rules configuration for a project
+ * const config = await loadConfiguration('rules/rules.md', '/Users/john/my-project')
+ *
+ * // Returns:
+ * // {
+ * //   global: "Global rules content...",     // From ~/.roo/rules/rules.md
+ * //   project: "Project rules content...",   // From /Users/john/my-project/.roo/rules/rules.md
+ * //   merged: "Global rules content...\n\n# Project-specific rules (override global):\n\nProject rules content..."
+ * // }
+ * ```
+ *
+ * @example File paths resolved:
+ * ```
+ * relativePath: 'rules/rules.md'
+ * cwd: '/Users/john/my-project'
+ *
+ * Reads from:
+ * - Global: /Users/john/.roo/rules/rules.md
+ * - Project: /Users/john/my-project/.roo/rules/rules.md
+ *
+ * Other common relativePath examples:
+ * - 'custom-instructions.md'
+ * - 'config/settings.json'
+ * - 'templates/component.tsx'
+ * ```
+ *
+ * @example Merging behavior:
+ * ```
+ * // If only global exists:
+ * { global: "content", project: null, merged: "content" }
+ *
+ * // If only project exists:
+ * { global: null, project: "content", merged: "content" }
+ *
+ * // If both exist:
+ * {
+ *   global: "global content",
+ *   project: "project content",
+ *   merged: "global content\n\n# Project-specific rules (override global):\n\nproject content"
+ * }
+ * ```
+ */
+export async function loadConfiguration(
+	relativePath: string,
+	cwd: string,
+): Promise<{
+	global: string | null
+	project: string | null
+	merged: string
+}> {
+	const globalDir = getGlobalRooDirectory()
+	const projectDir = getProjectRooDirectoryForCwd(cwd)
+
+	const globalFilePath = path.join(globalDir, relativePath)
+	const projectFilePath = path.join(projectDir, relativePath)
+
+	// Read global configuration
+	const globalContent = await readFileIfExists(globalFilePath)
+
+	// Read project-local configuration
+	const projectContent = await readFileIfExists(projectFilePath)
+
+	// Merge configurations - project overrides global
+	let merged = ""
+
+	if (globalContent) {
+		merged += globalContent
+	}
+
+	if (projectContent) {
+		if (merged) {
+			merged += "\n\n# Project-specific rules (override global):\n\n"
+		}
+		merged += projectContent
+	}
+
+	return {
+		global: globalContent,
+		project: projectContent,
+		merged: merged || "",
+	}
+}
+
+// Export with backward compatibility alias
+export const loadRooConfiguration: typeof loadConfiguration = loadConfiguration

package/src/vendor/zoo-code/src/services/search/file-search.ts

@@ -0,0 +1,143 @@
+/**
+ * SHIM — replaces zoo-code/src/services/search/file-search.ts.
+ *
+ * The original shells out to ripgrep (`executeRipgrep`) to discover files by
+ * glob pattern. Two vendored call sites use it:
+ *   - `services/roo-config/index.ts#discoverSubfolderRooDirectories()`: finds
+ *     any file under a nested ".roo" directory, excluding node_modules and
+ *     ".git" (double-star glob, "-g" flags — see that file for the literal args).
+ *   - `services/checkpoints/ShadowCheckpointService.ts#getNestedGitRepository()`:
+ *     finds ".git" + "HEAD" pairs anywhere under the workspace (nested-repo
+ *     detection — see that file for the literal args).
+ *
+ * This shim implements the same `{ args, workspacePath } -> results` shape
+ * with pure Node `fs`, supporting the small glob subset both callers use
+ * (double-star, single-star, and "!"-prefixed excludes via repeated "-g"
+ * flags). Each result has `{ path, type }` (relative to `workspacePath`,
+ * forward-slash separated), matching the real ripgrep-backed
+ * implementation's `FileResult` shape closely enough for both callers (the
+ * checkpoints caller destructures `type`).
+ *
+ * To keep this bounded on real repos, directories named ".git" are not
+ * recursed into wholesale (that would walk the entire object store) —
+ * instead only their "HEAD" file is checked directly, and "node_modules"
+ * directories are never recursed into. Both are reasonable defaults for the
+ * two callers above, which either exclude these directories explicitly or
+ * (in the checkpoints case) only ever care about a top-level "HEAD" file.
+ */
+
+import * as fs from "fs/promises"
+import * as path from "path"
+
+export interface RipgrepResult {
+	path: string
+	type: "file" | "folder"
+}
+
+function globToRegex(glob: string): RegExp {
+	let re = ""
+	for (let i = 0; i < glob.length; i++) {
+		const c = glob[i]
+		if (c === "*") {
+			if (glob[i + 1] === "*") {
+				re += ".*"
+				i++
+				if (glob[i + 1] === "/") {
+					i++
+				}
+			} else {
+				re += "[^/]*"
+			}
+		} else if ("+.^${}()|[]\\".includes(c)) {
+			re += "\\" + c
+		} else {
+			re += c
+		}
+	}
+	return new RegExp(`^${re}$`)
+}
+
+function parsePatterns(args: string[]): { include: RegExp[]; exclude: RegExp[] } {
+	const include: RegExp[] = []
+	const exclude: RegExp[] = []
+
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "-g" && args[i + 1] !== undefined) {
+			const pattern = args[i + 1]
+			if (pattern.startsWith("!")) {
+				exclude.push(globToRegex(pattern.slice(1)))
+			} else {
+				include.push(globToRegex(pattern))
+			}
+			i++
+		}
+	}
+
+	return { include, exclude }
+}
+
+export async function executeRipgrep({
+	args,
+	workspacePath,
+}: {
+	args: string[]
+	workspacePath: string
+}): Promise<RipgrepResult[]> {
+	const { include, exclude } = parsePatterns(args)
+	const results: RipgrepResult[] = []
+
+	const isExcluded = (relPath: string, isDir: boolean) => {
+		const candidates = isDir ? [relPath, `${relPath}/`] : [relPath]
+		return exclude.some((re) => candidates.some((c) => re.test(c)))
+	}
+
+	const matchesInclude = (relPath: string) => include.length === 0 || include.some((re) => re.test(relPath))
+
+	async function walk(dir: string, relative: string): Promise<void> {
+		let entries: import("fs").Dirent[]
+
+		try {
+			entries = await fs.readdir(dir, { withFileTypes: true })
+		} catch {
+			return
+		}
+
+		for (const entry of entries) {
+			const entryRelative = relative ? `${relative}/${entry.name}` : entry.name
+
+			if (entry.isDirectory()) {
+				if (entry.name === "node_modules" || isExcluded(entryRelative, true)) {
+					continue
+				}
+
+				if (entry.name === ".git") {
+					// Don't walk the object store; only surface HEAD, mirroring what
+					// the checkpoints caller's `**/.git/HEAD` pattern is looking for.
+					const headRelative = `${entryRelative}/HEAD`
+					const headAbsolute = path.join(dir, entry.name, "HEAD")
+
+					try {
+						const stat = await fs.stat(headAbsolute)
+
+						if (stat.isFile() && matchesInclude(headRelative) && !isExcluded(headRelative, false)) {
+							results.push({ path: headRelative, type: "file" })
+						}
+					} catch {
+						// No HEAD file — not a real git dir, nothing to report.
+					}
+
+					continue
+				}
+
+				await walk(path.join(dir, entry.name), entryRelative)
+			} else if (entry.isFile()) {
+				if (matchesInclude(entryRelative) && !isExcluded(entryRelative, false)) {
+					results.push({ path: entryRelative, type: "file" })
+				}
+			}
+		}
+	}
+
+	await walk(workspacePath, "")
+	return results
+}

package/src/vendor/zoo-code/src/services/skills/SkillsManager.ts

@@ -0,0 +1,20 @@
+/**
+ * SHIM — replaces zoo-code/src/services/skills/SkillsManager.ts.
+ *
+ * The real SkillsManager scans global/project skills directories. The vendored
+ * `core/prompts/sections/skills.ts` only reads `getSkillsForMode(mode)`, which
+ * this stub satisfies with an empty list (no skills registered headlessly).
+ * Skill loading is out of scope for Phase 1.
+ */
+
+export interface SkillLike {
+	name: string
+	description: string
+	path: string
+}
+
+export class SkillsManager {
+	getSkillsForMode(_mode: string): SkillLike[] {
+		return []
+	}
+}

package/src/vendor/zoo-code/src/shared/globalFileNames.ts

@@ -0,0 +1,9 @@
+export const GlobalFileNames = {
+	apiConversationHistory: "api_conversation_history.json",
+	uiMessages: "ui_messages.json",
+	mcpSettings: "mcp_settings.json",
+	customModes: "custom_modes.yaml",
+	taskMetadata: "task_metadata.json",
+	historyItem: "history_item.json",
+	historyIndex: "_index.json",
+}

package/src/vendor/zoo-code/src/shared/language.ts

@@ -0,0 +1,43 @@
+import { type Language, isLanguage } from "../../types"
+
+/**
+ * Language name mapping from ISO codes to full language names.
+ */
+
+export const LANGUAGES: Record<Language, string> = {
+	ca: "Català",
+	de: "Deutsch",
+	en: "English",
+	es: "Español",
+	fr: "Français",
+	hi: "हिन्दी",
+	id: "Bahasa Indonesia",
+	it: "Italiano",
+	ja: "日本語",
+	ko: "한국어",
+	nl: "Nederlands",
+	pl: "Polski",
+	"pt-BR": "Português",
+	ru: "Русский",
+	tr: "Türkçe",
+	vi: "Tiếng Việt",
+	"zh-CN": "简体中文",
+	"zh-TW": "繁體中文",
+}
+
+/**
+ * Formats a VSCode locale string to ensure the region code is uppercase.
+ * For example, transforms "en-us" to "en-US" or "fr-ca" to "fr-CA".
+ *
+ * @param vscodeLocale - The VSCode locale string to format (e.g., "en-us", "fr-ca")
+ * @returns The formatted locale string with uppercase region code
+ */
+
+export function formatLanguage(vscodeLocale: string): Language {
+	if (!vscodeLocale) {
+		return "en"
+	}
+
+	const formattedLocale = vscodeLocale.replace(/-(\w+)$/, (_, region) => `-${region.toUpperCase()}`)
+	return isLanguage(formattedLocale) ? formattedLocale : "en"
+}