@kite-copilot/cli 1.0.0

package/dist/config.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Configuration management for Kite CLI
+ * Handles reading/writing credentials to ~/.kite/config.json
+ */
+export interface KiteConfig {
+    token: string;
+    org_id: string;
+    api_config_id: string;
+    email?: string;
+    org_name?: string;
+    backend_url: string;
+}
+/**
+ * Load configuration from ~/.kite/config.json
+ * @returns The config object or null if not found
+ */
+export declare function loadConfig(): KiteConfig | null;
+/**
+ * Save configuration to ~/.kite/config.json
+ * @param config - The configuration to save
+ */
+export declare function saveConfig(config: KiteConfig): void;
+/**
+ * Clear (delete) the configuration file
+ */
+export declare function clearConfig(): void;
+/**
+ * Check if user is logged in (valid config exists)
+ */
+export declare function isLoggedIn(): boolean;
+/**
+ * Get the config file path (for display purposes)
+ */
+export declare function getConfigPath(): string;
+/**
+ * Save rejected mappings to ~/.kite/rejected/<timestamp>_mapping.json
+ * @param data - The mapping data to save
+ * @returns The path where the file was saved
+ */
+export declare function saveRejectedMapping(data: unknown): string;
+/**
+ * Get the rejected mappings directory path
+ */
+export declare function getRejectedDir(): string;

package/dist/config.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Configuration management for Kite CLI
+ * Handles reading/writing credentials to ~/.kite/config.json
+ */
+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.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.clearConfig = clearConfig;
+exports.isLoggedIn = isLoggedIn;
+exports.getConfigPath = getConfigPath;
+exports.saveRejectedMapping = saveRejectedMapping;
+exports.getRejectedDir = getRejectedDir;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const CONFIG_DIR = path.join(os.homedir(), ".kite");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const REJECTED_DIR = path.join(CONFIG_DIR, "rejected");
+/**
+ * Ensure the config directory exists
+ */
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Load configuration from ~/.kite/config.json
+ * @returns The config object or null if not found
+ */
+function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_FILE)) {
+            return null;
+        }
+        const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save configuration to ~/.kite/config.json
+ * @param config - The configuration to save
+ */
+function saveConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
+        mode: 0o600, // Read/write for owner only
+    });
+}
+/**
+ * Clear (delete) the configuration file
+ */
+function clearConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            fs.unlinkSync(CONFIG_FILE);
+        }
+    }
+    catch {
+        // Ignore errors when clearing
+    }
+}
+/**
+ * Check if user is logged in (valid config exists)
+ */
+function isLoggedIn() {
+    const config = loadConfig();
+    return config !== null && !!config.token && !!config.org_id;
+}
+/**
+ * Get the config file path (for display purposes)
+ */
+function getConfigPath() {
+    return CONFIG_FILE;
+}
+/**
+ * Ensure the rejected directory exists
+ */
+function ensureRejectedDir() {
+    if (!fs.existsSync(REJECTED_DIR)) {
+        fs.mkdirSync(REJECTED_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Save rejected mappings to ~/.kite/rejected/<timestamp>_mapping.json
+ * @param data - The mapping data to save
+ * @returns The path where the file was saved
+ */
+function saveRejectedMapping(data) {
+    ensureRejectedDir();
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const filename = `${timestamp}_mapping.json`;
+    const filepath = path.join(REJECTED_DIR, filename);
+    fs.writeFileSync(filepath, JSON.stringify(data, null, 2), { mode: 0o600 });
+    return filepath;
+}
+/**
+ * Get the rejected mappings directory path
+ */
+function getRejectedDir() {
+    return REJECTED_DIR;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Kite CLI - Main Entry Point
+ *
+ * Commands:
+ *   kite login    - Authenticate with Kite
+ *   kite logout   - Clear stored credentials
+ *   kite map      - Analyze frontend codebase
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Kite CLI - Main Entry Point
+ *
+ * Commands:
+ *   kite login    - Authenticate with Kite
+ *   kite logout   - Clear stored credentials
+ *   kite map      - Analyze frontend codebase
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const readline = __importStar(require("node:readline"));
+const config_js_1 = require("./config.js");
+const login_js_1 = require("./login.js");
+const analyzer_js_1 = require("./analyzer.js");
+const program = new commander_1.Command();
+/**
+ * Prompt user for yes/no confirmation
+ */
+async function promptYesNo(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            resolve(normalized === "y" || normalized === "yes");
+        });
+    });
+}
+program
+    .name("kite")
+    .description("Kite CLI - Analyze frontend codebases and map API calls")
+    .version("1.0.0");
+// Login command
+program
+    .command("login")
+    .description("Authenticate with Kite")
+    .option("--backend-url <url>", "Kite backend URL")
+    .action(async (options) => {
+    await (0, login_js_1.login)(options.backendUrl);
+});
+// Logout command
+program
+    .command("logout")
+    .description("Clear stored credentials")
+    .action(async () => {
+    await (0, login_js_1.logout)();
+});
+// Map command - analyze frontend codebase
+program
+    .command("map")
+    .description("Analyze a frontend codebase to discover API mappings")
+    .argument("<path>", "Path to the frontend codebase")
+    .option("-o, --output <file>", "Output JSON file path (for local save)")
+    .option("-q, --quiet", "Suppress terminal visualization")
+    .option("-v, --verbose", "Show verbose debug output")
+    .option("--timeout <seconds>", "Analysis timeout in seconds", "300")
+    .option("--no-prompt", "Skip confirmation prompt and save locally")
+    .action(async (codebasePath, options) => {
+    const quiet = options.quiet || false;
+    const verbose = options.verbose || false;
+    const skipPrompt = options.prompt === false;
+    // Check Claude CLI is available
+    const spinner = (0, ora_1.default)();
+    if (!quiet) {
+        spinner.start("Checking Claude CLI...");
+    }
+    const claudeAvailable = await (0, analyzer_js_1.checkClaudeAvailable)();
+    if (!claudeAvailable) {
+        if (!quiet)
+            spinner.fail("Claude CLI not found");
+        console.log(chalk_1.default.red("\n✗ Claude CLI is required for analysis.\n"));
+        console.log(chalk_1.default.gray("  Install it with: npm install -g @anthropic-ai/claude-cli\n"));
+        process.exit(1);
+    }
+    if (!quiet)
+        spinner.succeed("Claude CLI found");
+    // Run analysis
+    if (!quiet) {
+        spinner.start(`Analyzing codebase: ${codebasePath}`);
+    }
+    if (verbose) {
+        console.log(chalk_1.default.gray(`[DEBUG] Path: ${codebasePath}`));
+        console.log(chalk_1.default.gray(`[DEBUG] Timeout: ${options.timeout}s`));
+    }
+    try {
+        const result = await (0, analyzer_js_1.analyzeWithClaude)(codebasePath, {
+            timeout: parseInt(options.timeout, 10),
+            verbose,
+        });
+        if (!quiet) {
+            spinner.succeed("Analysis complete");
+        }
+        if (verbose) {
+            console.log(chalk_1.default.gray(`[DEBUG] Found ${result.routes.length} routes`));
+            console.log(chalk_1.default.gray(`[DEBUG] Found ${result.api_calls.length} API calls`));
+            console.log(chalk_1.default.gray(`[DEBUG] Generated ${result.mappings.length} mappings`));
+        }
+        // Display results
+        if (!quiet) {
+            console.log();
+            console.log(chalk_1.default.bold("📊 Analysis Results"));
+            console.log(chalk_1.default.gray("─".repeat(40)));
+            // Routes
+            console.log(chalk_1.default.cyan(`\nRoutes (${result.routes.length}):`));
+            for (const route of result.routes) {
+                console.log(`  • ${route.route_name} → ${route.component_name}`);
+                console.log(chalk_1.default.gray(`    ${route.file_path}`));
+            }
+            // API Calls
+            console.log(chalk_1.default.cyan(`\nAPI Calls (${result.api_calls.length}):`));
+            for (const call of result.api_calls) {
+                console.log(`  • ${call.method} ${call.endpoint}`);
+                console.log(chalk_1.default.gray(`    ${call.component_file}`));
+            }
+            // Mappings
+            console.log(chalk_1.default.cyan(`\nMappings (${result.mappings.length}):`));
+            for (const mapping of result.mappings) {
+                console.log(`  • ${mapping.tool_name} → ${mapping.api_endpoint}`);
+                if (mapping.navigation_page) {
+                    console.log(chalk_1.default.gray(`    Page: ${mapping.navigation_page}`));
+                }
+            }
+            console.log();
+        }
+        // Summary
+        if (!quiet) {
+            console.log();
+            console.log(chalk_1.default.bold("Summary"));
+            console.log(chalk_1.default.gray("─".repeat(40)));
+            console.log(`  Routes:    ${result.routes.length}`);
+            console.log(`  API Calls: ${result.api_calls.length}`);
+            console.log(`  Mappings:  ${result.mappings.length}`);
+            console.log();
+        }
+        // Handle save decision
+        if (skipPrompt) {
+            // --no-prompt: save locally
+            const outputPath = options.output || "kite-mappings.json";
+            (0, analyzer_js_1.saveResultToFile)(result, outputPath);
+            if (!quiet) {
+                console.log(chalk_1.default.green(`✓ Saved mappings to: ${outputPath}`));
+            }
+        }
+        else {
+            // Prompt user for confirmation
+            console.log();
+            const shouldUpload = await promptYesNo(chalk_1.default.cyan("Save mappings to Kite? (y/n): "));
+            if (shouldUpload) {
+                // Check if logged in
+                if (!(0, config_js_1.isLoggedIn)()) {
+                    console.log(chalk_1.default.yellow("\n⚠ Not logged in. Run 'kite login' first to upload mappings."));
+                    // Save to rejected as fallback
+                    const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
+                    console.log(chalk_1.default.gray(`  Saved locally to: ${rejectedPath}\n`));
+                    process.exit(1);
+                }
+                const config = (0, config_js_1.loadConfig)();
+                if (!quiet) {
+                    spinner.start("Uploading mappings to Kite...");
+                }
+                try {
+                    const uploadResult = await (0, analyzer_js_1.uploadMappings)(result, {
+                        backendUrl: config.backend_url,
+                        token: config.token,
+                        orgId: config.org_id,
+                        apiConfigId: config.api_config_id,
+                    });
+                    if (!quiet) {
+                        spinner.succeed(`Uploaded ${uploadResult.mappings_uploaded} mappings ` +
+                            `(merged: ${uploadResult.mappings_merged}, skipped: ${uploadResult.mappings_skipped})`);
+                    }
+                }
+                catch (uploadError) {
+                    if (!quiet)
+                        spinner.fail("Upload failed");
+                    console.log(chalk_1.default.red(`\n✗ ${uploadError.message}`));
+                    // Save to rejected on upload failure
+                    const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
+                    console.log(chalk_1.default.gray(`  Saved locally to: ${rejectedPath}\n`));
+                    process.exit(1);
+                }
+            }
+            else {
+                // User declined - save to rejected folder
+                const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
+                if (!quiet) {
+                    console.log(chalk_1.default.yellow(`\n✓ Mappings saved locally to: ${rejectedPath}`));
+                }
+            }
+        }
+        console.log();
+    }
+    catch (error) {
+        if (!quiet)
+            spinner.fail("Analysis failed");
+        if (error instanceof analyzer_js_1.ClaudeNotFoundError) {
+            console.log(chalk_1.default.red(`\n✗ ${error.message}\n`));
+            console.log(chalk_1.default.gray("  Install Claude CLI: npm install -g @anthropic-ai/claude-cli\n"));
+        }
+        else if (error instanceof analyzer_js_1.ClaudeTimeoutError) {
+            console.log(chalk_1.default.red(`\n✗ ${error.message}\n`));
+            console.log(chalk_1.default.gray("  Try increasing the timeout with --timeout\n"));
+        }
+        else if (error instanceof analyzer_js_1.ClaudeParseError) {
+            console.log(chalk_1.default.red(`\n✗ Failed to parse Claude response\n`));
+            if (verbose) {
+                console.log(chalk_1.default.gray(`  ${error.message}\n`));
+            }
+        }
+        else if (error instanceof analyzer_js_1.AnalyzerError) {
+            console.log(chalk_1.default.red(`\n✗ ${error.message}\n`));
+        }
+        else {
+            console.log(chalk_1.default.red(`\n✗ ${error.message}\n`));
+        }
+        process.exit(1);
+    }
+});
+// Status command - show current login status
+program
+    .command("status")
+    .description("Show current login status")
+    .action(() => {
+    const config = (0, config_js_1.loadConfig)();
+    if (!config || !config.token) {
+        console.log(chalk_1.default.yellow("\n⚠ Not logged in\n"));
+        console.log(chalk_1.default.gray("  Run 'kite login' to authenticate.\n"));
+        return;
+    }
+    console.log(chalk_1.default.green("\n✓ Logged in\n"));
+    if (config.email) {
+        console.log(`  Email: ${chalk_1.default.bold(config.email)}`);
+    }
+    if (config.org_name) {
+        console.log(`  Organization: ${chalk_1.default.bold(config.org_name)}`);
+    }
+    console.log(`  Config: ${chalk_1.default.gray((0, config_js_1.getConfigPath)())}`);
+    console.log();
+});
+program.parse();

package/dist/login.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Login flow for Kite CLI
+ * Prompts for token only, fetches user info from backend
+ */
+/**
+ * Run the login flow
+ */
+export declare function login(backendUrl?: string): Promise<void>;
+/**
+ * Run the logout flow
+ */
+export declare function logout(): Promise<void>;

package/dist/login.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Login flow for Kite CLI
+ * Prompts for token only, fetches user info from backend
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+exports.logout = logout;
+const readline = __importStar(require("node:readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const config_js_1 = require("./config.js");
+const DEFAULT_BACKEND_URL = "http://0.0.0.0:5002";
+/**
+ * Prompt for user input (with optional masking)
+ */
+async function prompt(question, mask = false) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        // For masked input, we'd need to handle it differently
+        // For simplicity, we'll just use regular input
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Fetch user info from backend using the token
+ */
+async function fetchUserInfo(token, backendUrl) {
+    const url = `${backendUrl}/api/auth/me`;
+    console.log(chalk_1.default.gray("[DEBUG] Fetching user info from:", url));
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+    });
+    console.log(chalk_1.default.gray("[DEBUG] Response status:", response.status));
+    if (response.status === 401) {
+        throw new Error("Invalid token. Please check your token and try again.");
+    }
+    if (response.status === 403) {
+        throw new Error("Access denied. Your token may not have sufficient permissions.");
+    }
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to authenticate: ${response.status} ${text}`);
+    }
+    return (await response.json());
+}
+/**
+ * Run the login flow
+ */
+async function login(backendUrl) {
+    const url = DEFAULT_BACKEND_URL;
+    console.log(chalk_1.default.bold("\n🪁 Kite CLI Login\n"));
+    console.log(chalk_1.default.gray("Get your token from the Kite dashboard: https://app.kite.com/settings\n"));
+    // Prompt for token
+    const token = await prompt(chalk_1.default.cyan("? ") + "Enter your Kite token: ");
+    if (!token) {
+        console.log(chalk_1.default.red("\n✗ Token is required"));
+        process.exit(1);
+    }
+    // Fetch user info
+    const spinner = (0, ora_1.default)("Fetching account info...").start();
+    try {
+        const userInfo = await fetchUserInfo(token, url);
+        spinner.succeed("Account verified");
+        // Save config
+        const config = {
+            token,
+            org_id: userInfo.org_id,
+            api_config_id: userInfo.api_config_id,
+            email: userInfo.email,
+            org_name: userInfo.org_name,
+            backend_url: url,
+        };
+        (0, config_js_1.saveConfig)(config);
+        // Success message
+        console.log();
+        if (userInfo.email && userInfo.org_name) {
+            console.log(chalk_1.default.green(`✓ Logged in as ${chalk_1.default.bold(userInfo.email)} (${userInfo.org_name})`));
+        }
+        else if (userInfo.email) {
+            console.log(chalk_1.default.green(`✓ Logged in as ${chalk_1.default.bold(userInfo.email)}`));
+        }
+        else {
+            console.log(chalk_1.default.green("✓ Logged in successfully"));
+        }
+        console.log(chalk_1.default.gray(`  Credentials saved to ${(0, config_js_1.getConfigPath)()}`));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail("Authentication failed");
+        console.log();
+        console.log(chalk_1.default.red(`✗ ${error.message}`));
+        process.exit(1);
+    }
+}
+/**
+ * Run the logout flow
+ */
+async function logout() {
+    const { clearConfig } = await import("./config.js");
+    clearConfig();
+    console.log(chalk_1.default.green("\n✓ Logged out successfully\n"));
+}

package/dist/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * TypeScript interfaces for frontend analysis results
+ * Mirrors the Python dataclasses in models.py
+ */
+export interface FrontendRoute {
+    route_name: string;
+    file_path: string;
+    component_name: string;
+}
+export interface FrontendApiCall {
+    endpoint: string;
+    method: string;
+    component_file: string;
+    action_form_type: string | null;
+}
+export interface FrontendMapping {
+    tool_name: string;
+    api_endpoint: string;
+    navigation_page: string | null;
+    action_form_type: string | null;
+    frontend_component: string | null;
+    frontend_file_path: string | null;
+}
+export interface FrontendAnalysisResult {
+    version: string;
+    generated_at: string;
+    codebase_path: string;
+    routes: FrontendRoute[];
+    api_calls: FrontendApiCall[];
+    mappings: FrontendMapping[];
+}
+export interface AnalyzeOptions {
+    timeout?: number;
+    verbose?: boolean;
+    claudePath?: string;
+}
+export interface UploadResult {
+    success: boolean;
+    mappings_uploaded: number;
+    mappings_merged: number;
+    mappings_skipped: number;
+    message: string;
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * TypeScript interfaces for frontend analysis results
+ * Mirrors the Python dataclasses in models.py
+ */
+Object.defineProperty(exports, "__esModule", { value: true });