frogo 0.1.0

package/src/cli/commands/configure.ts

@@ -0,0 +1,265 @@
+import { Command } from "commander";
+import prompts, { PromptObject } from "prompts";
+import { loadConfig } from "../../config/load.js";
+import { saveConfig } from "../../config/save.js";
+import type { FrogConfig, LangSmithConfig } from "../../core/types.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 <T extends Record<string, string | undefined>>(
+  questions: PromptObject<string>[]
+): Promise<T> => {
+  const answers = (await prompts(questions)) as T;
+  return answers;
+};
+
+const vqlQuestions: PromptObject<string>[] = [
+  {
+    type: "text",
+    name: "vercelToken",
+    message: "Vercel token",
+    initial: ""
+  }
+];
+
+const triggerQuestions: PromptObject<string>[] = [
+  {
+    type: "text",
+    name: "triggerToken",
+    message: "Trigger.dev API key",
+    initial: ""
+  }
+];
+
+const datadogQuestions: PromptObject<string>[] = [
+  {
+    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: PromptObject<string>[] = [
+  {
+    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: PromptObject<string>[] = [
+  {
+    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?: string): string | undefined {
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  return trimmed === "" ? undefined : trimmed;
+}
+
+async function configureDatadog(config: FrogConfig): Promise<FrogConfig> {
+  const answers = await promptCredentials<Record<string, string>>(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: FrogConfig): Promise<FrogConfig> {
+  const answers = await promptCredentials<Record<string, string>>(langsmithQuestions);
+  return {
+    ...config,
+    langsmith: {
+      apiKey: trimOrUndefined(answers.apiKey),
+      workspaceKey: trimOrUndefined(answers.workspaceKey),
+      mcpUrl: trimOrUndefined(answers.mcpUrl)
+    }
+  };
+}
+
+async function configureLLMProvider(config: FrogConfig): Promise<FrogConfig> {
+  const answers = await promptCredentials<Record<string, string>>(llmProviderQuestions);
+  return {
+    ...config,
+    llmProvider: {
+      provider: trimOrUndefined(answers.provider),
+      endpoint: trimOrUndefined(answers.endpoint),
+      model: trimOrUndefined(answers.model),
+      systemPrompt: trimOrUndefined(answers.systemPrompt)
+    }
+  };
+}
+
+async function showConfig(config: FrogConfig) {
+  console.log("Current configuration:");
+  console.log(JSON.stringify(config, null, 2));
+}
+
+async function configure(cmd: Command) {
+  let config = await loadConfig();
+  console.log("🐸 Frog configure — pick an integration to update");
+
+  while (true) {
+    const { choice } = (await promptCredentials<Record<string, string>>([
+      {
+        type: "select",
+        name: "choice",
+        message: "What would you like to configure?",
+        choices: menuChoices
+      }
+    ])) as { choice?: string };
+
+    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<Record<string, string>>(vqlQuestions)).vercelToken)
+        };
+        await saveConfig(config);
+        console.log("✔ Vercel token updated.");
+        break;
+      case "trigger":
+        config = {
+          ...config,
+          triggerToken: trimOrUndefined((await promptCredentials<Record<string, string>>(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()));

package/src/cli/commands/debug.ts

@@ -0,0 +1,10 @@
+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: string) => {
+    console.log(`🐸 Debugging query: ${query}`);
+    await runInvestigation({ windowMinutes: 15, query });
+  });

package/src/cli/commands/mcp.ts

@@ -0,0 +1,66 @@
+import { Command } from "commander";
+import prompts, { PromptObject } from "prompts";
+import { loadConfig } from "../../config/load.js";
+import { saveConfig } from "../../config/save.js";
+import type { FrogConfig } from "../../core/types.js";
+
+const LANGSMITH_SERVER = "langsmith";
+
+const langsmithQuestions: PromptObject<string>[] = [
+  {
+    type: "text",
+    name: "apiKey",
+    message: "LangSmith API key (ls_api_key_... or lsv2_pt_...)",
+    validate: (value: string) => (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: string) => {
+      if (server.toLowerCase() !== LANGSMITH_SERVER) {
+        console.log(`Unsupported MCP server: ${server}. Try 'frogo mcp login langsmith'.`);
+      return;
+    }
+
+    const answers = (await prompts(langsmithQuestions)) as {
+      apiKey?: string;
+      workspaceKey?: string;
+      mcpUrl?: string;
+    };
+
+    if (!answers.apiKey) {
+      console.log("LangSmith login canceled.");
+      return;
+    }
+
+    const config = await loadConfig();
+    const updated: FrogConfig = {
+      ...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/src/cli/commands/scan.ts

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

package/src/cli/index.ts

@@ -0,0 +1,27 @@
+#!/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/src/config/load.ts

@@ -0,0 +1,42 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { FrogConfig } from "../core/types.js";
+
+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: string): Promise<FrogConfig | null> {
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    const parsed: FrogConfig = JSON.parse(raw);
+    return parsed;
+  } catch (error) {
+    return null;
+  }
+}
+
+export async function loadConfig(): Promise<FrogConfig> {
+  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/src/config/save.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { FrogConfig } from "../core/types.js";
+
+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: FrogConfig,
+  options?: { local?: boolean; global?: boolean }
+): Promise<void> {
+  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/src/connectors/datadog.ts

@@ -0,0 +1,152 @@
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { Connector, FrogConfig, NormalizedEvent } from "../core/types.js";
+
+const DEFAULT_COMMAND = "datadog-mcp-server";
+const DEFAULT_QUERY = "status:error OR status:warn";
+const DEFAULT_LIMIT = 80;
+
+interface RawDatadogLogEntry {
+  id: string;
+  attributes?: {
+    timestamp?: string;
+    message?: string;
+    status?: string;
+    service?: string;
+    host?: string;
+    logger?: string;
+    tags?: string[];
+    [key: string]: unknown;
+  };
+  relationships?: {
+    trace?: {
+      data?: {
+        id: string;
+      };
+    };
+  };
+}
+
+interface RawDatadogSearchLogsResponse {
+  data?: RawDatadogLogEntry[];
+}
+
+export class DatadogConnector implements Connector {
+  name = "datadog";
+
+  constructor(private config: FrogConfig) {}
+
+  async fetchEvents(since: Date): Promise<NormalizedEvent[]> {
+    const datadog = this.config.datadog;
+    if (!datadog?.apiKey || !datadog?.appKey) {
+      return [];
+    }
+
+    const command = datadog.command ?? DEFAULT_COMMAND;
+    const args = datadog.args ?? [];
+    const env: Record<string, string> = { ...process.env } as Record<string, string>;
+    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 as { content?: Array<{ type: string; text?: string }> };
+      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();
+    }
+  }
+
+  private safeParse(raw: string): RawDatadogSearchLogsResponse | null {
+    try {
+      return JSON.parse(raw) as RawDatadogSearchLogsResponse;
+    } catch (error) {
+      console.error("Failed to parse Datadog search response", error);
+      return null;
+    }
+  }
+
+  private normalizeEntry(entry: RawDatadogLogEntry): NormalizedEvent {
+    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?: string): "info" | "warn" | "error" {
+  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/src/connectors/local.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Connector, FrogConfig, NormalizedEvent } from "../core/types.js";
+
+export class LocalConnector implements Connector {
+  name = "local";
+
+  constructor(private config: FrogConfig) {}
+
+  async fetchEvents(since: Date): Promise<NormalizedEvent[]> {
+    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) as Array<NormalizedEvent & { timestamp: string }>;
+      return parsed
+        .map((event) => ({ ...event, timestamp: new Date(event.timestamp) }))
+        .filter((event) => event.timestamp.getTime() >= since.getTime());
+    } catch (error) {
+      return [];
+    }
+  }
+}

package/src/connectors/trigger.ts

@@ -0,0 +1,16 @@
+import { Connector, NormalizedEvent, FrogConfig } from "../core/types.js";
+
+export class TriggerConnector implements Connector {
+  name = "trigger";
+
+  constructor(private config: FrogConfig) {}
+
+  async fetchEvents(since: Date): Promise<NormalizedEvent[]> {
+    if (!this.config.triggerToken) {
+      return [];
+    }
+
+    // TODO: implement Trigger.dev API fetch once credentials are available.
+    return [];
+  }
+}

package/src/connectors/vercel.ts

@@ -0,0 +1,16 @@
+import { Connector, NormalizedEvent, FrogConfig } from "../core/types.js";
+
+export class VercelConnector implements Connector {
+  name = "vercel";
+
+  constructor(private config: FrogConfig) {}
+
+  async fetchEvents(since: Date): Promise<NormalizedEvent[]> {
+    if (!this.config.vercelToken) {
+      return [];
+    }
+
+    // TODO: hook into the Vercel API once the token and project are configured.
+    return [];
+  }
+}

package/src/core/correlator.ts

@@ -0,0 +1,27 @@
+import { IncidentCluster, NormalizedEvent, PatternMatch } from "./types.js";
+import { buildIncidentClusters } from "./timeline.js";
+import { matchPattern } from "./pattern-engine.js";
+
+export interface IncidentReport {
+  cluster: IncidentCluster;
+  match: PatternMatch;
+  timeline: NormalizedEvent[];
+}
+
+export function correlateEvents(events: NormalizedEvent[]): IncidentReport | null {
+  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;
+}