frogo 0.1.0

package/README.md

@@ -0,0 +1,79 @@
+# Frogo
+Production incident investigator CLI that reconstructs cross-service failure timelines and produces a deterministic root-cause hypothesis, with optional MCP-powered log exploration.
+
+## Install
+```bash
+npx frogo
+```
+
+Or install globally:
+```bash
+npm install -g frogo
+```
+
+## Quickstart
+1. Configure integrations and the model:
+   ```bash
+   npx frogo configure
+   ```
+2. Run the agent chat:
+   ```bash
+   npx frogo
+   ```
+3. Run deterministic scans:
+   ```bash
+   npx frogo scan
+   npx frogo debug "why did my worker restart?"
+   ```
+
+## Commands
+- `frogo`  
+  Starts the agent chat (ai-sdk). Uses MCP tools when configured.
+- `frogo configure`  
+  Interactive configuration for Vercel, Trigger.dev, Datadog, LangSmith, and the LLM provider.
+- `frogo scan`  
+  Deterministic investigation over the default time window.
+- `frogo debug "<query>"`  
+  Narrow-window deterministic investigation with a user query bias.
+- `frogo mcp login langsmith`  
+  Store LangSmith MCP credentials.
+
+## Configuration
+Frogo reads from:
+- Project config: `.frogo.json`
+- Global config: `~/.frogo/config.json`
+
+### LLM provider
+Frogo does not store provider API keys in config. Set:
+```bash
+export FROGO_AI_API_KEY="..."
+```
+
+### LangSmith MCP
+Use the hosted MCP server:
+```
+https://langsmith-mcp-server.onrender.com/mcp
+```
+
+Frogo sends your key as the `LANGSMITH-API-KEY` header.
+
+### Datadog MCP
+Frogo can connect to a Datadog MCP server via stdio. Provide:
+```json
+{
+  "datadog": {
+    "apiKey": "...",
+    "appKey": "...",
+    "command": "datadog-mcp-server"
+  }
+}
+```
+
+## Philosophy
+- Deterministic pattern engine first
+- LLM explains, never decides root cause
+- Normalized events only (no raw logs sent to the model)
+- Built to extend with more connectors and patterns
+
+## License
+MIT

package/dist/agent/launch.js

@@ -0,0 +1,384 @@
+import "dotenv/config";
+import readline from "node:readline/promises";
+import crypto from "node:crypto";
+import chalk from "chalk";
+import { stdin as input, stdout as output } from "node:process";
+import { ToolLoopAgent, stepCountIs } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { loadConfig } from "../config/load.js";
+const DEFAULT_SYSTEM_PROMPT = "You are Frogo, a deterministic incident investigator. Respond concisely, cite evidence, and avoid hallucinations. " +
+    "If the user says 'do a pass' or 'anything you can get', fetch a minimal overview: projects, recent runs, datasets, and prompts (if available) " +
+    "using MCP tools, then summarize what you found.";
+const DATADOG_MCP_COMMAND = "datadog-mcp-server";
+function buildProviderContext(config) {
+    const apiKey = process.env.FROGO_AI_API_KEY?.trim();
+    if (!apiKey) {
+        console.error("Set FROGO_AI_API_KEY (or add it to your .env) before running Frogo.");
+        return null;
+    }
+    const providerName = (config.llmProvider?.provider ?? process.env.FROGO_AI_PROVIDER ?? "openai").toLowerCase();
+    const modelId = config.llmProvider?.model ?? process.env.FROGO_AI_MODEL ?? "gpt-4o-mini";
+    const endpoint = config.llmProvider?.endpoint ?? process.env.FROGO_AI_ENDPOINT;
+    const systemPrompt = config.llmProvider?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    let languageModel;
+    if (providerName === "anthropic") {
+        const provider = createAnthropic({ apiKey, baseURL: endpoint });
+        languageModel = provider(modelId);
+    }
+    else {
+        const provider = createOpenAI({ apiKey, baseURL: endpoint });
+        languageModel = provider(modelId);
+    }
+    return { languageModel, systemPrompt };
+}
+function prefersSse(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.message.toLowerCase().includes("does not support http transport");
+}
+async function createLangSmithClient(langsmith) {
+    const headers = {
+        "LANGSMITH-API-KEY": langsmith.apiKey
+    };
+    if (langsmith.workspaceKey) {
+        headers["LANGSMITH-WORKSPACE-ID"] = langsmith.workspaceKey;
+    }
+    const baseConfig = {
+        headers
+    };
+    try {
+        return await createMCPClient({
+            transport: {
+                type: "http",
+                url: langsmith.mcpUrl,
+                ...baseConfig
+            }
+        });
+    }
+    catch (error) {
+        if (prefersSse(error)) {
+            return await createMCPClient({
+                transport: {
+                    type: "sse",
+                    url: langsmith.mcpUrl,
+                    ...baseConfig
+                }
+            });
+        }
+        throw error;
+    }
+}
+async function buildLangSmithToolContext(config) {
+    const langsmith = config.langsmith;
+    if (!langsmith?.apiKey || !langsmith?.mcpUrl) {
+        return null;
+    }
+    try {
+        const client = await createLangSmithClient(langsmith);
+        const tools = await client.tools();
+        return { name: "LangSmith", tools, client };
+    }
+    catch (error) {
+        console.error("LangSmith MCP initialization failed:", error);
+        return null;
+    }
+}
+async function buildDatadogToolContext(config) {
+    const datadog = config.datadog;
+    if (!datadog?.apiKey || !datadog?.appKey) {
+        return null;
+    }
+    const env = {
+        DD_API_KEY: datadog.apiKey,
+        DD_APP_KEY: datadog.appKey,
+        DD_SITE: datadog.site ?? process.env.DD_SITE ?? "datadoghq.com"
+    };
+    if (datadog.logsSite) {
+        env.DD_LOGS_SITE = datadog.logsSite;
+    }
+    if (datadog.metricsSite) {
+        env.DD_METRICS_SITE = datadog.metricsSite;
+    }
+    const transport = new StdioClientTransport({
+        command: datadog.command ?? DATADOG_MCP_COMMAND,
+        args: datadog.args ?? [],
+        env,
+        stderr: "inherit"
+    });
+    try {
+        const client = await createMCPClient({
+            transport,
+            name: "frogo-datadog",
+            version: "0.1.0"
+        });
+        const tools = await client.tools();
+        return { name: "Datadog", tools, client };
+    }
+    catch (error) {
+        console.error("Datadog MCP initialization failed:", error);
+        await transport.close().catch(() => {
+            /* ignore */
+        });
+        return null;
+    }
+}
+async function buildMcpToolContexts(config) {
+    const contexts = [];
+    const langsmithContext = await buildLangSmithToolContext(config);
+    if (langsmithContext) {
+        contexts.push(langsmithContext);
+    }
+    const datadogContext = await buildDatadogToolContext(config);
+    if (datadogContext) {
+        contexts.push(datadogContext);
+    }
+    return contexts;
+}
+function combineToolSets(contexts) {
+    return contexts.reduce((acc, context) => ({ ...acc, ...context.tools }), {});
+}
+async function cleanupMcpContexts(contexts) {
+    await Promise.all(contexts.map(async (context) => {
+        try {
+            await context.client.close();
+        }
+        catch (error) {
+            console.error(`Failed to close ${context.name} MCP client:`, error);
+        }
+    }));
+}
+function createSpinner(label = "thinking") {
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧"];
+    let index = 0;
+    let handle;
+    const isTty = Boolean(process.stdout.isTTY);
+    const render = () => {
+        const frame = frames[index];
+        index = (index + 1) % frames.length;
+        process.stdout.write(`\r${chalk.gray(frame)} ${chalk.dim(label)}`);
+    };
+    return {
+        start() {
+            if (!isTty) {
+                process.stdout.write(`${chalk.dim(label)}...\n`);
+                return;
+            }
+            render();
+            handle = setInterval(render, 80);
+        },
+        stop() {
+            if (!isTty) {
+                return;
+            }
+            if (handle) {
+                clearInterval(handle);
+                handle = undefined;
+            }
+            process.stdout.write("\r");
+            process.stdout.write(" ".repeat(32));
+            process.stdout.write("\r");
+        }
+    };
+}
+function cleanAssistantOutput(content) {
+    return content.replace(/^Agent:\s*/i, "").trim();
+}
+function renderBanner(context, mcpContexts) {
+    const sessionId = crypto.randomBytes(8).toString("hex");
+    const workdir = process.cwd();
+    const providerName = context.languageModel.modelId ?? context.languageModel?.model ?? "unknown";
+    const providerLabel = context.languageModel?.provider ?? "openai";
+    const mcpLabel = mcpContexts.length ? mcpContexts.map((item) => item.name).join(", ") : "none";
+    const header = "🐸 Frogo CLI";
+    const headerLine = `│ ● ${header} │`;
+    const sessionLines = [
+        `│ session: ${sessionId} │`,
+        `│ ↳ workdir: ${workdir} │`,
+        `│ ↳ model: ${providerName} │`,
+        `│ ↳ provider: ${providerLabel} │`,
+        `│ ↳ mcp: ${mcpLabel} │`
+    ];
+    const headerWidth = Math.max(headerLine.length, ...sessionLines.map((line) => line.length));
+    const drawLine = (text) => {
+        const padded = text.padEnd(headerWidth - 1, " ");
+        return `${padded}│`;
+    };
+    const top = `╭${"─".repeat(headerWidth - 1)}╮`;
+    const bottom = `╰${"─".repeat(headerWidth - 1)}╯`;
+    console.log(chalk.gray(top));
+    console.log(chalk.gray(drawLine(headerLine)));
+    console.log(chalk.gray(bottom));
+    console.log(chalk.gray(top));
+    sessionLines.forEach((line) => console.log(chalk.gray(drawLine(line))));
+    console.log(chalk.gray(bottom));
+}
+function renderAssistantPrefix() {
+    process.stdout.write(`${chalk.green("🐸")} `);
+}
+function formatToolPayload(payload, max = 400) {
+    try {
+        const raw = JSON.stringify(payload);
+        if (raw.length <= max) {
+            return raw;
+        }
+        return `${raw.slice(0, max)}…`;
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+export async function runAgentChat() {
+    const config = await loadConfig();
+    const context = buildProviderContext(config);
+    if (!context) {
+        process.exit(1);
+    }
+    const mcpContexts = await buildMcpToolContexts(config);
+    renderBanner(context, mcpContexts);
+    const toolSet = combineToolSets(mcpContexts);
+    const agent = new ToolLoopAgent({
+        id: "frogo-agent",
+        model: context.languageModel,
+        instructions: context.systemPrompt,
+        tools: Object.keys(toolSet).length ? toolSet : undefined,
+        stopWhen: stepCountIs(1000)
+    });
+    const rl = readline.createInterface({ input, output });
+    const spinner = createSpinner();
+    const conversation = [];
+    let activeAbort = null;
+    let isGenerating = false;
+    console.log(chalk.dim("Type your question and press enter (Ctrl+C to exit)."));
+    try {
+        rl.on("SIGINT", () => {
+            if (isGenerating && activeAbort) {
+                activeAbort.abort();
+                process.stdout.write(`\n${chalk.dim("↳ you canceled the current response. Ask another question when ready.")}\n`);
+                return;
+            }
+            rl.close();
+        });
+        while (true) {
+            let question;
+            try {
+                question = await rl.question(`${chalk.cyan("›")} `);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === "SIGINT") {
+                    break;
+                }
+                throw error;
+            }
+            const trimmed = question.trim();
+            if (!trimmed) {
+                continue;
+            }
+            conversation.push({ role: "user", content: trimmed });
+            spinner.start();
+            isGenerating = true;
+            activeAbort = new AbortController();
+            let spinnerActive = true;
+            let assistantReply = "";
+            let prefixPrinted = false;
+            let lineOpen = false;
+            const ensurePrefix = () => {
+                if (!prefixPrinted) {
+                    renderAssistantPrefix();
+                    prefixPrinted = true;
+                    lineOpen = true;
+                }
+            };
+            const ensureNewline = () => {
+                if (lineOpen) {
+                    process.stdout.write("\n");
+                    lineOpen = false;
+                    prefixPrinted = false;
+                }
+            };
+            try {
+                const streamResult = await agent.stream({
+                    messages: conversation,
+                    abortSignal: activeAbort.signal
+                });
+                for await (const part of streamResult.fullStream) {
+                    switch (part.type) {
+                        case "text-delta": {
+                            if (spinnerActive) {
+                                spinner.stop();
+                                spinnerActive = false;
+                                ensurePrefix();
+                            }
+                            ensurePrefix();
+                            process.stdout.write(part.text);
+                            assistantReply += part.text;
+                            break;
+                        }
+                        case "tool-call": {
+                            if (spinnerActive) {
+                                spinner.stop();
+                                spinnerActive = false;
+                            }
+                            ensureNewline();
+                            const payload = formatToolPayload(part.input);
+                            process.stdout.write(`${chalk.dim("↳ tool call")} ${chalk.cyan(part.toolName)} ${chalk.dim(payload)}\n`);
+                            break;
+                        }
+                        case "tool-result": {
+                            ensureNewline();
+                            const payload = formatToolPayload(part.output);
+                            process.stdout.write(`${chalk.dim("↳ tool result")} ${chalk.cyan(part.toolName)} ${chalk.dim(payload)}\n`);
+                            break;
+                        }
+                        case "tool-error": {
+                            ensureNewline();
+                            process.stdout.write(`${chalk.red("↳ tool error")} ${chalk.cyan(part.toolName)} ${chalk.dim(String(part.error))}\n`);
+                            break;
+                        }
+                        case "tool-approval-request": {
+                            ensureNewline();
+                            process.stdout.write(`${chalk.yellow("↳ tool approval")} ${chalk.cyan(part.toolCall.toolName)}\n`);
+                            break;
+                        }
+                        case "tool-output-denied": {
+                            ensureNewline();
+                            process.stdout.write(`${chalk.yellow("↳ tool output denied")} ${chalk.cyan(part.toolName)}\n`);
+                            break;
+                        }
+                        default:
+                            break;
+                    }
+                }
+                if (spinnerActive) {
+                    spinner.stop();
+                }
+                process.stdout.write("\n");
+                const cleaned = cleanAssistantOutput(assistantReply);
+                if (cleaned) {
+                    conversation.push({ role: "assistant", content: cleaned });
+                }
+            }
+            catch (error) {
+                spinner.stop();
+                if (activeAbort?.signal.aborted) {
+                    console.log(`\n${chalk.dim("↳ you canceled the current response. Ask another question when ready.")}`);
+                }
+                else {
+                    console.error("Agent call failed:", error);
+                    break;
+                }
+            }
+            finally {
+                isGenerating = false;
+                activeAbort = null;
+            }
+        }
+    }
+    finally {
+        rl.close();
+        await cleanupMcpContexts(mcpContexts);
+    }
+}

package/dist/cli/commands/configure.js

@@ -0,0 +1,243 @@
+import { Command } from "commander";
+import prompts from "prompts";
+import { loadConfig } from "../../config/load.js";
+import { saveConfig } from "../../config/save.js";
+const menuChoices = [
+    { title: "Vercel", value: "vercel" },
+    { title: "Trigger.dev", value: "trigger" },
+    { title: "Datadog", value: "datadog" },
+    { title: "LangSmith", value: "langsmith" },
+    { title: "LLM provider", value: "llmProvider" },
+    { title: "Show configuration", value: "show" },
+    { title: "Done", value: "done" }
+];
+const promptCredentials = async (questions) => {
+    const answers = (await prompts(questions));
+    return answers;
+};
+const vqlQuestions = [
+    {
+        type: "text",
+        name: "vercelToken",
+        message: "Vercel token",
+        initial: ""
+    }
+];
+const triggerQuestions = [
+    {
+        type: "text",
+        name: "triggerToken",
+        message: "Trigger.dev API key",
+        initial: ""
+    }
+];
+const datadogQuestions = [
+    {
+        type: "text",
+        name: "apiKey",
+        message: "Datadog API key for MCP",
+        initial: ""
+    },
+    {
+        type: "text",
+        name: "appKey",
+        message: "Datadog Application key",
+        initial: ""
+    },
+    {
+        type: "text",
+        name: "site",
+        message: "Datadog site",
+        initial: "datadoghq.com"
+    },
+    {
+        type: "text",
+        name: "logsSite",
+        message: "Datadog logs site (optional)",
+        initial: ""
+    },
+    {
+        type: "text",
+        name: "metricsSite",
+        message: "Datadog metrics site (optional)",
+        initial: ""
+    },
+    {
+        type: "text",
+        name: "command",
+        message: "Datadog MCP command",
+        initial: "datadog-mcp-server"
+    },
+    {
+        type: "text",
+        name: "args",
+        message: "Additional args for Datadog command",
+        initial: ""
+    }
+];
+const langsmithQuestions = [
+    {
+        type: "text",
+        name: "apiKey",
+        message: "LangSmith API key",
+        initial: ""
+    },
+    {
+        type: "text",
+        name: "workspaceKey",
+        message: "LangSmith workspace ID (optional)",
+        initial: ""
+    },
+    {
+        type: "text",
+        name: "mcpUrl",
+        message: "LangSmith MCP URL",
+        initial: "https://langsmith-mcp-server.onrender.com/mcp"
+    }
+];
+const llmProviderChoices = [
+    { title: "openai", value: "openai" },
+    { title: "anthropic", value: "anthropic" },
+    { title: "custom", value: "custom" }
+];
+const llmProviderQuestions = [
+    {
+        type: "select",
+        name: "provider",
+        message: "LLM provider",
+        choices: llmProviderChoices,
+        initial: 0
+    },
+    {
+        type: "text",
+        name: "endpoint",
+        message: "Provider endpoint or MCP URL (optional)",
+        initial: "https://api.openai.com/v1"
+    },
+    {
+        type: "text",
+        name: "model",
+        message: "Default model",
+        initial: "gpt-4o-mini"
+    },
+    {
+        type: "text",
+        name: "systemPrompt",
+        message: "System prompt (optional)",
+        initial: "You are Frogo, an incident investigator. Answer concisely."
+    }
+];
+function trimOrUndefined(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+async function configureDatadog(config) {
+    const answers = await promptCredentials(datadogQuestions);
+    return {
+        ...config,
+        datadog: {
+            apiKey: trimOrUndefined(answers.apiKey),
+            appKey: trimOrUndefined(answers.appKey),
+            site: trimOrUndefined(answers.site),
+            logsSite: trimOrUndefined(answers.logsSite),
+            metricsSite: trimOrUndefined(answers.metricsSite),
+            command: trimOrUndefined(answers.command),
+            args: answers.args ? answers.args.split(" ").filter(Boolean) : undefined
+        }
+    };
+}
+async function configureLangSmith(config) {
+    const answers = await promptCredentials(langsmithQuestions);
+    return {
+        ...config,
+        langsmith: {
+            apiKey: trimOrUndefined(answers.apiKey),
+            workspaceKey: trimOrUndefined(answers.workspaceKey),
+            mcpUrl: trimOrUndefined(answers.mcpUrl)
+        }
+    };
+}
+async function configureLLMProvider(config) {
+    const answers = await promptCredentials(llmProviderQuestions);
+    return {
+        ...config,
+        llmProvider: {
+            provider: trimOrUndefined(answers.provider),
+            endpoint: trimOrUndefined(answers.endpoint),
+            model: trimOrUndefined(answers.model),
+            systemPrompt: trimOrUndefined(answers.systemPrompt)
+        }
+    };
+}
+async function showConfig(config) {
+    console.log("Current configuration:");
+    console.log(JSON.stringify(config, null, 2));
+}
+async function configure(cmd) {
+    let config = await loadConfig();
+    console.log("🐸 Frog configure — pick an integration to update");
+    while (true) {
+        const { choice } = (await promptCredentials([
+            {
+                type: "select",
+                name: "choice",
+                message: "What would you like to configure?",
+                choices: menuChoices
+            }
+        ]));
+        if (!choice) {
+            console.log("Configuration aborted.");
+            break;
+        }
+        if (choice === "done") {
+            await saveConfig(config);
+            console.log("🐸 Configuration saved.");
+            break;
+        }
+        if (choice === "show") {
+            await showConfig(config);
+            continue;
+        }
+        switch (choice) {
+            case "vercel":
+                config = {
+                    ...config,
+                    vercelToken: trimOrUndefined((await promptCredentials(vqlQuestions)).vercelToken)
+                };
+                await saveConfig(config);
+                console.log("✔ Vercel token updated.");
+                break;
+            case "trigger":
+                config = {
+                    ...config,
+                    triggerToken: trimOrUndefined((await promptCredentials(triggerQuestions)).triggerToken)
+                };
+                await saveConfig(config);
+                console.log("✔ Trigger.dev API key updated.");
+                break;
+            case "datadog":
+                config = await configureDatadog(config);
+                await saveConfig(config);
+                console.log("✔ Datadog MCP config updated.");
+                break;
+            case "langsmith":
+                config = await configureLangSmith(config);
+                await saveConfig(config);
+                console.log("✔ LangSmith MCP config updated.");
+                break;
+            case "llmProvider":
+                config = await configureLLMProvider(config);
+                await saveConfig(config);
+                console.log("✔ LLM provider updated.");
+                console.log("Set `FROGO_AI_API_KEY` (or place it in your `.env`) instead of saving the key to disk.");
+                break;
+            default:
+                console.log(`Unknown option: ${choice}`);
+        }
+    }
+}
+export const configureCommand = new Command("configure")
+    .description("connect integrations and save config")
+    .action(async () => configure(new Command()));