distill-mcp 0.6.0-beta

package/dist/cli/doctor.js

@@ -0,0 +1,127 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { detectInstalledIDEs, readJSONFile, isCtxOptConfigured, success, warn, error, log, COLORS, getPackageVersion, } from "./utils.js";
+function checkNodeVersion() {
+    try {
+        const version = process.version;
+        const major = parseInt(version.slice(1).split(".")[0] ?? "0", 10);
+        if (major >= 18) {
+            return {
+                name: "Node.js version",
+                status: "pass",
+                message: `${version} (>= 18 required)`,
+            };
+        }
+        else {
+            return {
+                name: "Node.js version",
+                status: "fail",
+                message: `${version} (>= 18 required, please upgrade)`,
+            };
+        }
+    }
+    catch {
+        return {
+            name: "Node.js version",
+            status: "fail",
+            message: "Unable to determine Node.js version",
+        };
+    }
+}
+function checkPackageInstallation() {
+    try {
+        // Check if ctxopt-mcp is in PATH
+        const which = process.platform === "win32" ? "where" : "which";
+        execSync(`${which} ctxopt-mcp`, { stdio: "pipe" });
+        return {
+            name: "Package installation",
+            status: "pass",
+            message: `@ctxopt/mcp-server v${getPackageVersion()} installed globally`,
+        };
+    }
+    catch {
+        return {
+            name: "Package installation",
+            status: "warn",
+            message: "ctxopt-mcp not found in PATH (may be running via npx)",
+        };
+    }
+}
+function checkIDEConfigurations() {
+    const results = [];
+    const ideConfigs = detectInstalledIDEs();
+    for (const [ide, config] of Object.entries(ideConfigs)) {
+        if (!config.detected) {
+            results.push({
+                name: `${config.name} configuration`,
+                status: "warn",
+                message: "IDE not detected",
+            });
+            continue;
+        }
+        const configFile = readJSONFile(config.configPath);
+        if (!existsSync(config.configPath)) {
+            results.push({
+                name: `${config.name} configuration`,
+                status: "warn",
+                message: `Config file not found at ${config.configPath}`,
+            });
+            continue;
+        }
+        if (isCtxOptConfigured(configFile)) {
+            results.push({
+                name: `${config.name} configuration`,
+                status: "pass",
+                message: `CtxOpt configured in ${config.configPath}`,
+            });
+        }
+        else {
+            results.push({
+                name: `${config.name} configuration`,
+                status: "fail",
+                message: `CtxOpt not configured. Run 'ctxopt-mcp setup --${ide}'`,
+            });
+        }
+    }
+    return results;
+}
+export async function doctor() {
+    log(`\n${COLORS.bright}${COLORS.cyan}CtxOpt MCP Server Doctor${COLORS.reset}\n`);
+    log(`Running diagnostic checks...\n`);
+    const checks = [
+        checkNodeVersion(),
+        checkPackageInstallation(),
+        ...checkIDEConfigurations(),
+    ];
+    let passCount = 0;
+    let warnCount = 0;
+    let failCount = 0;
+    for (const check of checks) {
+        switch (check.status) {
+            case "pass":
+                success(`${check.name}: ${check.message}`);
+                passCount++;
+                break;
+            case "warn":
+                warn(`${check.name}: ${check.message}`);
+                warnCount++;
+                break;
+            case "fail":
+                error(`${check.name}: ${check.message}`);
+                failCount++;
+                break;
+        }
+    }
+    log("\n" + "─".repeat(50));
+    if (failCount === 0 && warnCount === 0) {
+        success(`All ${passCount} checks passed! CtxOpt is ready to use.`);
+    }
+    else if (failCount === 0) {
+        warn(`${passCount} passed, ${warnCount} warnings. CtxOpt should work but may have limited functionality.`);
+    }
+    else {
+        error(`${passCount} passed, ${warnCount} warnings, ${failCount} failed.`);
+        log(`\nRun ${COLORS.cyan}ctxopt-mcp setup${COLORS.reset} to fix configuration issues.`);
+    }
+    log("");
+}

package/dist/cli/hooks.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CtxOpt Hooks Installation Module
+ *
+ * Installs Claude Code hooks that suggest MCP tool usage:
+ * - PreToolUse: Suggests smart_file_read for code files (non-blocking for Edit compatibility)
+ * - PostToolUse: Reminds to use auto_optimize for large Bash outputs
+ * - UserPromptSubmit: Injects MCP tool reminders
+ */
+export interface InstallHooksOptions {
+    projectDir?: string;
+    force?: boolean;
+}
+export declare function installHooks(options?: InstallHooksOptions): Promise<boolean>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/cli/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/cli/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA+JH,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC,CAqGtF"}

package/dist/cli/hooks.js

@@ -0,0 +1,229 @@
+/**
+ * CtxOpt Hooks Installation Module
+ *
+ * Installs Claude Code hooks that suggest MCP tool usage:
+ * - PreToolUse: Suggests smart_file_read for code files (non-blocking for Edit compatibility)
+ * - PostToolUse: Reminds to use auto_optimize for large Bash outputs
+ * - UserPromptSubmit: Injects MCP tool reminders
+ */
+import { existsSync, mkdirSync, writeFileSync, chmodSync } from "fs";
+import { join } from "path";
+import { success, warn, info, error, log, COLORS, readJSONFile, writeJSONFile } from "./utils.js";
+// ============================================================================
+// Hook Script Templates
+// ============================================================================
+const PRE_READ_CHECK_SCRIPT = `#!/bin/bash
+# CtxOpt - PreToolUse Hook for Read
+# Suggests smart_file_read for code files (non-blocking to allow Edit to work)
+
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+BASENAME=$(basename "$FILE_PATH")
+
+# Skip suggestion for configuration files
+if echo "$BASENAME" | grep -qiE "^(CLAUDE|README|CHANGELOG|LICENSE)"; then
+  exit 0
+fi
+if echo "$BASENAME" | grep -qiE "\\.(md|json|yaml|yml|toml|ini|config)$"; then
+  exit 0
+fi
+if echo "$BASENAME" | grep -qiE "^(Dockerfile|Makefile|\\.gitignore|\\.env|\\.prettierrc|\\.eslintrc)"; then
+  exit 0
+fi
+
+# Suggest smart_file_read for source code files (non-blocking)
+if echo "$FILE_PATH" | grep -qE "\\.(ts|tsx|js|jsx|py|go|rs|java|cpp|c|h|hpp)$"; then
+  # Use systemMessage to suggest without blocking (allows Edit to work)
+  cat << EOF
+{"systemMessage": "TIP: Consider using mcp__ctxopt__smart_file_read for '\$BASENAME' to save 50-70% tokens. Example: mcp__ctxopt__smart_file_read filePath=\\"\$FILE_PATH\\" target={\\"type\\":\\"function\\",\\"name\\":\\"myFunc\\"}"}
+EOF
+  exit 0
+fi
+
+# Allow everything else
+exit 0
+`;
+const POST_BASH_REMIND_SCRIPT = `#!/bin/bash
+# CtxOpt - PostToolUse Hook for Bash
+# Reminds to use MCP tools for large outputs
+
+INPUT=$(cat)
+TOOL_RESPONSE=$(echo "$INPUT" | jq -r '.tool_response // empty')
+RESPONSE_SIZE=\${#TOOL_RESPONSE}
+
+# Threshold: 5000 chars ~ 1250 tokens
+THRESHOLD=5000
+
+# Skip if output is small
+if [ "$RESPONSE_SIZE" -lt "$THRESHOLD" ]; then
+  exit 0
+fi
+
+# Detect content type and suggest appropriate tool
+if echo "$TOOL_RESPONSE" | grep -qiE "(error TS|warning TS|error\\[E|npm ERR|ERROR in|failed|FAILED)"; then
+  echo '{"systemMessage": "TIP: Large build output detected. Use mcp__ctxopt__auto_optimize to compress errors (95%+ reduction)."}'
+  exit 0
+fi
+
+if echo "$TOOL_RESPONSE" | grep -qiE "(\\[INFO\\]|\\[ERROR\\]|\\[WARN\\]|\\[DEBUG\\]|[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2})"; then
+  echo '{"systemMessage": "TIP: Large log output detected. Use mcp__ctxopt__summarize_logs to compress (80-90% reduction)."}'
+  exit 0
+fi
+
+# Generic large output
+echo '{"systemMessage": "TIP: Large output ('$RESPONSE_SIZE' chars). Consider using mcp__ctxopt__auto_optimize for compression (40-60% reduction)."}'
+exit 0
+`;
+const PROMPT_INJECT_SCRIPT = `#!/bin/bash
+# CtxOpt - UserPromptSubmit Hook
+# Injects MCP tool reminders at the start of each prompt
+
+cat << 'EOF'
+<user-prompt-submit-hook>
+CTXOPT REMINDER: Use MCP tools for token optimization:
+- Code files: mcp__ctxopt__smart_file_read (50-70% savings vs Read)
+- Build/test output: mcp__ctxopt__auto_optimize
+- Session stats: mcp__ctxopt__session_stats
+</user-prompt-submit-hook>
+EOF
+exit 0
+`;
+function createHooksConfig() {
+    return {
+        hooks: {
+            UserPromptSubmit: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: '"$CLAUDE_PROJECT_DIR/.claude/hooks/prompt-inject.sh"',
+                            timeout: 2,
+                        },
+                    ],
+                },
+            ],
+            PreToolUse: [
+                {
+                    matcher: "Read",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: '"$CLAUDE_PROJECT_DIR/.claude/hooks/pre-read-check.sh"',
+                            timeout: 2,
+                        },
+                    ],
+                },
+            ],
+            PostToolUse: [
+                {
+                    matcher: "Bash",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: '"$CLAUDE_PROJECT_DIR/.claude/hooks/post-bash-remind.sh"',
+                            timeout: 5,
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+}
+export async function installHooks(options = {}) {
+    const projectDir = options.projectDir || process.cwd();
+    const force = options.force || false;
+    log(`\n${COLORS.bright}Installing CtxOpt hooks...${COLORS.reset}\n`);
+    // Check for jq dependency
+    info("Checking dependencies...");
+    const jqCheck = checkJqInstalled();
+    if (!jqCheck) {
+        warn("jq is not installed. Hooks require jq for JSON parsing.");
+        log(`\nInstall jq:`);
+        log(`  ${COLORS.dim}macOS:${COLORS.reset}   brew install jq`);
+        log(`  ${COLORS.dim}Ubuntu:${COLORS.reset}  sudo apt install jq`);
+        log(`  ${COLORS.dim}Windows:${COLORS.reset} choco install jq`);
+        log("");
+    }
+    // Create directories
+    const claudeDir = join(projectDir, ".claude");
+    const hooksDir = join(claudeDir, "hooks");
+    if (!existsSync(claudeDir)) {
+        mkdirSync(claudeDir, { recursive: true });
+        info(`Created ${COLORS.dim}.claude/${COLORS.reset}`);
+    }
+    if (!existsSync(hooksDir)) {
+        mkdirSync(hooksDir, { recursive: true });
+        info(`Created ${COLORS.dim}.claude/hooks/${COLORS.reset}`);
+    }
+    // Write hook scripts
+    const hookFiles = {
+        "pre-read-check.sh": PRE_READ_CHECK_SCRIPT,
+        "post-bash-remind.sh": POST_BASH_REMIND_SCRIPT,
+        "prompt-inject.sh": PROMPT_INJECT_SCRIPT,
+    };
+    let scriptsWritten = 0;
+    for (const [filename, content] of Object.entries(hookFiles)) {
+        const filepath = join(hooksDir, filename);
+        if (existsSync(filepath) && !force) {
+            warn(`Skipped ${filename} (already exists, use --force to overwrite)`);
+            continue;
+        }
+        writeFileSync(filepath, content, "utf-8");
+        chmodSync(filepath, 0o755); // Make executable
+        success(`Created ${COLORS.dim}.claude/hooks/${COLORS.reset}${filename}`);
+        scriptsWritten++;
+    }
+    // Update settings.local.json
+    const settingsPath = join(claudeDir, "settings.local.json");
+    let settingsUpdated = false;
+    try {
+        let existingSettings = {};
+        if (existsSync(settingsPath)) {
+            existingSettings = (await readJSONFile(settingsPath)) || {};
+        }
+        const hooksConfig = createHooksConfig();
+        // Merge hooks config with existing settings
+        const newSettings = {
+            ...existingSettings,
+            hooks: {
+                ...(existingSettings.hooks || {}),
+                ...hooksConfig.hooks,
+            },
+        };
+        await writeJSONFile(settingsPath, newSettings);
+        success(`Updated ${COLORS.dim}.claude/${COLORS.reset}settings.local.json`);
+        settingsUpdated = true;
+    }
+    catch (err) {
+        error(`Failed to update settings.local.json: ${err}`);
+    }
+    // Summary
+    log("\n" + "─".repeat(50));
+    if (scriptsWritten > 0 || settingsUpdated) {
+        success("Hooks installed successfully!");
+        log(`\n${COLORS.dim}What the hooks do:${COLORS.reset}`);
+        log(`  • ${COLORS.yellow}PreToolUse[Read]${COLORS.reset}     Suggests smart_file_read for code files`);
+        log(`  • ${COLORS.yellow}PostToolUse[Bash]${COLORS.reset}    Suggests compression for large outputs`);
+        log(`  • ${COLORS.yellow}UserPromptSubmit${COLORS.reset}     Reminds to use MCP tools`);
+        log(`\n${COLORS.dim}Token savings:${COLORS.reset}`);
+        log(`  • smart_file_read:  50-70% reduction vs Read`);
+        log(`  • auto_optimize:    95%+ reduction on build errors`);
+        log(`  • summarize_logs:   80-90% reduction on logs\n`);
+        return true;
+    }
+    else {
+        warn("No changes made. Use --force to overwrite existing files.");
+        return false;
+    }
+}
+function checkJqInstalled() {
+    try {
+        const { execSync } = require("child_process");
+        execSync("jq --version", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+export { setup, parseSetupArgs, type SetupOptions } from "./setup.js";
+export { doctor } from "./doctor.js";
+export { installHooks, type InstallHooksOptions } from "./hooks.js";
+export * from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACpE,cAAc,YAAY,CAAC"}

package/dist/cli/index.js

@@ -0,0 +1,4 @@
+export { setup, parseSetupArgs } from "./setup.js";
+export { doctor } from "./doctor.js";
+export { installHooks } from "./hooks.js";
+export * from "./utils.js";

package/dist/cli/setup.d.ts

@@ -0,0 +1,10 @@
+export interface SetupOptions {
+    claude?: boolean;
+    cursor?: boolean;
+    windsurf?: boolean;
+    force?: boolean;
+    hooks?: boolean;
+}
+export declare function setup(options?: SetupOptions): Promise<void>;
+export declare function parseSetupArgs(args: string[]): SetupOptions;
+//# sourceMappingURL=setup.d.ts.map

package/dist/cli/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/cli/setup.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAyBD,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA4ErE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,YAAY,CAyB3D"}

package/dist/cli/setup.js

@@ -0,0 +1,117 @@
+import { detectInstalledIDEs, readJSONFile, writeJSONFile, getMCPServerConfig, isCtxOptConfigured, success, warn, error, info, log, COLORS, } from "./utils.js";
+import { installHooks } from "./hooks.js";
+function configureIDE(ide, config, force) {
+    log(`\nConfiguring ${COLORS.bright}${config.name}${COLORS.reset}...`);
+    const existingConfig = readJSONFile(config.configPath) || {};
+    if (isCtxOptConfigured(existingConfig) && !force) {
+        warn(`CtxOpt already configured in ${config.name}. Use --force to overwrite.`);
+        return true;
+    }
+    const mcpServers = existingConfig.mcpServers || {};
+    mcpServers.ctxopt = getMCPServerConfig();
+    existingConfig.mcpServers = mcpServers;
+    if (writeJSONFile(config.configPath, existingConfig)) {
+        success(`Configured ${config.name} at ${config.configPath}`);
+        return true;
+    }
+    else {
+        error(`Failed to write config to ${config.configPath}`);
+        return false;
+    }
+}
+export async function setup(options = {}) {
+    log(`\n${COLORS.bright}${COLORS.cyan}CtxOpt MCP Server Setup${COLORS.reset}\n`);
+    const ideConfigs = detectInstalledIDEs();
+    const specificIDEs = options.claude || options.cursor || options.windsurf;
+    const hooksOnly = options.hooks && !specificIDEs;
+    // If --hooks only (no IDE specified), just install hooks
+    if (hooksOnly) {
+        await installHooks({ force: options.force });
+        return;
+    }
+    const idesToConfigure = [];
+    if (specificIDEs) {
+        if (options.claude)
+            idesToConfigure.push("claude");
+        if (options.cursor)
+            idesToConfigure.push("cursor");
+        if (options.windsurf)
+            idesToConfigure.push("windsurf");
+    }
+    else {
+        // Auto-detect installed IDEs
+        for (const [ide, config] of Object.entries(ideConfigs)) {
+            if (config.detected) {
+                idesToConfigure.push(ide);
+            }
+        }
+    }
+    if (idesToConfigure.length === 0 && !options.hooks) {
+        warn("No supported IDEs detected.");
+        log("\nSupported IDEs:");
+        log("  • Claude Code");
+        log("  • Cursor");
+        log("  • Windsurf");
+        log("\nYou can manually configure by running:");
+        log("  ctxopt-mcp setup --claude");
+        log("  ctxopt-mcp setup --cursor");
+        log("  ctxopt-mcp setup --windsurf");
+        return;
+    }
+    if (idesToConfigure.length > 0) {
+        info(`Detected IDEs: ${idesToConfigure.map((ide) => ideConfigs[ide].name).join(", ")}`);
+        let successCount = 0;
+        let failCount = 0;
+        for (const ide of idesToConfigure) {
+            const result = configureIDE(ide, ideConfigs[ide], options.force || false);
+            if (result) {
+                successCount++;
+            }
+            else {
+                failCount++;
+            }
+        }
+        log("\n" + "─".repeat(50));
+        if (successCount > 0 && failCount === 0) {
+            success(`Setup complete! Configured ${successCount} IDE(s).`);
+        }
+        else if (successCount > 0) {
+            warn(`Partially complete. ${successCount} succeeded, ${failCount} failed.`);
+        }
+        else {
+            error("Setup failed. No IDEs were configured.");
+        }
+    }
+    // Install hooks if requested
+    if (options.hooks) {
+        await installHooks({ force: options.force });
+    }
+    log(`\n${COLORS.dim}Next steps:${COLORS.reset}`);
+    log("  1. Restart your IDE to load the MCP server");
+    log("  2. Run 'ctxopt-mcp doctor' to verify the installation");
+    log(`  3. Visit ${COLORS.cyan}https://ctxopt.dev/docs${COLORS.reset} for documentation\n`);
+}
+export function parseSetupArgs(args) {
+    const options = {};
+    for (const arg of args) {
+        switch (arg) {
+            case "--claude":
+                options.claude = true;
+                break;
+            case "--cursor":
+                options.cursor = true;
+                break;
+            case "--windsurf":
+                options.windsurf = true;
+                break;
+            case "--force":
+            case "-f":
+                options.force = true;
+                break;
+            case "--hooks":
+                options.hooks = true;
+                break;
+        }
+    }
+    return options;
+}

package/dist/cli/utils.d.ts

@@ -0,0 +1,30 @@
+export type IDE = "claude" | "cursor" | "windsurf";
+export interface IDEConfig {
+    name: string;
+    configPath: string;
+    configKey: string;
+    detected: boolean;
+}
+export declare const COLORS: {
+    reset: string;
+    bright: string;
+    dim: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    red: string;
+    cyan: string;
+};
+export declare function log(message: string): void;
+export declare function success(message: string): void;
+export declare function warn(message: string): void;
+export declare function error(message: string): void;
+export declare function info(message: string): void;
+export declare function getIDEConfigPaths(): Record<IDE, IDEConfig>;
+export declare function detectInstalledIDEs(): Record<IDE, IDEConfig>;
+export declare function readJSONFile(path: string): Record<string, unknown> | null;
+export declare function writeJSONFile(path: string, data: Record<string, unknown>): boolean;
+export declare function getMCPServerConfig(): Record<string, unknown>;
+export declare function isCtxOptConfigured(config: Record<string, unknown> | null): boolean;
+export declare function getPackageVersion(): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/cli/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/cli/utils.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,GAAG,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEnD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,MAAM;;;;;;;;;CASlB,CAAC;AAEF,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEzC;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7C;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE3C;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAAC,GAAG,EAAE,SAAS,CAAC,CAgC1D;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAAC,GAAG,EAAE,SAAS,CAAC,CAS5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAUzE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAWlF;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAM5D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,OAAO,CAIlF;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAQ1C"}

package/dist/cli/utils.js

@@ -0,0 +1,116 @@
+import { homedir, platform } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+export const COLORS = {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+};
+export function log(message) {
+    console.log(message);
+}
+export function success(message) {
+    console.log(`${COLORS.green}✓${COLORS.reset} ${message}`);
+}
+export function warn(message) {
+    console.log(`${COLORS.yellow}⚠${COLORS.reset} ${message}`);
+}
+export function error(message) {
+    console.log(`${COLORS.red}✗${COLORS.reset} ${message}`);
+}
+export function info(message) {
+    console.log(`${COLORS.blue}ℹ${COLORS.reset} ${message}`);
+}
+export function getIDEConfigPaths() {
+    const home = homedir();
+    const isWindows = platform() === "win32";
+    return {
+        claude: {
+            name: "Claude Code",
+            configPath: isWindows
+                ? join(home, "AppData", "Roaming", "claude", "settings.json")
+                : join(home, ".claude", "settings.json"),
+            configKey: "mcpServers",
+            detected: false,
+        },
+        cursor: {
+            name: "Cursor",
+            configPath: isWindows
+                ? join(home, "AppData", "Roaming", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json")
+                : platform() === "darwin"
+                    ? join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json")
+                    : join(home, ".config", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json"),
+            configKey: "mcpServers",
+            detected: false,
+        },
+        windsurf: {
+            name: "Windsurf",
+            configPath: isWindows
+                ? join(home, "AppData", "Roaming", "windsurf", "settings.json")
+                : join(home, ".windsurf", "settings.json"),
+            configKey: "mcpServers",
+            detected: false,
+        },
+    };
+}
+export function detectInstalledIDEs() {
+    const configs = getIDEConfigPaths();
+    for (const [key, config] of Object.entries(configs)) {
+        const configDir = join(config.configPath, "..");
+        config.detected = existsSync(configDir);
+    }
+    return configs;
+}
+export function readJSONFile(path) {
+    try {
+        if (!existsSync(path)) {
+            return null;
+        }
+        const content = readFileSync(path, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeJSONFile(path, data) {
+    try {
+        const dir = join(path, "..");
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getMCPServerConfig() {
+    return {
+        command: "ctxopt-mcp",
+        args: ["serve"],
+        env: {},
+    };
+}
+export function isCtxOptConfigured(config) {
+    if (!config)
+        return false;
+    const mcpServers = config.mcpServers;
+    return mcpServers?.ctxopt !== undefined;
+}
+export function getPackageVersion() {
+    try {
+        const pkgPath = join(import.meta.dirname, "..", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version || "0.1.0";
+    }
+    catch {
+        return "0.1.0";
+    }
+}

package/dist/compressors/config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Config Compressor
+ *
+ * Specialized compressor for configuration files (JSON, YAML-like).
+ * Summarizes nested objects and arrays while preserving structure.
+ */
+import type { Compressor } from "./types.js";
+export declare const configCompressor: Compressor;
+//# sourceMappingURL=config.d.ts.map