@agenthippo-ai/agenthippo 0.1.0

package/out/utils.js

@@ -0,0 +1,915 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAnalyticsScriptsDir = void 0;
+exports.logInfo = logInfo;
+exports.getErrorCode = getErrorCode;
+exports.pathExists = pathExists;
+exports.isDirOrSymlink = isDirOrSymlink;
+exports.ensureRealDirectory = ensureRealDirectory;
+exports.writeFileIfChanged = writeFileIfChanged;
+exports.copyDirRecursive = copyDirRecursive;
+exports.copyDirRecursiveWithTransform = copyDirRecursiveWithTransform;
+exports.symlinkOrCopyFile = symlinkOrCopyFile;
+exports.syncDirByFileLinks = syncDirByFileLinks;
+exports.ensureWorkspaceGitAndGitignore = ensureWorkspaceGitAndGitignore;
+exports.readFileSha256 = readFileSha256;
+exports.getFileStats = getFileStats;
+exports.isCachedHashValid = isCachedHashValid;
+exports.shortSig = shortSig;
+exports.isLocalHttps = isLocalHttps;
+exports.applyLocalTlsBypass = applyLocalTlsBypass;
+exports.getOverrideOpenAIBaseUrl = getOverrideOpenAIBaseUrl;
+exports.resolveApiRouting = resolveApiRouting;
+exports.getExplicitConfigValue = getExplicitConfigValue;
+exports.getAgentideEngineSettings = getAgentideEngineSettings;
+exports.emitStreamEvent = emitStreamEvent;
+exports.createIPCStreamEmitter = createIPCStreamEmitter;
+exports.computeTextDelta = computeTextDelta;
+exports.createDeferred = createDeferred;
+exports.stableAdditionalDirs = stableAdditionalDirs;
+exports.extractFilePaths = extractFilePaths;
+exports.isCreateCommand = isCreateCommand;
+exports.normalizeFileChangeKind = normalizeFileChangeKind;
+exports.isBinaryFile = isBinaryFile;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const promises_1 = require("stream/promises");
+const util_1 = require("util");
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const shared_1 = require("./shared");
+const branding_1 = require("./branding");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+// Lazy-load vscode to allow bundling for CLI/headless mode
+// Use eval to prevent Bun from statically analyzing the require
+let _vscode;
+function getVscode() {
+    if (!_vscode) {
+        try {
+            // eslint-disable-next-line no-eval
+            _vscode = eval('require')('vscode');
+        }
+        catch {
+            throw new Error('vscode module not available. Use ConfigProvider instead of vscode.workspace.getConfiguration');
+        }
+    }
+    return _vscode;
+}
+/** Helper to log a message using whichever method is available */
+function logInfo(logger, msg) {
+    if (logger.appendLine) {
+        logger.appendLine(msg);
+    }
+    else if (logger.info) {
+        logger.info(msg);
+    }
+}
+// -----------------------------------------------------------------------------
+// Error Handling
+// -----------------------------------------------------------------------------
+/**
+ * Extract error code from an unknown error object (e.g., Node.js fs errors).
+ */
+function getErrorCode(e) {
+    return e && typeof e === 'object' ? e.code : undefined;
+}
+// -----------------------------------------------------------------------------
+// File System Utilities
+// -----------------------------------------------------------------------------
+async function pathExists(targetPath) {
+    try {
+        await fs_1.promises.lstat(targetPath);
+        return true;
+    }
+    catch (e) {
+        if (getErrorCode(e) === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+}
+async function isDirOrSymlink(targetPath) {
+    try {
+        const stat = await fs_1.promises.lstat(targetPath);
+        return stat.isDirectory() || stat.isSymbolicLink();
+    }
+    catch (e) {
+        if (getErrorCode(e) === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+}
+async function ensureRealDirectory(dirPath) {
+    try {
+        const st = await fs_1.promises.lstat(dirPath);
+        if (st.isSymbolicLink() || !st.isDirectory()) {
+            await fs_1.promises.rm(dirPath, { recursive: true, force: true });
+            await fs_1.promises.mkdir(dirPath, { recursive: true });
+        }
+    }
+    catch (e) {
+        if (getErrorCode(e) === 'ENOENT') {
+            await fs_1.promises.mkdir(dirPath, { recursive: true });
+            return;
+        }
+        throw e;
+    }
+}
+async function writeFileIfChanged(targetFile, contents) {
+    try {
+        const existing = await fs_1.promises.readFile(targetFile, 'utf8');
+        if (existing === contents) {
+            return false;
+        }
+    }
+    catch (e) {
+        if (getErrorCode(e) !== 'ENOENT') {
+            throw e;
+        }
+    }
+    await fs_1.promises.mkdir(path.dirname(targetFile), { recursive: true });
+    await fs_1.promises.writeFile(targetFile, contents, 'utf8');
+    return true;
+}
+async function copyDirRecursive(sourceDir, targetDir) {
+    await fs_1.promises.mkdir(targetDir, { recursive: true });
+    const entries = await fs_1.promises.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = path.join(sourceDir, entry.name);
+        const dst = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(src, dst);
+        }
+        else if (entry.isFile()) {
+            await fs_1.promises.copyFile(src, dst);
+        }
+        else if (entry.isSymbolicLink()) {
+            // Best-effort: resolve and copy the link target as a file or directory.
+            const resolved = await fs_1.promises.readlink(src);
+            const resolvedAbs = path.isAbsolute(resolved)
+                ? resolved
+                : path.resolve(path.dirname(src), resolved);
+            const stat = await fs_1.promises.stat(resolvedAbs);
+            if (stat.isDirectory()) {
+                await copyDirRecursive(resolvedAbs, dst);
+            }
+            else {
+                await fs_1.promises.copyFile(resolvedAbs, dst);
+            }
+        }
+    }
+}
+/**
+ * Copy a directory recursively, applying a text transform to markdown files.
+ * Used for bundled skills that may contain branding tokens.
+ */
+async function copyDirRecursiveWithTransform(sourceDir, targetDir, transformMd) {
+    await fs_1.promises.mkdir(targetDir, { recursive: true });
+    const entries = await fs_1.promises.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = path.join(sourceDir, entry.name);
+        const dst = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursiveWithTransform(src, dst, transformMd);
+        }
+        else if (entry.isFile()) {
+            const lowerName = entry.name.toLowerCase();
+            if (lowerName.endsWith('.md')) {
+                // Apply transform to markdown files
+                const content = await fs_1.promises.readFile(src, 'utf8');
+                await fs_1.promises.writeFile(dst, transformMd(content), 'utf8');
+            }
+            else {
+                await fs_1.promises.copyFile(src, dst);
+            }
+        }
+        else if (entry.isSymbolicLink()) {
+            // Best-effort: resolve and copy the link target as a file or directory.
+            const resolved = await fs_1.promises.readlink(src);
+            const resolvedAbs = path.isAbsolute(resolved)
+                ? resolved
+                : path.resolve(path.dirname(src), resolved);
+            const stat = await fs_1.promises.stat(resolvedAbs);
+            if (stat.isDirectory()) {
+                await copyDirRecursiveWithTransform(resolvedAbs, dst, transformMd);
+            }
+            else {
+                const lowerName = entry.name.toLowerCase();
+                if (lowerName.endsWith('.md')) {
+                    const content = await fs_1.promises.readFile(resolvedAbs, 'utf8');
+                    await fs_1.promises.writeFile(dst, transformMd(content), 'utf8');
+                }
+                else {
+                    await fs_1.promises.copyFile(resolvedAbs, dst);
+                }
+            }
+        }
+    }
+}
+/**
+ * Create a symlink (or copy as fallback) to a file.
+ *
+ * @param force - If true, replace any existing file (for derived/managed files).
+ *                If false, only replace symlinks pointing elsewhere, never clobber non-symlinks (for user files).
+ */
+async function symlinkOrCopyFile(sourceFile, targetFile, logger, label, options) {
+    const force = options?.force ?? false;
+    // Check existing target
+    try {
+        const existing = await fs_1.promises.lstat(targetFile);
+        if (existing.isSymbolicLink()) {
+            // Check if already pointing to correct target
+            try {
+                const current = await fs_1.promises.readlink(targetFile);
+                const currentAbs = path.isAbsolute(current)
+                    ? current
+                    : path.resolve(path.dirname(targetFile), current);
+                if (path.resolve(currentAbs) === path.resolve(sourceFile)) {
+                    return; // Already correct, nothing to do
+                }
+            }
+            catch {
+                // Can't read link, fall through and replace it
+            }
+            await fs_1.promises.unlink(targetFile);
+        }
+        else if (force) {
+            // Force mode: replace any file type
+            await fs_1.promises.rm(targetFile, { recursive: true, force: true });
+        }
+        else {
+            // Preserve mode: don't clobber user-managed non-symlink files
+            return;
+        }
+    }
+    catch (e) {
+        if (getErrorCode(e) !== 'ENOENT') {
+            throw e;
+        }
+        // File doesn't exist, proceed to create
+    }
+    await fs_1.promises.mkdir(path.dirname(targetFile), { recursive: true });
+    if (path.resolve(sourceFile) === path.resolve(targetFile)) {
+        return;
+    }
+    try {
+        await fs_1.promises.symlink(sourceFile, targetFile, 'file');
+        logInfo(logger, `[AgentIDE] Linked ${label} (symlink): ${targetFile} -> ${sourceFile}`);
+    }
+    catch {
+        await fs_1.promises.copyFile(sourceFile, targetFile);
+        logInfo(logger, `[AgentIDE] Linked ${label} (copy fallback): ${targetFile}`);
+    }
+}
+/**
+ * Mirror a directory by creating **file symlinks** (with copy fallback) rather than directory symlinks.
+ * This avoids Git's "pathspec is beyond a symbolic link" failure mode (which triggers on directory symlinks).
+ *
+ * Notes:
+ * - Hidden entries (starting with ".") are ignored.
+ * - Non-symlink files in target that don't exist in source are copied back to source (preserves agent-created content).
+ * - Only stale symlinks are removed (symlinks pointing to files no longer in source).
+ */
+async function syncDirByFileLinks(sourceDir, targetDir, logger, label) {
+    await ensureRealDirectory(targetDir);
+    const expectedDirs = new Set();
+    const expectedFiles = new Map(); // relPath -> sourceAbs
+    const walk = async (absSrc, rel) => {
+        let entries;
+        try {
+            entries = await fs_1.promises.readdir(absSrc, { withFileTypes: true });
+        }
+        catch (e) {
+            if (getErrorCode(e) === 'ENOENT') {
+                return;
+            }
+            throw e;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+            const src = path.join(absSrc, entry.name);
+            const relPath = rel ? path.join(rel, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                expectedDirs.add(relPath);
+                await walk(src, relPath);
+            }
+            else if (entry.isFile()) {
+                expectedFiles.set(relPath, src);
+            }
+            else if (entry.isSymbolicLink()) {
+                // Best-effort: resolve and mirror the link target.
+                try {
+                    const resolved = await fs_1.promises.readlink(src);
+                    const resolvedAbs = path.isAbsolute(resolved)
+                        ? resolved
+                        : path.resolve(path.dirname(src), resolved);
+                    const stat = await fs_1.promises.stat(resolvedAbs);
+                    if (stat.isDirectory()) {
+                        expectedDirs.add(relPath);
+                        await walk(resolvedAbs, relPath);
+                    }
+                    else {
+                        expectedFiles.set(relPath, resolvedAbs);
+                    }
+                }
+                catch (e) {
+                    const code = getErrorCode(e);
+                    if (code === 'ENOENT' || code === 'ELOOP') {
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+        }
+    };
+    await walk(sourceDir, '');
+    // Ensure all directories exist (parents first).
+    const dirsByDepth = Array.from(expectedDirs).sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);
+    for (const relDir of dirsByDepth) {
+        await ensureRealDirectory(path.join(targetDir, relDir));
+    }
+    // Link files (force overwrite; derived dirs are AgentIDE-managed)
+    for (const [relFile, srcAbs] of expectedFiles.entries()) {
+        await symlinkOrCopyFile(srcAbs, path.join(targetDir, relFile), logger, `${label}/${relFile}`.replace(/\\/g, '/'), { force: true });
+    }
+    // Copy-back: copy non-symlink files from target to source if they don't exist in source.
+    // This preserves agent-created content (scripts, templates, etc.) in the source of truth.
+    const expectedFileSet = new Set(expectedFiles.keys());
+    const copyBack = async (absDst, relDst) => {
+        let entries;
+        try {
+            entries = await fs_1.promises.readdir(absDst, { withFileTypes: true });
+        }
+        catch (e) {
+            if (getErrorCode(e) === 'ENOENT') {
+                return;
+            }
+            throw e;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+            const absDstFile = path.join(absDst, entry.name);
+            const relPath = relDst ? path.join(relDst, entry.name) : entry.name;
+            const absSrcFile = path.join(sourceDir, relPath);
+            if (entry.isDirectory()) {
+                await copyBack(absDstFile, relPath);
+            }
+            else if (entry.isFile() && !entry.isSymbolicLink()) {
+                // Real file in target - check if it exists in source
+                if (!expectedFileSet.has(relPath)) {
+                    // File doesn't exist in source - copy it back
+                    try {
+                        await fs_1.promises.mkdir(path.dirname(absSrcFile), { recursive: true });
+                        await fs_1.promises.copyFile(absDstFile, absSrcFile);
+                        logInfo(logger, `[AgentIDE] Copied new file to source: ${label}/${relPath}`.replace(/\\/g, '/'));
+                        // Add to expected files so it becomes a symlink on next sync
+                        expectedFiles.set(relPath, absSrcFile);
+                    }
+                    catch (e) {
+                        logInfo(logger, `[AgentIDE] Warning: failed to copy back ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+            }
+        }
+    };
+    await copyBack(targetDir, '');
+    // Re-link any files we just copied back (convert them to symlinks)
+    for (const [relFile, srcAbs] of expectedFiles.entries()) {
+        const targetFile = path.join(targetDir, relFile);
+        try {
+            const stat = await fs_1.promises.lstat(targetFile);
+            // If it's a regular file (not symlink), replace with symlink
+            if (stat.isFile() && !stat.isSymbolicLink()) {
+                await fs_1.promises.rm(targetFile, { force: true });
+                await symlinkOrCopyFile(srcAbs, targetFile, logger, `${label}/${relFile}`.replace(/\\/g, '/'), { force: true });
+            }
+        }
+        catch {
+            // File doesn't exist, will be created by the link phase
+        }
+    }
+    // Cleanup: remove unexpected SYMLINK entries in target dir.
+    const cleanup = async (absDst, relDst) => {
+        let entries;
+        try {
+            entries = await fs_1.promises.readdir(absDst, { withFileTypes: true });
+        }
+        catch (e) {
+            if (getErrorCode(e) === 'ENOENT') {
+                return;
+            }
+            throw e;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+            const abs = path.join(absDst, entry.name);
+            const relPath = relDst ? path.join(relDst, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                // Recurse into directories to clean up symlinks inside
+                await cleanup(abs, relPath);
+                // Don't remove directories - they may contain user-added files
+            }
+            else if (entry.isSymbolicLink()) {
+                // Only remove symlinks that are no longer expected
+                if (!expectedFileSet.has(relPath)) {
+                    await fs_1.promises.rm(abs, { force: true });
+                }
+            }
+        }
+    };
+    await cleanup(targetDir, '');
+}
+/**
+ * Ensure workspace root has git initialized and .gitignore entries for agent directories.
+ * If the folder is not a git repository, runs `git init`.
+ * Adds the agent root, .claude, .codex to the root .gitignore if not already present.
+ */
+async function ensureWorkspaceGitAndGitignore(workspaceRoot, logger) {
+    const gitDir = path.join(workspaceRoot, '.git');
+    // Check if .git exists
+    const gitExists = await pathExists(gitDir);
+    if (!gitExists) {
+        // Initialize git repository
+        try {
+            await execFileAsync('git', ['init'], { cwd: workspaceRoot });
+            logInfo(logger, `[AgentIDE] Initialized git repository in ${workspaceRoot}`);
+        }
+        catch (e) {
+            logInfo(logger, `[AgentIDE] Note: Could not initialize git in ${workspaceRoot}: ${e instanceof Error ? e.message : String(e)}`);
+            // Continue anyway - we still want to create/update .gitignore
+        }
+    }
+    // Ensure root .gitignore has entries for agent directories
+    const rootGitignorePath = path.join(workspaceRoot, '.gitignore');
+    // Build the list of directories to ignore from AGENT_ENGINES
+    const agentideDirs = [
+        ...Object.values(shared_1.AGENT_ENGINES).map(engine => engine.workspaceDir),
+    ];
+    const managedBlockLines = [
+        `# ${branding_1.AGENTIDE_BRAND_NAME} (managed)`,
+        `# These directories are managed by ${branding_1.AGENTIDE_BRAND_NAME} and should not be committed.`,
+        ...agentideDirs,
+    ];
+    let existing = '';
+    try {
+        existing = await fs_1.promises.readFile(rootGitignorePath, 'utf8');
+    }
+    catch (e) {
+        if (getErrorCode(e) !== 'ENOENT') {
+            logInfo(logger, `[AgentIDE] Warning: failed to read root .gitignore: ${e instanceof Error ? e.message : String(e)}`);
+            return;
+        }
+    }
+    // Check if all required entries are already present (as standalone lines)
+    const existingLines = existing.split('\n').map(l => l.trim());
+    const missingDirs = agentideDirs.filter(dir => !existingLines.includes(dir));
+    if (missingDirs.length === 0) {
+        return;
+    }
+    // If we have the managed block header but missing some entries, rebuild the block
+    // Otherwise, append the full managed block
+    const managedHeader = `# ${branding_1.AGENTIDE_BRAND_NAME} (managed)`;
+    const legacyHeader = '# AgentIDE (managed)';
+    const hasHeader = existing.includes(managedHeader) || existing.includes(legacyHeader);
+    let next;
+    if (hasHeader) {
+        // Replace the managed block with updated entries
+        // Find the block and replace it
+        const lines = existing.split('\n');
+        const newLines = [];
+        let inManagedBlock = false;
+        for (const line of lines) {
+            if (line.trim() === managedHeader || line.trim() === legacyHeader) {
+                inManagedBlock = true;
+                // Add the new managed block
+                newLines.push(...managedBlockLines);
+                continue;
+            }
+            if (inManagedBlock) {
+                // Skip lines that are part of the managed block (comments or the dirs)
+                if (line.trim().startsWith('#') || agentideDirs.includes(line.trim()) || line.trim() === '') {
+                    continue;
+                }
+                // End of managed block
+                inManagedBlock = false;
+            }
+            newLines.push(line);
+        }
+        next = newLines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+    }
+    else {
+        // Append the managed block
+        next = [
+            existing.trimEnd(),
+            '',
+            managedBlockLines.join('\n'),
+            '',
+        ].join('\n').replace(/^\n+/, '');
+    }
+    try {
+        const changed = await writeFileIfChanged(rootGitignorePath, next);
+        if (changed) {
+            logInfo(logger, `[AgentIDE] Updated ${rootGitignorePath} to ignore ${branding_1.AGENTIDE_BRAND_NAME} directories`);
+        }
+    }
+    catch (e) {
+        logInfo(logger, `[AgentIDE] Warning: failed to write root .gitignore: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/**
+ * Compute SHA256 hash of a file using streaming to avoid loading large files into memory.
+ * Returns the hash along with file stats for caching purposes.
+ */
+async function readFileSha256(filePath) {
+    const stat = await fs_1.promises.stat(filePath);
+    const hash = crypto.createHash('sha256');
+    await (0, promises_1.pipeline)((0, fs_1.createReadStream)(filePath), hash);
+    return {
+        sha256: hash.digest('hex'),
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+    };
+}
+/**
+ * Get file stats for mtime caching (fast path check before hashing).
+ */
+async function getFileStats(filePath) {
+    try {
+        const stat = await fs_1.promises.stat(filePath);
+        return { size: stat.size, mtimeMs: stat.mtimeMs };
+    }
+    catch (e) {
+        if (getErrorCode(e) === 'ENOENT') {
+            return undefined;
+        }
+        throw e;
+    }
+}
+/**
+ * Check if cached file hash is still valid based on mtime and size.
+ * If valid, returns the cached entry; otherwise returns undefined to trigger re-hash.
+ */
+function isCachedHashValid(cached, currentStats) {
+    if (!cached || !currentStats) {
+        return undefined;
+    }
+    if (cached.mtimeMs === currentStats.mtimeMs && cached.size === currentStats.size) {
+        return cached;
+    }
+    return undefined;
+}
+function shortSig(input) {
+    return crypto.createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+// -----------------------------------------------------------------------------
+// Environment Utilities
+// -----------------------------------------------------------------------------
+/**
+ * Check if a URL is a local HTTPS address (localhost, 127.0.0.1, 0.0.0.0).
+ */
+function isLocalHttps(url) {
+    if (!url) {
+        return false;
+    }
+    return url.startsWith('https://') && (url.includes('localhost') || url.includes('127.0.0.1') || url.includes('0.0.0.0'));
+}
+/**
+ * Apply TLS verification bypass for local HTTPS in an environment object.
+ * Returns the modified env and whether TLS was disabled.
+ */
+function applyLocalTlsBypass(env, baseUrl) {
+    if (isLocalHttps(baseUrl)) {
+        env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
+        return true;
+    }
+    return false;
+}
+// -----------------------------------------------------------------------------
+// API Routing
+// -----------------------------------------------------------------------------
+/**
+ * Get overrideOpenAIBaseUrl for a baseUrl by looking up custom provider config.
+ * Uses the provided ConfigProvider or returns undefined (for headless/CLI).
+ */
+function getOverrideOpenAIBaseUrl(baseUrl, configProvider) {
+    // If no ConfigProvider, return undefined (no override in headless/CLI mode)
+    if (!configProvider) {
+        return undefined;
+    }
+    const customProviders = configProvider.getCustomProviders();
+    const normalizedInput = baseUrl.replace(/\/$/, '');
+    for (const providerConfig of Object.values(customProviders)) {
+        if (providerConfig.baseUrl) {
+            const normalizedProviderUrl = providerConfig.baseUrl.replace(/\/$/, '');
+            if (normalizedInput === normalizedProviderUrl && providerConfig.overrideOpenAIBaseUrl) {
+                return providerConfig.overrideOpenAIBaseUrl.trim();
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve API key and base URL based on LiteLLM routing configuration.
+ * Handles fallback to global litellm* settings when useLiteLLM is true.
+ * Returns both baseUrl (for Claude/Anthropic) and openaiBaseUrl (with overrideOpenAIBaseUrl applied for Codex).
+ *
+ * @param options - Agent request options
+ * @param litellmApiKey - Fallback LiteLLM API key
+ * @param litellmBaseUrl - Fallback LiteLLM base URL
+ * @param configProvider - Optional config provider for resolving overrides
+ */
+function resolveApiRouting(options, litellmApiKey, litellmBaseUrl, configProvider) {
+    const useLiteLLM = options.useLiteLLM === true;
+    const baseUrl = options.baseUrl || (useLiteLLM ? litellmBaseUrl : undefined);
+    const liteLLMResolvedApiKey = options.apiKey || litellmApiKey || 'sk-dummy';
+    // For OpenAI-compatible endpoints, check for per-provider overrideOpenAIBaseUrl
+    let openaiBaseUrl = baseUrl;
+    if (baseUrl) {
+        const overrideUrl = getOverrideOpenAIBaseUrl(baseUrl, configProvider);
+        if (overrideUrl) {
+            openaiBaseUrl = overrideUrl;
+        }
+    }
+    return {
+        apiKey: useLiteLLM ? liteLLMResolvedApiKey : (options.apiKey || ''),
+        baseUrl,
+        openaiBaseUrl,
+        useLiteLLM,
+    };
+}
+// -----------------------------------------------------------------------------
+// VS Code Configuration
+// -----------------------------------------------------------------------------
+/**
+ * Get explicit config value from VS Code configuration.
+ * Note: This function requires VS Code runtime.
+ */
+function getExplicitConfigValue(config, key) {
+    const inspect = config.inspect(key);
+    if (!inspect) {
+        return undefined;
+    }
+    return (inspect.workspaceFolderValue ?? inspect.workspaceValue ?? inspect.globalValue);
+}
+/**
+ * Get engine settings from configuration.
+ * Uses the provided ConfigProvider or returns defaults (for headless/CLI).
+ */
+function getAgentideEngineSettings(configProvider) {
+    if (configProvider) {
+        return configProvider.getEngineSettings();
+    }
+    // Return defaults when no ConfigProvider (headless/CLI mode)
+    return {
+        claudeMaxThinkingTokens: 0,
+    };
+}
+// -----------------------------------------------------------------------------
+// Stream Emitter Factory
+// -----------------------------------------------------------------------------
+/**
+ * Send a stream event to the Workbench via command.
+ * The Workbench registers 'agentide.streamCallback' to receive these events.
+ */
+async function emitStreamEvent(event) {
+    try {
+        await getVscode().commands.executeCommand('agentide.streamCallback', event);
+    }
+    catch (e) {
+        console.error('[AgentIDE Extension] Failed to emit stream event:', e);
+    }
+}
+/**
+ * Create a StreamEmitter for IPC streaming via stream events.
+ */
+const STREAM_COALESCE_WINDOW_MS = 40;
+const STREAM_COALESCE_MIN_CHARS = 120;
+function flushCoalescedBuffers(streamId, state) {
+    const emits = [];
+    if (state.markdownBuffer) {
+        emits.push(emitStreamEvent({ streamId, type: 'markdown', data: state.markdownBuffer }));
+        state.markdownBuffer = '';
+    }
+    if (state.thinkingBuffer) {
+        emits.push(emitStreamEvent({ streamId, type: 'thinking', data: state.thinkingBuffer }));
+        state.thinkingBuffer = '';
+    }
+    if (state.flushTimer) {
+        clearTimeout(state.flushTimer);
+        state.flushTimer = undefined;
+    }
+    return Promise.all(emits).then(() => undefined);
+}
+function ensureFlushTimer(streamId, state) {
+    if (state.flushTimer) {
+        return;
+    }
+    state.flushTimer = setTimeout(() => {
+        void flushCoalescedBuffers(streamId, state);
+    }, STREAM_COALESCE_WINDOW_MS);
+}
+function createIPCStreamEmitter(streamId) {
+    const state = {
+        markdownBuffer: '',
+        thinkingBuffer: '',
+        flushTimer: undefined,
+    };
+    return {
+        async thinking(delta) {
+            if (!delta) {
+                return;
+            }
+            state.thinkingBuffer += delta;
+            if (state.thinkingBuffer.length >= STREAM_COALESCE_MIN_CHARS) {
+                await flushCoalescedBuffers(streamId, state);
+                return;
+            }
+            ensureFlushTimer(streamId, state);
+        },
+        async text(delta) {
+            if (!delta) {
+                return;
+            }
+            state.markdownBuffer += delta;
+            if (state.markdownBuffer.length >= STREAM_COALESCE_MIN_CHARS) {
+                await flushCoalescedBuffers(streamId, state);
+                return;
+            }
+            ensureFlushTimer(streamId, state);
+        },
+        async toolStart(toolName, input, toolCallId, metadata) {
+            await flushCoalescedBuffers(streamId, state);
+            await emitStreamEvent({ streamId, type: 'tool_use', toolName, toolCallId, data: input || '', metadata });
+        },
+        async toolEnd(toolName, toolCallId, result, isError, metadata) {
+            await flushCoalescedBuffers(streamId, state);
+            const base = (metadata && typeof metadata === 'object') ? metadata : {};
+            await emitStreamEvent({
+                streamId,
+                type: 'tool_end',
+                toolName,
+                toolCallId,
+                data: result || '',
+                metadata: { ...base, isError }
+            });
+        },
+        async progress(message) {
+            await flushCoalescedBuffers(streamId, state);
+            await emitStreamEvent({ streamId, type: 'progress', data: message });
+        },
+        async question(payload) {
+            await flushCoalescedBuffers(streamId, state);
+            await emitStreamEvent({ streamId, type: 'question', metadata: payload });
+            return {
+                selected: [],
+                freeText: null,
+                declined: true,
+            };
+        },
+        async error(message) {
+            await flushCoalescedBuffers(streamId, state);
+            await emitStreamEvent({ streamId, type: 'error', data: message });
+        },
+        async done() {
+            await flushCoalescedBuffers(streamId, state);
+            await emitStreamEvent({ streamId, type: 'done' });
+        },
+    };
+}
+// -----------------------------------------------------------------------------
+// Text Delta Tracking
+// -----------------------------------------------------------------------------
+/**
+ * Helper to compute delta for streaming text (avoids duplicate content).
+ * Uses a Map to track last seen text per item ID.
+ */
+function computeTextDelta(itemId, newText, tracker) {
+    const prev = tracker.get(itemId) ?? '';
+    const delta = newText.startsWith(prev) ? newText.slice(prev.length) : newText;
+    tracker.set(itemId, newText);
+    return delta;
+}
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+// -----------------------------------------------------------------------------
+// Stable Helpers
+// -----------------------------------------------------------------------------
+function stableAdditionalDirs(additionalDirectories) {
+    return (additionalDirectories ?? []).slice().filter(Boolean).sort();
+}
+// Re-export from utils/paths for extension convenience
+var paths_1 = require("./utils/paths");
+Object.defineProperty(exports, "getAnalyticsScriptsDir", { enumerable: true, get: function () { return paths_1.getAnalyticsScriptsDir; } });
+// -----------------------------------------------------------------------------
+// Shell Command File Path Extraction (for edit tracking)
+// -----------------------------------------------------------------------------
+const CREATE_CMD_PATTERN = /(?:cat\s*>[^>]|echo\s*>[^>]|touch\s+|>\s*[^>]|<<\s*['"]?EOF)/;
+const EXCLUDED_PREFIXES = ['/tmp/', '/var/', '/dev/'];
+const EXCLUDED_SUFFIXES = ['.tmp', '.bak'];
+/** Extract file paths from shell command. Inclusive approach - better to over-track than miss. */
+function extractFilePaths(command, workspaceRoot) {
+    // Use matchAll with inline regex to avoid shared state issues
+    // Character class includes: whitespace, quotes, backticks, semicolon, pipe, ampersand, parens, equals, and redirects (><)
+    const matches = command.matchAll(/(?:^|[\s'"`;|&()=><])([./]*(?:[\w.\-]+\/)*[\w.\-]+\.[\w]+)(?=[\s'"`;|&()=><]|$)/g);
+    const paths = new Set();
+    for (const m of matches) {
+        const p = m[1].replace(/['"]/g, '').trim();
+        if (!p || p.startsWith('-') || p.includes('..')) {
+            continue;
+        }
+        if (EXCLUDED_PREFIXES.some(x => p.startsWith(x)) || EXCLUDED_SUFFIXES.some(x => p.endsWith(x))) {
+            continue;
+        }
+        paths.add(p.startsWith('/') ? p : `${workspaceRoot}/${p.replace(/^\.\//, '')}`);
+    }
+    return [...paths];
+}
+/** Check if command creates new files (vs modifying existing) */
+function isCreateCommand(cmd) {
+    return CREATE_CMD_PATTERN.test(cmd);
+}
+/**
+ * Normalize provider-specific file change kinds to AgentIDE's canonical kinds.
+ */
+function normalizeFileChangeKind(kind) {
+    switch (kind) {
+        case 'add':
+        case 'create':
+            return 'create';
+        case 'update':
+        case 'modify':
+            return 'modify';
+        case 'delete':
+            return 'delete';
+        default:
+            return undefined;
+    }
+}
+/** Binary file extensions that should not be tracked for edit diffs (lowercase) */
+const BINARY_EXTENSIONS = new Set([
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    '.zip', '.tar', '.gz', '.rar', '.7z',
+    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
+    '.mp3', '.mp4', '.wav', '.avi', '.mov', '.mkv',
+    '.exe', '.dll', '.so', '.dylib', '.bin',
+    '.woff', '.woff2', '.ttf', '.otf', '.eot',
+    '.pyc', '.class', '.o', '.a',
+]);
+/** Check if file is a binary file (based on extension). Assumes lowercase extensions. */
+function isBinaryFile(filePath) {
+    const dotIdx = filePath.lastIndexOf('.');
+    if (dotIdx === -1) {
+        return false;
+    }
+    return BINARY_EXTENSIONS.has(filePath.slice(dotIdx));
+}