frogo 0.1.0

package/dist/cli/commands/debug.js

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { runInvestigation } from "../../core/investigator.js";
+export const debugCommand = new Command("debug")
+    .description("run deterministic investigation against a focused query")
+    .argument("query", "natural language prompt")
+    .action(async (query) => {
+    console.log(`🐸 Debugging query: ${query}`);
+    await runInvestigation({ windowMinutes: 15, query });
+});

package/dist/cli/commands/investigate.js

@@ -0,0 +1,50 @@
+import { loadConfig } from "../../config/load.js";
+import { VercelConnector } from "../../connectors/vercel.js";
+import { TriggerConnector } from "../../connectors/trigger.js";
+import { LocalConnector } from "../../connectors/local.js";
+import { DatadogConnector } from "../../connectors/datadog.js";
+import { correlateEvents } from "../../core/correlator.js";
+import { explainIncident } from "../../llm/explain.js";
+const DEFAULT_WINDOW_MINUTES = 15;
+function formatEvent(event) {
+    return `${event.timestamp.toISOString()} ${event.source} ${event.type}`;
+}
+async function runInvestigation(options = {}) {
+    const config = await loadConfig();
+    const windowMinutes = options.windowMinutes ?? DEFAULT_WINDOW_MINUTES;
+    const windowStart = new Date(Date.now() - windowMinutes * 60 * 1000);
+    const connectors = [
+        new VercelConnector(config),
+        new TriggerConnector(config),
+        new LocalConnector(config),
+        new DatadogConnector(config)
+    ];
+    console.log(`🐸 Scanning last ${windowMinutes} minutes...`);
+    const events = await Promise.all(connectors.map((connector) => connector.fetchEvents(windowStart)));
+    const flattened = events.flat();
+    const report = correlateEvents(flattened);
+    if (!report) {
+        console.log("🐸 No significant failure patterns detected.");
+        return;
+    }
+    const explanation = await explainIncident({
+        pattern: report.match.patternId,
+        timeline: report.timeline,
+        evidence: report.match.evidence,
+        confidence: report.match.confidence,
+        rootCauseEvent: report.match.rootCauseEvent,
+        query: options.query
+    });
+    console.log("Incident detected.");
+    console.log("Trigger:");
+    console.log(`- ${report.match.rootCauseEvent.type}`);
+    console.log("Cascade:");
+    report.match.evidence
+        .slice(1)
+        .forEach((event) => console.log(`→ ${formatEvent(event)}`));
+    console.log("Root Cause:");
+    console.log(`- ${explanation.explanation}`);
+    console.log(`Confidence: ${report.match.confidence.toFixed(2)}`);
+    console.log(`Suggested Fix: ${explanation.suggestion}`);
+}
+export { runInvestigation };

package/dist/cli/commands/mcp.js

@@ -0,0 +1,53 @@
+import { Command } from "commander";
+import prompts from "prompts";
+import { loadConfig } from "../../config/load.js";
+import { saveConfig } from "../../config/save.js";
+const LANGSMITH_SERVER = "langsmith";
+const langsmithQuestions = [
+    {
+        type: "text",
+        name: "apiKey",
+        message: "LangSmith API key (ls_api_key_... or lsv2_pt_...)",
+        validate: (value) => (value.trim() ? true : "API key is required")
+    },
+    {
+        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"
+    }
+];
+export const mcpCommand = new Command("mcp").description("manage MCP server integrations");
+mcpCommand
+    .command("login")
+    .description("store credentials for an MCP server, e.g. langsmith")
+    .argument("server", "name of the MCP server")
+    .action(async (server) => {
+    if (server.toLowerCase() !== LANGSMITH_SERVER) {
+        console.log(`Unsupported MCP server: ${server}. Try 'frogo mcp login langsmith'.`);
+        return;
+    }
+    const answers = (await prompts(langsmithQuestions));
+    if (!answers.apiKey) {
+        console.log("LangSmith login canceled.");
+        return;
+    }
+    const config = await loadConfig();
+    const updated = {
+        ...config,
+        langsmith: {
+            apiKey: answers.apiKey.trim(),
+            workspaceKey: answers.workspaceKey?.trim() || undefined,
+            mcpUrl: answers.mcpUrl?.trim() || undefined
+        }
+    };
+    await saveConfig(updated);
+    console.log("🐸 LangSmith MCP credentials saved.");
+    console.log("If you plan to use ai-sdk's mcp login CLI, run `npx ai-sdk mcp login langsmith` now.");
+});

package/dist/cli/commands/scan.js

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { runInvestigation } from "../../core/investigator.js";
+export const scanCommand = new Command("scan")
+    .description("run deterministic incident scan")
+    .action(() => runInvestigation());

package/dist/cli/index.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { configureCommand } from "./commands/configure.js";
+import { debugCommand } from "./commands/debug.js";
+import { scanCommand } from "./commands/scan.js";
+import { runAgentChat } from "../agent/launch.js";
+import { mcpCommand } from "./commands/mcp.js";
+const program = new Command();
+program.name("frogo");
+program.description("Frogo v0 — incident investigator CLI");
+program.version("0.1.0");
+program.addCommand(configureCommand);
+program.addCommand(scanCommand);
+program.addCommand(debugCommand);
+program.addCommand(mcpCommand);
+program.action(() => {
+    runAgentChat().catch((error) => {
+        console.error("Agent process failed:", error);
+        process.exit(1);
+    });
+});
+program.parse();

package/dist/config/load.js

@@ -0,0 +1,36 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+const PROJECT_CONFIG = ".frogo.json";
+const LEGACY_PROJECT_CONFIG = ".frog.json";
+const GLOBAL_DIR = path.join(os.homedir(), ".frogo");
+const LEGACY_GLOBAL_DIR = path.join(os.homedir(), ".frog");
+const GLOBAL_CONFIG = path.join(GLOBAL_DIR, "config.json");
+const LEGACY_GLOBAL_CONFIG = path.join(LEGACY_GLOBAL_DIR, "config.json");
+async function readJson(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function loadConfig() {
+    const localPaths = [path.join(process.cwd(), PROJECT_CONFIG), path.join(process.cwd(), LEGACY_PROJECT_CONFIG)];
+    for (const localPath of localPaths) {
+        const local = await readJson(localPath);
+        if (local) {
+            return local;
+        }
+    }
+    const globalPaths = [GLOBAL_CONFIG, LEGACY_GLOBAL_CONFIG];
+    for (const globalPath of globalPaths) {
+        const global = await readJson(globalPath);
+        if (global) {
+            return global;
+        }
+    }
+    return {};
+}

package/dist/config/save.js

@@ -0,0 +1,19 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+const PROJECT_CONFIG = ".frogo.json";
+const GLOBAL_DIR = path.join(os.homedir(), ".frogo");
+const GLOBAL_CONFIG = path.join(GLOBAL_DIR, "config.json");
+export async function saveConfig(config, options) {
+    const local = options?.local ?? true;
+    const global = options?.global ?? true;
+    const serialized = JSON.stringify(config, null, 2);
+    if (local) {
+        const localPath = path.join(process.cwd(), PROJECT_CONFIG);
+        await fs.writeFile(localPath, serialized, "utf-8");
+    }
+    if (global) {
+        await fs.mkdir(GLOBAL_DIR, { recursive: true });
+        await fs.writeFile(GLOBAL_CONFIG, serialized, "utf-8");
+    }
+}

package/dist/connectors/datadog.js

@@ -0,0 +1,113 @@
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+const DEFAULT_COMMAND = "datadog-mcp-server";
+const DEFAULT_QUERY = "status:error OR status:warn";
+const DEFAULT_LIMIT = 80;
+export class DatadogConnector {
+    constructor(config) {
+        this.config = config;
+        this.name = "datadog";
+    }
+    async fetchEvents(since) {
+        const datadog = this.config.datadog;
+        if (!datadog?.apiKey || !datadog?.appKey) {
+            return [];
+        }
+        const command = datadog.command ?? DEFAULT_COMMAND;
+        const args = datadog.args ?? [];
+        const env = { ...process.env };
+        env.DD_API_KEY = datadog.apiKey;
+        env.DD_APP_KEY = datadog.appKey;
+        env.DD_SITE = datadog.site ?? 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,
+            args,
+            env,
+            stderr: "inherit"
+        });
+        const client = new Client({ name: "frog-datadog-connector", version: "0.1.0" });
+        try {
+            await client.connect(transport);
+            const response = await client.callTool({
+                name: "search-logs",
+                arguments: {
+                    filter: {
+                        query: datadog.query ?? DEFAULT_QUERY,
+                        from: since.toISOString(),
+                        to: new Date().toISOString(),
+                        indexes: datadog.indexes
+                    },
+                    limit: datadog.limit ?? DEFAULT_LIMIT
+                }
+            });
+            const toolResponse = response;
+            const raw = toolResponse.content?.find((item) => item.type === "text")?.text;
+            if (!raw) {
+                return [];
+            }
+            const parsed = this.safeParse(raw);
+            if (!parsed) {
+                return [];
+            }
+            return (parsed.data ?? [])
+                .map((entry) => this.normalizeEntry(entry))
+                .filter((event) => event.timestamp.getTime() >= since.getTime());
+        }
+        catch (error) {
+            console.error("Datadog MCP fetch failed:", error);
+            return [];
+        }
+        finally {
+            await transport.close();
+        }
+    }
+    safeParse(raw) {
+        try {
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            console.error("Failed to parse Datadog search response", error);
+            return null;
+        }
+    }
+    normalizeEntry(entry) {
+        const attributes = entry.attributes ?? {};
+        const timestamp = attributes.timestamp ? new Date(attributes.timestamp) : new Date();
+        return {
+            source: "datadog",
+            type: attributes.service ? `${attributes.service}.log` : "datadog.log",
+            severity: mapSeverity(attributes.status),
+            timestamp,
+            metadata: {
+                id: entry.id,
+                message: attributes.message,
+                status: attributes.status,
+                service: attributes.service,
+                host: attributes.host,
+                logger: attributes.logger,
+                traceId: entry.relationships?.trace?.data?.id,
+                tags: attributes.tags,
+                raw: entry
+            }
+        };
+    }
+}
+function mapSeverity(status) {
+    if (!status) {
+        return "info";
+    }
+    const normalized = status.toLowerCase();
+    if (normalized === "error" || normalized === "critical" || normalized === "fatal") {
+        return "error";
+    }
+    if (normalized === "warn" || normalized === "warning") {
+        return "warn";
+    }
+    return "info";
+}

package/dist/connectors/demo-events.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDemoEvents = getDemoEvents;
+const now = Date.now();
+const minutesAgo = (minutes) => new Date(now - minutes * 60 * 1000);
+const DEMO_EVENTS = {
+    vercel: [
+        {
+            source: "vercel",
+            type: "function.timeout",
+            severity: "error",
+            timestamp: minutesAgo(12),
+            metadata: {
+                project: "runclaw",
+                functionName: "provision-worker",
+                timeoutMs: 10000,
+                durationMs: 12000
+            }
+        }
+    ],
+    trigger: [
+        {
+            source: "trigger",
+            type: "job.retry",
+            severity: "warn",
+            timestamp: minutesAgo(11),
+            metadata: {
+                jobName: "provision-worker",
+                attempt: 1,
+                reason: "function timeout"
+            }
+        },
+        {
+            source: "trigger",
+            type: "job.retry",
+            severity: "warn",
+            timestamp: minutesAgo(10),
+            metadata: {
+                jobName: "provision-worker",
+                attempt: 2,
+                reason: "function timeout"
+            }
+        },
+        {
+            source: "trigger",
+            type: "job.retry",
+            severity: "warn",
+            timestamp: minutesAgo(9),
+            metadata: {
+                jobName: "provision-worker",
+                attempt: 3,
+                reason: "function timeout"
+            }
+        },
+        {
+            source: "trigger",
+            type: "worker.restart",
+            severity: "error",
+            timestamp: minutesAgo(8),
+            metadata: {
+                worker: "provision-worker",
+                reason: "retry storm"
+            }
+        }
+    ],
+    datadog: [],
+    local: [
+        {
+            source: "local",
+            type: "external.api.rate_limit",
+            severity: "warn",
+            timestamp: minutesAgo(7),
+            metadata: {
+                target: "https://api.example.com/allocations",
+                status: 429
+            }
+        }
+    ]
+};
+function getDemoEvents(source, since) {
+    return DEMO_EVENTS[source].filter((event) => event.timestamp.getTime() >= since.getTime());
+}

package/dist/connectors/local.js

@@ -0,0 +1,25 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export class LocalConnector {
+    constructor(config) {
+        this.config = config;
+        this.name = "local";
+    }
+    async fetchEvents(since) {
+        const manualPath = process.env.FROGO_LOCAL_EVENTS;
+        if (!manualPath) {
+            return [];
+        }
+        try {
+            const resolved = path.resolve(process.cwd(), manualPath);
+            const raw = await fs.readFile(resolved, "utf-8");
+            const parsed = JSON.parse(raw);
+            return parsed
+                .map((event) => ({ ...event, timestamp: new Date(event.timestamp) }))
+                .filter((event) => event.timestamp.getTime() >= since.getTime());
+        }
+        catch (error) {
+            return [];
+        }
+    }
+}

package/dist/connectors/trigger.js

@@ -0,0 +1,13 @@
+export class TriggerConnector {
+    constructor(config) {
+        this.config = config;
+        this.name = "trigger";
+    }
+    async fetchEvents(since) {
+        if (!this.config.triggerToken) {
+            return [];
+        }
+        // TODO: implement Trigger.dev API fetch once credentials are available.
+        return [];
+    }
+}

package/dist/connectors/vercel.js

@@ -0,0 +1,13 @@
+export class VercelConnector {
+    constructor(config) {
+        this.config = config;
+        this.name = "vercel";
+    }
+    async fetchEvents(since) {
+        if (!this.config.vercelToken) {
+            return [];
+        }
+        // TODO: hook into the Vercel API once the token and project are configured.
+        return [];
+    }
+}

package/dist/core/correlator.js

@@ -0,0 +1,17 @@
+import { buildIncidentClusters } from "./timeline.js";
+import { matchPattern } from "./pattern-engine.js";
+export function correlateEvents(events) {
+    const sortedTimeline = [...events].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const clusters = buildIncidentClusters(events);
+    for (const cluster of clusters) {
+        const match = matchPattern(cluster);
+        if (match) {
+            return {
+                cluster,
+                match,
+                timeline: sortedTimeline
+            };
+        }
+    }
+    return null;
+}

package/dist/core/investigator.js

@@ -0,0 +1,49 @@
+import { loadConfig } from "../config/load.js";
+import { VercelConnector } from "../connectors/vercel.js";
+import { TriggerConnector } from "../connectors/trigger.js";
+import { LocalConnector } from "../connectors/local.js";
+import { DatadogConnector } from "../connectors/datadog.js";
+import { correlateEvents } from "../core/correlator.js";
+import { explainIncident } from "../llm/explain.js";
+const DEFAULT_WINDOW_MINUTES = 15;
+function formatEvent(event) {
+    return `${event.timestamp.toISOString()} ${event.source} ${event.type}`;
+}
+export async function runInvestigation(options = {}) {
+    const config = await loadConfig();
+    const windowMinutes = options.windowMinutes ?? DEFAULT_WINDOW_MINUTES;
+    const windowStart = new Date(Date.now() - windowMinutes * 60 * 1000);
+    const connectors = [
+        new VercelConnector(config),
+        new TriggerConnector(config),
+        new LocalConnector(config),
+        new DatadogConnector(config)
+    ];
+    console.log(`🐸 Scanning last ${windowMinutes} minutes...`);
+    const events = await Promise.all(connectors.map((connector) => connector.fetchEvents(windowStart)));
+    const flattened = events.flat();
+    const report = correlateEvents(flattened);
+    if (!report) {
+        console.log("🐸 No significant failure patterns detected.");
+        return;
+    }
+    const explanation = await explainIncident({
+        pattern: report.match.patternId,
+        timeline: report.timeline,
+        evidence: report.match.evidence,
+        confidence: report.match.confidence,
+        rootCauseEvent: report.match.rootCauseEvent,
+        query: options.query
+    });
+    console.log("Incident detected.");
+    console.log("Trigger:");
+    console.log(`- ${report.match.rootCauseEvent.type}`);
+    console.log("Cascade:");
+    report.match.evidence
+        .slice(1)
+        .forEach((event) => console.log(`→ ${formatEvent(event)}`));
+    console.log("Root Cause:");
+    console.log(`- ${explanation.explanation}`);
+    console.log(`Confidence: ${report.match.confidence.toFixed(2)}`);
+    console.log(`Suggested Fix: ${explanation.suggestion}`);
+}

package/dist/core/pattern-engine.js

@@ -0,0 +1,108 @@
+const patternMatchers = [
+    matchServerlessTimeoutCascade,
+    matchRetryStorm,
+    matchDeployFailure,
+    matchCrashLoop
+];
+export function matchPattern(cluster) {
+    for (const matcher of patternMatchers) {
+        const match = matcher(cluster);
+        if (match) {
+            return match;
+        }
+    }
+    return null;
+}
+function matchServerlessTimeoutCascade(cluster) {
+    const { triggerEvent, cascade } = cluster;
+    if (triggerEvent.source !== "vercel") {
+        return null;
+    }
+    if (!triggerEvent.type.toLowerCase().includes("timeout")) {
+        return null;
+    }
+    const evidence = [
+        triggerEvent,
+        ...cascade.filter((event) => isRetry(event) || isRestart(event) || isExternal429(event))
+    ];
+    const hasRetry = cascade.some(isRetry);
+    const hasRestart = cascade.some(isRestart);
+    if (!hasRetry) {
+        return null;
+    }
+    const confidence = hasRestart ? 0.87 : 0.82;
+    return buildMatch("SERVERLESS_TIMEOUT_CASCADE", triggerEvent, evidence, confidence, {
+        retryCount: cascade.filter(isRetry).length,
+        restartDetected: hasRestart
+    });
+}
+function matchRetryStorm(cluster) {
+    const { cascade } = cluster;
+    const retries = cascade.filter((event) => isRetry(event));
+    if (retries.length < 3) {
+        return null;
+    }
+    const grouped = groupBy(retries, (event) => String(event.metadata.jobName ?? "unknown"));
+    const hasBusyJob = Object.values(grouped).some((jobs) => jobs.length >= 3);
+    if (!hasBusyJob) {
+        return null;
+    }
+    const root = retries[0];
+    const evidence = retries.slice(0, 5);
+    return buildMatch("RETRY_STORM", root, evidence, 0.74, {
+        retries: retries.length,
+        jobs: Object.keys(grouped)
+    });
+}
+function matchDeployFailure(cluster) {
+    const timeline = [cluster.triggerEvent, ...cluster.cascade];
+    const deployEvent = timeline.find((event) => event.type.toLowerCase().includes("deploy"));
+    if (!deployEvent) {
+        return null;
+    }
+    const errorsAfterDeployment = timeline.filter((event) => event.timestamp.getTime() >= deployEvent.timestamp.getTime() && event.severity === "error");
+    if (errorsAfterDeployment.length === 0) {
+        return null;
+    }
+    return buildMatch("DEPLOY_FAILURE", deployEvent, errorsAfterDeployment, 0.72, {
+        deployEventType: deployEvent.type,
+        errorCount: errorsAfterDeployment.length
+    });
+}
+function matchCrashLoop(cluster) {
+    const restarts = cluster.cascade.filter((event) => isRestart(event));
+    if (restarts.length < 2) {
+        return null;
+    }
+    const root = restarts[0];
+    const evidence = restarts.slice(0, 3);
+    return buildMatch("CRASH_LOOP", root, evidence, 0.66, {
+        restartCount: restarts.length
+    });
+}
+function isRetry(event) {
+    return event.type.toLowerCase().includes("retry") || event.metadata?.retry === true;
+}
+function isRestart(event) {
+    return event.type.toLowerCase().includes("restart") || event.type.toLowerCase().includes("duplicate execution");
+}
+function isExternal429(event) {
+    return event.metadata?.status === 429 || String(event.metadata?.statusCode ?? "").startsWith("429");
+}
+function groupBy(list, select) {
+    return list.reduce((acc, item) => {
+        const key = select(item);
+        acc[key] = acc[key] ?? [];
+        acc[key].push(item);
+        return acc;
+    }, {});
+}
+function buildMatch(patternId, rootCauseEvent, evidence, confidence, metadata) {
+    return {
+        patternId,
+        rootCauseEvent,
+        evidence,
+        confidence,
+        metadata
+    };
+}

package/dist/core/timeline.js

@@ -0,0 +1,24 @@
+const CLUSTER_WINDOW_MS = 15 * 60 * 1000;
+export function buildIncidentClusters(events) {
+    const sorted = [...events].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const clusters = [];
+    for (const event of sorted) {
+        if (event.severity !== "error" && event.severity !== "warn") {
+            continue;
+        }
+        const cascade = sorted.filter((candidate) => {
+            const offset = candidate.timestamp.getTime() - event.timestamp.getTime();
+            return offset >= 0 && offset <= CLUSTER_WINDOW_MS && candidate !== event;
+        });
+        const windowEnd = cascade.length
+            ? cascade[cascade.length - 1].timestamp
+            : event.timestamp;
+        clusters.push({
+            triggerEvent: event,
+            cascade,
+            windowStart: event.timestamp,
+            windowEnd
+        });
+    }
+    return clusters;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/llm/explain.js

@@ -0,0 +1,14 @@
+export async function explainIncident(input) {
+    const timelineSummary = input.timeline
+        .map((event) => `- ${event.timestamp.toISOString()} ${event.source} ${event.type}`)
+        .join("\n");
+    const evidenceSummary = input.evidence
+        .map((event) => `- ${event.timestamp.toISOString()} ${event.source} ${event.type}`)
+        .join("\n");
+    const explanation = `Detected pattern ${input.pattern} with confidence ${input.confidence.toFixed(2)}. Root cause event: ${input.rootCauseEvent.type}.`;
+    const suggestion = `Review ${input.rootCauseEvent.source} ${input.rootCauseEvent.type} around ${input.rootCauseEvent.timestamp.toISOString()} to mitigate.`;
+    return {
+        explanation,
+        suggestion
+    };
+}