indusagi-coding-agent 0.1.0

package/dist/cli/args.js

@@ -0,0 +1,282 @@
+/**
+ * CLI argument parsing and help display
+ */
+import chalk from "chalk";
+import { APP_NAME, CONFIG_DIR_NAME, ENV_AGENT_DIR } from "../config.js";
+import { allTools } from "../core/tools/index.js";
+const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+export function isValidThinkingLevel(level) {
+    return VALID_THINKING_LEVELS.includes(level);
+}
+export function parseArgs(args, extensionFlags) {
+    const result = {
+        messages: [],
+        fileArgs: [],
+        unknownFlags: new Map(),
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            result.help = true;
+        }
+        else if (arg === "--version" || arg === "-v") {
+            result.version = true;
+        }
+        else if (arg === "--mode" && i + 1 < args.length) {
+            const mode = args[++i];
+            if (mode === "text" || mode === "json" || mode === "rpc") {
+                result.mode = mode;
+            }
+        }
+        else if (arg === "--continue" || arg === "-c") {
+            result.continue = true;
+        }
+        else if (arg === "--resume" || arg === "-r") {
+            result.resume = true;
+        }
+        else if (arg === "--provider" && i + 1 < args.length) {
+            result.provider = args[++i];
+        }
+        else if (arg === "--model" && i + 1 < args.length) {
+            result.model = args[++i];
+        }
+        else if (arg === "--api-key" && i + 1 < args.length) {
+            result.apiKey = args[++i];
+        }
+        else if (arg === "--system-prompt" && i + 1 < args.length) {
+            result.systemPrompt = args[++i];
+        }
+        else if (arg === "--append-system-prompt" && i + 1 < args.length) {
+            result.appendSystemPrompt = args[++i];
+        }
+        else if (arg === "--no-session") {
+            result.noSession = true;
+        }
+        else if (arg === "--session" && i + 1 < args.length) {
+            result.session = args[++i];
+        }
+        else if (arg === "--session-dir" && i + 1 < args.length) {
+            result.sessionDir = args[++i];
+        }
+        else if (arg === "--models" && i + 1 < args.length) {
+            result.models = args[++i].split(",").map((s) => s.trim());
+        }
+        else if (arg === "--no-tools") {
+            result.noTools = true;
+        }
+        else if (arg === "--tools" && i + 1 < args.length) {
+            const toolNames = args[++i].split(",").map((s) => s.trim());
+            const validTools = [];
+            for (const name of toolNames) {
+                if (name in allTools) {
+                    validTools.push(name);
+                }
+                else {
+                    console.error(chalk.yellow(`Warning: Unknown tool "${name}". Valid tools: ${Object.keys(allTools).join(", ")}`));
+                }
+            }
+            result.tools = validTools;
+        }
+        else if (arg === "--thinking" && i + 1 < args.length) {
+            const level = args[++i];
+            if (isValidThinkingLevel(level)) {
+                result.thinking = level;
+            }
+            else {
+                console.error(chalk.yellow(`Warning: Invalid thinking level "${level}". Valid values: ${VALID_THINKING_LEVELS.join(", ")}`));
+            }
+        }
+        else if (arg === "--print" || arg === "-p") {
+            result.print = true;
+        }
+        else if (arg === "--export" && i + 1 < args.length) {
+            result.export = args[++i];
+        }
+        else if ((arg === "--extension" || arg === "-e") && i + 1 < args.length) {
+            result.extensions = result.extensions ?? [];
+            result.extensions.push(args[++i]);
+        }
+        else if (arg === "--no-extensions") {
+            result.noExtensions = true;
+        }
+        else if (arg === "--skill" && i + 1 < args.length) {
+            result.skills = result.skills ?? [];
+            result.skills.push(args[++i]);
+        }
+        else if (arg === "--prompt-template" && i + 1 < args.length) {
+            result.promptTemplates = result.promptTemplates ?? [];
+            result.promptTemplates.push(args[++i]);
+        }
+        else if (arg === "--theme" && i + 1 < args.length) {
+            result.themes = result.themes ?? [];
+            result.themes.push(args[++i]);
+        }
+        else if (arg === "--no-skills") {
+            result.noSkills = true;
+        }
+        else if (arg === "--no-prompt-templates") {
+            result.noPromptTemplates = true;
+        }
+        else if (arg === "--no-themes") {
+            result.noThemes = true;
+        }
+        else if (arg === "--list-models") {
+            // Check if next arg is a search pattern (not a flag or file arg)
+            if (i + 1 < args.length && !args[i + 1].startsWith("-") && !args[i + 1].startsWith("@")) {
+                result.listModels = args[++i];
+            }
+            else {
+                result.listModels = true;
+            }
+        }
+        else if (arg === "--verbose") {
+            result.verbose = true;
+        }
+        else if (arg.startsWith("@")) {
+            result.fileArgs.push(arg.slice(1)); // Remove @ prefix
+        }
+        else if (arg.startsWith("--") && extensionFlags) {
+            // Check if it's an extension-registered flag
+            const flagName = arg.slice(2);
+            const extFlag = extensionFlags.get(flagName);
+            if (extFlag) {
+                if (extFlag.type === "boolean") {
+                    result.unknownFlags.set(flagName, true);
+                }
+                else if (extFlag.type === "string" && i + 1 < args.length) {
+                    result.unknownFlags.set(flagName, args[++i]);
+                }
+            }
+            // Unknown flags without extensionFlags are silently ignored (first pass)
+        }
+        else if (!arg.startsWith("-")) {
+            result.messages.push(arg);
+        }
+    }
+    return result;
+}
+export function printHelp() {
+    console.log(`${chalk.bold(APP_NAME)} - AI coding assistant with read, bash, edit, write tools
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} [options] [@files...] [messages...]
+
+${chalk.bold("Commands:")}
+  ${APP_NAME} install <source> [-l]    Install extension source and add to settings
+  ${APP_NAME} remove <source> [-l]     Remove extension source from settings
+  ${APP_NAME} update [source]          Update installed extensions (skips pinned sources)
+  ${APP_NAME} list                     List installed extensions from settings
+  ${APP_NAME} config                   Open TUI to enable/disable package resources
+
+${chalk.bold("Options:")}
+  --provider <name>              Provider name (default: google)
+  --model <id>                   Model ID (default: gemini-2.5-flash)
+  --api-key <key>                API key (defaults to env vars)
+  --system-prompt <text>         System prompt (default: coding assistant prompt)
+  --append-system-prompt <text>  Append text or file contents to the system prompt
+  --mode <mode>                  Output mode: text (default), json, or rpc
+  --print, -p                    Non-interactive mode: process prompt and exit
+  --continue, -c                 Continue previous session
+  --resume, -r                   Select a session to resume
+  --session <path>               Use specific session file
+  --session-dir <dir>            Directory for session storage and lookup
+  --no-session                   Don't save session (ephemeral)
+  --models <patterns>            Comma-separated model patterns for Ctrl+P cycling
+                                 Supports globs (anthropic/*, *sonnet*) and fuzzy matching
+  --no-tools                     Disable all built-in tools
+  --tools <tools>                Comma-separated list of tools to enable (default: read,bash,edit,write)
+                                 Available: read, bash, edit, write, grep, find, ls
+  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
+  --extension, -e <path>         Load an extension file (can be used multiple times)
+  --no-extensions                Disable extension discovery (explicit -e paths still work)
+  --skill <path>                 Load a skill file or directory (can be used multiple times)
+  --no-skills                    Disable skills discovery and loading
+  --prompt-template <path>       Load a prompt template file or directory (can be used multiple times)
+  --no-prompt-templates          Disable prompt template discovery and loading
+  --theme <path>                 Load a theme file or directory (can be used multiple times)
+  --no-themes                    Disable theme discovery and loading
+  --export <file>                Export session file to HTML and exit
+  --list-models [search]         List available models (with optional fuzzy search)
+  --verbose                      Force verbose startup (overrides quietStartup setting)
+  --help, -h                     Show this help
+  --version, -v                  Show version number
+
+Extensions can register additional flags (e.g., --plan from plan-mode extension).
+
+${chalk.bold("Examples:")}
+  # Interactive mode
+  ${APP_NAME}
+
+  # Interactive mode with initial prompt
+  ${APP_NAME} "List all .ts files in src/"
+
+  # Include files in initial message
+  ${APP_NAME} @prompt.md @image.png "What color is the sky?"
+
+  # Non-interactive mode (process and exit)
+  ${APP_NAME} -p "List all .ts files in src/"
+
+  # Multiple messages (interactive)
+  ${APP_NAME} "Read package.json" "What dependencies do we have?"
+
+  # Continue previous session
+  ${APP_NAME} --continue "What did we discuss?"
+
+  # Use different model
+  ${APP_NAME} --provider openai --model gpt-4o-mini "Help me refactor this code"
+
+  # Limit model cycling to specific models
+  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o
+
+  # Limit to a specific provider with glob pattern
+  ${APP_NAME} --models "github-copilot/*"
+
+  # Cycle models with fixed thinking levels
+  ${APP_NAME} --models sonnet:high,haiku:low
+
+  # Start with a specific thinking level
+  ${APP_NAME} --thinking high "Solve this complex problem"
+
+  # Read-only mode (no file modifications possible)
+  ${APP_NAME} --tools read,grep,find,ls -p "Review the code in src/"
+
+  # Export a session file to HTML
+  ${APP_NAME} --export ~/${CONFIG_DIR_NAME}/agent/sessions/--path--/session.jsonl
+  ${APP_NAME} --export session.jsonl output.html
+
+${chalk.bold("Environment Variables:")}
+  ANTHROPIC_AINDUSAGI_KEY                - Anthropic Claude API key
+  ANTHROPIC_OAUTH_TOKEN            - Anthropic OAuth token (alternative to API key)
+  OPENAI_AINDUSAGI_KEY                   - OpenAI GPT API key
+  AZURE_OPENAI_AINDUSAGI_KEY             - Azure OpenAI API key
+  AZURE_OPENAI_BASE_URL            - Azure OpenAI base URL (https://{resource}.openai.azure.com/openai/v1)
+  AZURE_OPENAI_RESOURCE_NAME       - Azure OpenAI resource name (alternative to base URL)
+  AZURE_OPENAI_AINDUSAGI_VERSION         - Azure OpenAI API version (default: v1)
+  AZURE_OPENAI_DEPLOYMENT_NAME_MAP - Azure OpenAI model=deployment map (comma-separated)
+  GEMINI_AINDUSAGI_KEY                   - Google Gemini API key
+  GROQ_AINDUSAGI_KEY                     - Groq API key
+  CEREBRAS_AINDUSAGI_KEY                 - Cerebras API key
+  XAI_AINDUSAGI_KEY                      - xAI Grok API key
+  OPENROUTER_AINDUSAGI_KEY               - OpenRouter API key
+  AI_GATEWAY_AINDUSAGI_KEY               - Vercel AI Gateway API key
+  ZAI_AINDUSAGI_KEY                      - ZAI API key
+  MISTRAL_AINDUSAGI_KEY                  - Mistral API key
+  MINIMAX_AINDUSAGI_KEY                  - MiniMax API key
+  AWS_PROFILE                      - AWS profile for Amazon Bedrock
+  AWS_ACCESS_KEY_ID                - AWS access key for Amazon Bedrock
+  AWS_SECRET_ACCESS_KEY            - AWS secret key for Amazon Bedrock
+  AWS_BEARER_TOKEN_BEDROCK         - Bedrock API key (bearer token)
+  AWS_REGION                       - AWS region for Amazon Bedrock (e.g., us-east-1)
+  ${ENV_AGENT_DIR.padEnd(32)} - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
+  INDUSAGI_SHARE_VIEWER_URL        - Base URL for /share command (default: https://buildwithindusagi.ai/session/)
+
+${chalk.bold("Available Tools (default: read, bash, edit, write):")}
+  read   - Read file contents
+  bash   - Execute bash commands
+  edit   - Edit files with find/replace
+  write  - Write files (creates/overwrites)
+  grep   - Search file contents (read-only, off by default)
+  find   - Find files by glob pattern (read-only, off by default)
+  ls     - List directory contents (read-only, off by default)
+`);
+}

package/dist/cli/config-selector.js

@@ -0,0 +1,30 @@
+/**
+ * TUI config selector for `indusagi config` command
+ */
+import { ProcessTerminal, TUI } from "indusagi/tui";
+import { ConfigSelectorComponent } from "../modes/interactive/components/config-selector.js";
+import { initTheme, stopThemeWatcher } from "../modes/interactive/theme/theme.js";
+/** Show TUI config selector and return when closed */
+export async function selectConfig(options) {
+    // Initialize theme before showing TUI
+    initTheme(options.settingsManager.getTheme(), true);
+    return new Promise((resolve) => {
+        const ui = new TUI(new ProcessTerminal());
+        let resolved = false;
+        const selector = new ConfigSelectorComponent(options.resolvedPaths, options.settingsManager, options.cwd, options.agentDir, () => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                stopThemeWatcher();
+                resolve();
+            }
+        }, () => {
+            ui.stop();
+            stopThemeWatcher();
+            process.exit(0);
+        }, () => ui.requestRender());
+        ui.addChild(selector);
+        ui.setFocus(selector.getResourceList());
+        ui.start();
+    });
+}

package/dist/cli/file-processor.js

@@ -0,0 +1,78 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+import { access, readFile, stat } from "node:fs/promises";
+import chalk from "chalk";
+import { resolve } from "path";
+import { resolveReadPath } from "../core/tools/path-utils.js";
+import { formatDimensionNote, resizeImage } from "../utils/image-resize.js";
+import { detectSupportedImageMimeTypeFromFile } from "../utils/mime.js";
+/** Process @file arguments into text content and image attachments */
+export async function processFileArguments(fileArgs, options) {
+    const autoResizeImages = options?.autoResizeImages ?? true;
+    let text = "";
+    const images = [];
+    for (const fileArg of fileArgs) {
+        // Expand and resolve path (handles ~ expansion and macOS screenshot Unicode spaces)
+        const absolutePath = resolve(resolveReadPath(fileArg, process.cwd()));
+        // Check if file exists
+        try {
+            await access(absolutePath);
+        }
+        catch {
+            console.error(chalk.red(`Error: File not found: ${absolutePath}`));
+            process.exit(1);
+        }
+        // Check if file is empty
+        const stats = await stat(absolutePath);
+        if (stats.size === 0) {
+            // Skip empty files
+            continue;
+        }
+        const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
+        if (mimeType) {
+            // Handle image file
+            const content = await readFile(absolutePath);
+            const base64Content = content.toString("base64");
+            let attachment;
+            let dimensionNote;
+            if (autoResizeImages) {
+                const resized = await resizeImage({ type: "image", data: base64Content, mimeType });
+                dimensionNote = formatDimensionNote(resized);
+                attachment = {
+                    type: "image",
+                    mimeType: resized.mimeType,
+                    data: resized.data,
+                };
+            }
+            else {
+                attachment = {
+                    type: "image",
+                    mimeType,
+                    data: base64Content,
+                };
+            }
+            images.push(attachment);
+            // Add text reference to image with optional dimension note
+            if (dimensionNote) {
+                text += `<file name="${absolutePath}">${dimensionNote}</file>\n`;
+            }
+            else {
+                text += `<file name="${absolutePath}"></file>\n`;
+            }
+        }
+        else {
+            // Handle text file
+            try {
+                const content = await readFile(absolutePath, "utf-8");
+                text += `<file name="${absolutePath}">\n${content}\n</file>\n`;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(chalk.red(`Error: Could not read file ${absolutePath}: ${message}`));
+                process.exit(1);
+            }
+        }
+    }
+    return { text, images };
+}

package/dist/cli/list-models.js

@@ -0,0 +1,91 @@
+/**
+ * List available models with optional fuzzy search
+ */
+import { fuzzyFilter } from "indusagi/tui";
+/**
+ * Format a number as human-readable (e.g., 200000 -> "200K", 1000000 -> "1M")
+ */
+function formatTokenCount(count) {
+    if (count >= 1_000_000) {
+        const millions = count / 1_000_000;
+        return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+    }
+    if (count >= 1_000) {
+        const thousands = count / 1_000;
+        return thousands % 1 === 0 ? `${thousands}K` : `${thousands.toFixed(1)}K`;
+    }
+    return count.toString();
+}
+/**
+ * List available models, optionally filtered by search pattern
+ */
+export async function listModels(modelRegistry, searchPattern) {
+    const models = modelRegistry.getAvailable();
+    if (models.length === 0) {
+        console.log("No models available. Set API keys in environment variables.");
+        return;
+    }
+    // Apply fuzzy filter if search pattern provided
+    let filteredModels = models;
+    if (searchPattern) {
+        filteredModels = fuzzyFilter(models, searchPattern, (m) => `${m.provider} ${m.id}`);
+    }
+    if (filteredModels.length === 0) {
+        console.log(`No models matching "${searchPattern}"`);
+        return;
+    }
+    // Sort by provider, then by model id
+    filteredModels.sort((a, b) => {
+        const providerCmp = a.provider.localeCompare(b.provider);
+        if (providerCmp !== 0)
+            return providerCmp;
+        return a.id.localeCompare(b.id);
+    });
+    // Calculate column widths
+    const rows = filteredModels.map((m) => ({
+        provider: m.provider,
+        model: m.id,
+        context: formatTokenCount(m.contextWindow),
+        maxOut: formatTokenCount(m.maxTokens),
+        thinking: m.reasoning ? "yes" : "no",
+        images: m.input.includes("image") ? "yes" : "no",
+    }));
+    const headers = {
+        provider: "provider",
+        model: "model",
+        context: "context",
+        maxOut: "max-out",
+        thinking: "thinking",
+        images: "images",
+    };
+    const widths = {
+        provider: Math.max(headers.provider.length, ...rows.map((r) => r.provider.length)),
+        model: Math.max(headers.model.length, ...rows.map((r) => r.model.length)),
+        context: Math.max(headers.context.length, ...rows.map((r) => r.context.length)),
+        maxOut: Math.max(headers.maxOut.length, ...rows.map((r) => r.maxOut.length)),
+        thinking: Math.max(headers.thinking.length, ...rows.map((r) => r.thinking.length)),
+        images: Math.max(headers.images.length, ...rows.map((r) => r.images.length)),
+    };
+    // Print header
+    const headerLine = [
+        headers.provider.padEnd(widths.provider),
+        headers.model.padEnd(widths.model),
+        headers.context.padEnd(widths.context),
+        headers.maxOut.padEnd(widths.maxOut),
+        headers.thinking.padEnd(widths.thinking),
+        headers.images.padEnd(widths.images),
+    ].join("  ");
+    console.log(headerLine);
+    // Print rows
+    for (const row of rows) {
+        const line = [
+            row.provider.padEnd(widths.provider),
+            row.model.padEnd(widths.model),
+            row.context.padEnd(widths.context),
+            row.maxOut.padEnd(widths.maxOut),
+            row.thinking.padEnd(widths.thinking),
+            row.images.padEnd(widths.images),
+        ].join("  ");
+        console.log(line);
+    }
+}

package/dist/cli/session-picker.js

@@ -0,0 +1,31 @@
+/**
+ * TUI session selector for --resume flag
+ */
+import { ProcessTerminal, TUI } from "indusagi/tui";
+import { SessionSelectorComponent } from "../modes/interactive/components/session-selector.js";
+/** Show TUI session selector and return selected session path or null if cancelled */
+export async function selectSession(currentSessionsLoader, allSessionsLoader) {
+    return new Promise((resolve) => {
+        const ui = new TUI(new ProcessTerminal());
+        let resolved = false;
+        const selector = new SessionSelectorComponent(currentSessionsLoader, allSessionsLoader, (path) => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                resolve(path);
+            }
+        }, () => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                resolve(null);
+            }
+        }, () => {
+            ui.stop();
+            process.exit(0);
+        }, () => ui.requestRender(), { showRenameHint: false });
+        ui.addChild(selector);
+        ui.setFocus(selector.getSessionList());
+        ui.start();
+    });
+}

package/dist/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for the refactored coding agent.
+ * Uses main.ts with AgentSession and new mode modules.
+ *
+ * Test with: npx tsx src/cli-new.ts [args...]
+ */
+process.title = "indusagi";
+import { main } from "./main.js";
+main(process.argv.slice(2));

package/dist/config.js

@@ -0,0 +1,158 @@
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+// =============================================================================
+// Package Detection
+// =============================================================================
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Detect if we're running as a Bun compiled binary.
+ * Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
+ */
+export const isBunBinary = import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
+/** Detect if Bun is the runtime (compiled binary or bun run) */
+export const isBunRuntime = !!process.versions.bun;
+// =============================================================================
+// Package Asset Paths (shipped with executable)
+// =============================================================================
+/**
+ * Get the base directory for resolving package assets (themes, package.json, README.md, CHANGELOG.md).
+ * - For Bun binary: returns the directory containing the executable
+ * - For Node.js (dist/): returns __dirname (the dist/ directory)
+ * - For tsx (src/): returns parent directory (the package root)
+ */
+export function getPackageDir() {
+    if (isBunBinary) {
+        // Bun binary: process.execPath points to the compiled executable
+        return dirname(process.execPath);
+    }
+    // Node.js: walk up from __dirname until we find package.json
+    let dir = __dirname;
+    while (dir !== dirname(dir)) {
+        if (existsSync(join(dir, "package.json"))) {
+            return dir;
+        }
+        dir = dirname(dir);
+    }
+    // Fallback (shouldn't happen)
+    return __dirname;
+}
+/**
+ * Get path to built-in themes directory (shipped with package)
+ * - For Bun binary: theme/ next to executable
+ * - For Node.js (dist/): dist/modes/interactive/theme/
+ * - For tsx (src/): src/modes/interactive/theme/
+ */
+export function getThemesDir() {
+    if (isBunBinary) {
+        return join(dirname(process.execPath), "theme");
+    }
+    // Theme is in modes/interactive/theme/ relative to src/ or dist/
+    const packageDir = getPackageDir();
+    const srcOrDist = existsSync(join(packageDir, "src")) ? "src" : "dist";
+    return join(packageDir, srcOrDist, "modes", "interactive", "theme");
+}
+/**
+ * Get path to HTML export template directory (shipped with package)
+ * - For Bun binary: export-html/ next to executable
+ * - For Node.js (dist/): dist/core/export-html/
+ * - For tsx (src/): src/core/export-html/
+ */
+export function getExportTemplateDir() {
+    if (isBunBinary) {
+        return join(dirname(process.execPath), "export-html");
+    }
+    const packageDir = getPackageDir();
+    const srcOrDist = existsSync(join(packageDir, "src")) ? "src" : "dist";
+    return join(packageDir, srcOrDist, "core", "export-html");
+}
+/** Get path to package.json */
+export function getPackageJsonPath() {
+    return join(getPackageDir(), "package.json");
+}
+/** Get path to README.md */
+export function getReadmePath() {
+    return resolve(join(getPackageDir(), "README.md"));
+}
+/** Get path to docs directory */
+export function getDocsPath() {
+    return resolve(join(getPackageDir(), "docs"));
+}
+/** Get path to examples directory */
+export function getExamplesPath() {
+    return resolve(join(getPackageDir(), "examples"));
+}
+/** Get path to CHANGELOG.md */
+export function getChangelogPath() {
+    return resolve(join(getPackageDir(), "CHANGELOG.md"));
+}
+// =============================================================================
+// App Config (from package.json indusagiConfig)
+// =============================================================================
+const pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+export const APP_NAME = pkg.indusagiConfig?.name || "indusagi";
+export const CONFIG_DIR_NAME = pkg.indusagiConfig?.configDir || ".indusagi";
+export const VERSION = pkg.version;
+// e.g., INDUSAGI_CODING_AGENT_DIR or TAU_CODING_AGENT_DIR
+export const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
+export const ENV_SHARE_VIEWER_URL = `${APP_NAME.toUpperCase()}_SHARE_VIEWER_URL`;
+const DEFAULT_SHARE_VIEWER_URL = "https://buildwithindusagi.ai/session/";
+/** Get the share viewer URL for a gist ID */
+export function getShareViewerUrl(gistId) {
+    const baseUrl = process.env[ENV_SHARE_VIEWER_URL] || DEFAULT_SHARE_VIEWER_URL;
+    return `${baseUrl}#${gistId}`;
+}
+// =============================================================================
+// User Config Paths (~/.indusagi/agent/*)
+// =============================================================================
+/** Get the agent config directory (e.g., ~/.indusagi/agent/) */
+export function getAgentDir() {
+    const envDir = process.env[ENV_AGENT_DIR];
+    if (envDir) {
+        // Expand tilde to home directory
+        if (envDir === "~")
+            return homedir();
+        if (envDir.startsWith("~/"))
+            return homedir() + envDir.slice(1);
+        return envDir;
+    }
+    return join(homedir(), CONFIG_DIR_NAME, "agent");
+}
+/** Get path to user's custom themes directory */
+export function getCustomThemesDir() {
+    return join(getAgentDir(), "themes");
+}
+/** Get path to models.json */
+export function getModelsPath() {
+    return join(getAgentDir(), "models.json");
+}
+/** Get path to auth.json */
+export function getAuthPath() {
+    return join(getAgentDir(), "auth.json");
+}
+/** Get path to settings.json */
+export function getSettingsPath() {
+    return join(getAgentDir(), "settings.json");
+}
+/** Get path to tools directory */
+export function getToolsDir() {
+    return join(getAgentDir(), "tools");
+}
+/** Get path to managed binaries directory (fd, rg) */
+export function getBinDir() {
+    return join(getAgentDir(), "bin");
+}
+/** Get path to prompt templates directory */
+export function getPromptsDir() {
+    return join(getAgentDir(), "prompts");
+}
+/** Get path to sessions directory */
+export function getSessionsDir() {
+    return join(getAgentDir(), "sessions");
+}
+/** Get path to debug log file */
+export function getDebugLogPath() {
+    return join(getAgentDir(), `${APP_NAME}-debug.log`);
+}