openreport 0.1.0

package/src/config/loader.ts

@@ -0,0 +1,168 @@
+import * as fs from "fs";
+import * as path from "path";
+import { OpenReportConfigSchema, type OpenReportConfig } from "./schema.js";
+import { DEFAULT_CONFIG } from "./defaults.js";
+import { ConfigError } from "../errors.js";
+import { debugLog } from "../utils/debug.js";
+
+async function readJsonFile(filePath: string): Promise<Record<string, unknown> | null> {
+  try {
+    const content = await fs.promises.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (e) {
+    debugLog("config:readJsonFile", e);
+    return null;
+  }
+}
+
+function getGlobalConfigPath(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return path.join(home, ".openreport", "config.json");
+}
+
+function getProjectConfigPath(projectRoot: string): string {
+  return path.join(projectRoot, ".openreport", "config.json");
+}
+
+const ENV_KEY_MAP: [string, string][] = [
+  ["ANTHROPIC_API_KEY", "anthropic"],
+  ["OPENAI_API_KEY", "openai"],
+  ["GOOGLE_GENERATIVE_AI_API_KEY", "google"],
+  ["MISTRAL_API_KEY", "mistral"],
+];
+
+function envToConfig(): Partial<OpenReportConfig> {
+  const config: Record<string, unknown> = {};
+
+  if (process.env.OPENREPORT_PROVIDER) {
+    config.defaultProvider = process.env.OPENREPORT_PROVIDER;
+  }
+  if (process.env.OPENREPORT_MODEL) {
+    config.defaultModel = process.env.OPENREPORT_MODEL;
+  }
+
+  for (const [envKey, providerName] of ENV_KEY_MAP) {
+    const apiKey = process.env[envKey];
+    if (apiKey) {
+      config.providers = {
+        ...((config.providers as Record<string, unknown>) || {}),
+        [providerName]: { apiKey },
+      };
+    }
+  }
+
+  return config as Partial<OpenReportConfig>;
+}
+
+export interface LoadConfigOptions {
+  projectRoot?: string;
+  cliFlags?: Partial<OpenReportConfig>;
+}
+
+function stripSensitiveFields(config: Record<string, unknown>): Record<string, unknown> {
+  const result = { ...config };
+  if (result.providers && typeof result.providers === "object") {
+    const providers = { ...(result.providers as Record<string, unknown>) };
+    for (const key of Object.keys(providers)) {
+      if (providers[key] && typeof providers[key] === "object") {
+        const provider = { ...(providers[key] as Record<string, unknown>) };
+        delete provider.baseURL;
+        delete provider.apiKey;
+        providers[key] = provider;
+      }
+    }
+    result.providers = providers;
+  }
+  return result;
+}
+
+function capProjectConfig(config: Record<string, unknown>): Record<string, unknown> {
+  const result = { ...config };
+
+  // Cap scan settings
+  if (result.scan && typeof result.scan === "object") {
+    const scan = { ...(result.scan as Record<string, unknown>) };
+    if (typeof scan.maxDepth === "number" && scan.maxDepth > 15) scan.maxDepth = 15;
+    if (typeof scan.maxFileSize === "number" && scan.maxFileSize > 200000) scan.maxFileSize = 200000;
+    result.scan = scan;
+  }
+
+  // Cap agent settings
+  if (result.agents && typeof result.agents === "object") {
+    const agents = { ...(result.agents as Record<string, unknown>) };
+    if (typeof agents.maxConcurrency === "number" && agents.maxConcurrency > 5) agents.maxConcurrency = 5;
+    if (typeof agents.maxTokens === "number" && agents.maxTokens > 16384) agents.maxTokens = 16384;
+    if (agents.maxStepsOverride && typeof agents.maxStepsOverride === "object") {
+      const steps = { ...(agents.maxStepsOverride as Record<string, unknown>) };
+      for (const key of Object.keys(steps)) {
+        if (typeof steps[key] === "number" && (steps[key] as number) > 20) steps[key] = 20;
+      }
+      agents.maxStepsOverride = steps;
+    }
+    result.agents = agents;
+  }
+
+  return result;
+}
+
+export async function loadConfig(options: LoadConfigOptions = {}): Promise<OpenReportConfig> {
+  const projectRoot = options.projectRoot || process.cwd();
+
+  // Note: Bun automatically loads .env from CWD.
+  // We intentionally do NOT load .env from the target project root,
+  // as a malicious repo could override API keys or redirect API calls.
+
+  // Cascade: defaults < global config < project config < env vars < CLI flags
+  const globalConfig = (await readJsonFile(getGlobalConfigPath())) || {};
+  const projectConfig = (await readJsonFile(getProjectConfigPath(projectRoot))) || {};
+  const envConfig = envToConfig();
+
+  const merged = deepMerge(
+    DEFAULT_CONFIG,
+    globalConfig,
+    capProjectConfig(stripSensitiveFields(projectConfig)),
+    envConfig,
+    options.cliFlags || {}
+  );
+
+  try {
+    return OpenReportConfigSchema.parse(merged);
+  } catch (e) {
+    throw new ConfigError(
+      `Invalid configuration: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}
+
+/**
+ * Recursively merges plain JSON objects (not class instances, arrays, or Maps).
+ * Later values override earlier ones; nested plain objects are merged recursively.
+ * Arrays and non-plain-object values are replaced wholesale.
+ */
+function deepMerge(...objects: Record<string, unknown>[]): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  for (const obj of objects) {
+    for (const key of Object.keys(obj)) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+      const val = obj[key];
+      if (
+        val &&
+        typeof val === "object" &&
+        !Array.isArray(val) &&
+        result[key] &&
+        typeof result[key] === "object" &&
+        !Array.isArray(result[key])
+      ) {
+        result[key] = deepMerge(
+          result[key] as Record<string, unknown>,
+          val as Record<string, unknown>
+        );
+      } else if (val !== undefined) {
+        result[key] = val;
+      }
+    }
+  }
+
+  return result;
+}

package/src/config/ollama.ts

@@ -0,0 +1,48 @@
+export interface OllamaModel {
+  name: string;
+  size: number;
+  parameterSize: string;
+}
+
+export async function fetchOllamaModels(
+  baseURL = "http://localhost:11434"
+): Promise<OllamaModel[]> {
+  try {
+    const response = await fetch(`${baseURL}/api/tags`, {
+      signal: AbortSignal.timeout(3000),
+    });
+
+    if (!response.ok) return [];
+
+    const data = (await response.json()) as {
+      models?: Array<{
+        name: string;
+        size: number;
+        details?: { parameter_size?: string };
+      }>;
+    };
+
+    if (!data.models) return [];
+
+    return data.models.map((m) => ({
+      name: m.name,
+      size: m.size,
+      parameterSize: m.details?.parameter_size || "",
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export async function isOllamaRunning(
+  baseURL = "http://localhost:11434"
+): Promise<boolean> {
+  try {
+    const response = await fetch(baseURL, {
+      signal: AbortSignal.timeout(2000),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}

package/src/config/providers.ts

@@ -0,0 +1,199 @@
+import type { LanguageModelV1 } from "ai";
+import type { OpenReportConfig } from "./schema.js";
+import { createCliModel } from "./cli-model.js";
+import { CLI_TOOLS } from "./cli-detection.js";
+import { ProviderError } from "../errors.js";
+
+export interface ProviderEntry {
+  id: string;
+  createModel: (modelId: string) => LanguageModelV1;
+  defaultModel: string;
+  type: "api" | "local" | "cli";
+}
+
+const PROVIDER_DEFAULTS: Record<string, string> = {
+  anthropic: "claude-sonnet-4-5-20250929",
+  openai: "gpt-4o",
+  google: "gemini-2.0-flash",
+  mistral: "mistral-large-latest",
+  ollama: "qwen2.5-coder:14b",
+};
+
+// ── Lazy-loaded SDK factory ──────────────────────────────────────────────
+
+type SdkFactory = (modelId: string) => LanguageModelV1;
+type SdkCreator<T> = (opts: Record<string, unknown>) => T;
+
+function createSdkFactory<T>(
+  importFn: () => Promise<SdkCreator<T>>,
+  buildConfig: (config: OpenReportConfig) => Record<string, unknown>,
+): (config: OpenReportConfig) => Promise<T> {
+  let cached: T | null = null;
+  return async (config: OpenReportConfig) => {
+    if (!cached) {
+      const createFn = await importFn();
+      cached = createFn(buildConfig(config));
+    }
+    return cached;
+  };
+}
+
+function standardConfig(
+  providerKey: keyof OpenReportConfig["providers"],
+  envKey: string,
+) {
+  return (config: OpenReportConfig): Record<string, unknown> => {
+    const provConfig = config.providers[providerKey] || {};
+    return {
+      apiKey: provConfig.apiKey || process.env[envKey],
+      ...(provConfig.baseURL ? { baseURL: provConfig.baseURL } : {}),
+    };
+  };
+}
+
+const getAnthropicSdk = createSdkFactory(
+  async () => (await import("@ai-sdk/anthropic")).createAnthropic as unknown as SdkCreator<SdkFactory>,
+  standardConfig("anthropic", "ANTHROPIC_API_KEY"),
+);
+
+const getOpenAISdk = createSdkFactory(
+  async () => (await import("@ai-sdk/openai")).createOpenAI as unknown as SdkCreator<SdkFactory>,
+  standardConfig("openai", "OPENAI_API_KEY"),
+);
+
+const getGoogleSdk = createSdkFactory(
+  async () => (await import("@ai-sdk/google")).createGoogleGenerativeAI as unknown as SdkCreator<SdkFactory>,
+  standardConfig("google", "GOOGLE_GENERATIVE_AI_API_KEY"),
+);
+
+const getMistralSdk = createSdkFactory(
+  async () => (await import("@ai-sdk/mistral")).createMistral as unknown as SdkCreator<SdkFactory>,
+  standardConfig("mistral", "MISTRAL_API_KEY"),
+);
+
+const getOllamaSdk = createSdkFactory(
+  async () => (await import("@ai-sdk/openai")).createOpenAI as unknown as SdkCreator<SdkFactory>,
+  (config: OpenReportConfig) => {
+    const ollamaConfig = config.providers.ollama || {};
+    return {
+      apiKey: "ollama",
+      baseURL: ollamaConfig.baseURL || process.env.OLLAMA_BASE_URL || "http://localhost:11434/v1",
+    };
+  },
+);
+
+// ── Cloud provider definitions (data-driven) ────────────────────────────
+
+interface CloudProviderDef {
+  id: string;
+  getSdk: (config: OpenReportConfig) => Promise<SdkFactory>;
+  type: "api" | "local";
+}
+
+const CLOUD_PROVIDERS: CloudProviderDef[] = [
+  { id: "anthropic", getSdk: getAnthropicSdk, type: "api" },
+  { id: "openai", getSdk: getOpenAISdk, type: "api" },
+  { id: "google", getSdk: getGoogleSdk, type: "api" },
+  { id: "mistral", getSdk: getMistralSdk, type: "api" },
+  { id: "ollama", getSdk: getOllamaSdk, type: "local" },
+];
+
+// ── Registry ────────────────────────────────────────────────────────────
+
+export function createProviderRegistry(config: OpenReportConfig) {
+  const providers = new Map<string, ProviderEntry>();
+
+  // ── Cloud/local API providers (lazy-loaded on first createModel call) ──
+
+  for (const def of CLOUD_PROVIDERS) {
+    providers.set(def.id, {
+      id: def.id,
+      createModel: (modelId: string) => {
+        return createLazyModel(() => def.getSdk(config), modelId, def.id);
+      },
+      defaultModel: PROVIDER_DEFAULTS[def.id],
+      type: def.type,
+    });
+  }
+
+  // ── CLI-based providers (auto-detected) ───────────────────────────
+
+  for (const cliTool of CLI_TOOLS) {
+    providers.set(cliTool.id, {
+      id: cliTool.id,
+      createModel: (modelId: string) => createCliModel(cliTool.id, modelId),
+      defaultModel: cliTool.defaultModel,
+      type: "cli",
+    });
+  }
+
+  return {
+    getProvider(id: string): ProviderEntry | undefined {
+      return providers.get(id);
+    },
+
+    getModel(config: OpenReportConfig): LanguageModelV1 {
+      const provider = providers.get(config.defaultProvider);
+      if (!provider) {
+        throw new ProviderError(`Unknown provider: ${config.defaultProvider}`);
+      }
+      return provider.createModel(config.defaultModel || provider.defaultModel);
+    },
+
+    listProviders(): string[] {
+      return Array.from(providers.keys());
+    },
+
+    getProvidersByType(type: "api" | "local" | "cli"): ProviderEntry[] {
+      return Array.from(providers.values()).filter((p) => p.type === type);
+    },
+  };
+}
+
+export type ProviderRegistry = ReturnType<typeof createProviderRegistry>;
+
+// ── Lazy model proxy ────────────────────────────────────────────────────
+// Creates a LanguageModelV1 that only loads the SDK when doGenerate/doStream is called.
+
+function createLazyModel(
+  getSdk: () => Promise<SdkFactory>,
+  modelId: string,
+  providerId: string,
+): LanguageModelV1 {
+  let _resolved: LanguageModelV1 | null = null;
+
+  async function resolve(): Promise<LanguageModelV1> {
+    if (!_resolved) {
+      const sdk = await getSdk();
+      _resolved = sdk(modelId) as LanguageModelV1;
+    }
+    return _resolved;
+  }
+
+  const base: LanguageModelV1 = {
+    specificationVersion: "v1",
+    provider: providerId,
+    modelId,
+    defaultObjectGenerationMode: undefined,
+
+    async doGenerate(options) {
+      const model = await resolve();
+      return model.doGenerate(options);
+    },
+
+    async doStream(options) {
+      const model = await resolve();
+      return model.doStream(options);
+    },
+  };
+
+  return new Proxy(base, {
+    get(target, prop, receiver) {
+      if (_resolved && prop in _resolved) {
+        const value = (_resolved as Record<string | symbol, unknown>)[prop];
+        return typeof value === "function" ? value.bind(_resolved) : value;
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+}

package/src/config/resolve-provider.ts

@@ -0,0 +1,62 @@
+import type { LanguageModelV1 } from "ai";
+import type { OpenReportConfig } from "./schema.js";
+import type { ProviderRegistry } from "./providers.js";
+import { detectInstalledClis } from "./cli-detection.js";
+import { ProviderError } from "../errors.js";
+import { debugLog } from "../utils/debug.js";
+
+export interface ResolvedProvider {
+  model: LanguageModelV1;
+  effectiveProvider: string;
+  effectiveModel: string;
+  warnings: string[];
+}
+
+export async function resolveProvider(
+  config: OpenReportConfig,
+  registry: ProviderRegistry,
+): Promise<ResolvedProvider> {
+  const detectedClis = await detectInstalledClis();
+  const warnings: string[] = [];
+
+  let effectiveProvider = config.defaultProvider;
+  let effectiveModel = config.defaultModel;
+
+  const isConfiguredAvailable = detectedClis.some(
+    (c) => c.id === config.defaultProvider,
+  );
+  if (!isConfiguredAvailable && detectedClis.length > 0) {
+    const msg = `Configured provider '${config.defaultProvider}' unavailable, using CLI fallback: ${detectedClis[0].id}`;
+    debugLog("provider:fallback", msg);
+    warnings.push(msg);
+    effectiveProvider = detectedClis[0].id;
+    effectiveModel = detectedClis[0].defaultModel;
+  }
+
+  let model: LanguageModelV1;
+  try {
+    const provider = registry.getProvider(effectiveProvider);
+    if (provider) {
+      model = provider.createModel(effectiveModel);
+    } else {
+      model = registry.getModel(config);
+    }
+  } catch {
+    if (detectedClis.length > 0) {
+      const fallbackProvider = registry.getProvider(detectedClis[0].id);
+      if (!fallbackProvider) {
+        throw new ProviderError(`Provider "${detectedClis[0].id}" not found in registry`);
+      }
+      model = fallbackProvider.createModel(detectedClis[0].defaultModel);
+      const msg = `Provider '${effectiveProvider}' failed to initialize, using CLI fallback: ${detectedClis[0].id}`;
+      debugLog("provider:fallback", msg);
+      warnings.push(msg);
+      effectiveProvider = detectedClis[0].id;
+      effectiveModel = detectedClis[0].defaultModel;
+    } else {
+      throw new ProviderError("No code agents found. Install one of: claude, gemini, codex");
+    }
+  }
+
+  return { model, effectiveProvider, effectiveModel, warnings };
+}

package/src/config/saver.ts

@@ -0,0 +1,50 @@
+import * as fs from "fs";
+import * as path from "path";
+import { debugLog } from "../utils/debug.js";
+
+export interface SaveableConfig {
+  defaultProvider: string;
+  defaultModel: string;
+  agents?: {
+    maxConcurrency?: number;
+    temperature?: number;
+  };
+  features?: {
+    todoList?: boolean;
+  };
+}
+
+export async function saveProjectConfig(
+  projectRoot: string,
+  config: SaveableConfig
+): Promise<void> {
+  const configDir = path.join(projectRoot, ".openreport");
+  const configFile = path.join(configDir, "config.json");
+
+  await fs.promises.mkdir(configDir, { recursive: true });
+
+  // Merge with existing config if present
+  let existing: Record<string, unknown> = {};
+  try {
+    const content = await fs.promises.readFile(configFile, "utf-8");
+    existing = JSON.parse(content);
+  } catch (e) {
+    debugLog("config:readExisting", e);
+  }
+
+  const merged = {
+    ...existing,
+    defaultProvider: config.defaultProvider,
+    defaultModel: config.defaultModel,
+    agents: {
+      ...((existing.agents as Record<string, unknown>) || {}),
+      ...(config.agents || {}),
+    },
+    features: {
+      ...((existing.features as Record<string, unknown>) || {}),
+      ...(config.features || {}),
+    },
+  };
+
+  await fs.promises.writeFile(configFile, JSON.stringify(merged, null, 2), "utf-8");
+}

package/src/config/schema.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+export const ProviderConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  baseURL: z.string().optional(),
+});
+
+export const OpenReportConfigSchema = z.object({
+  defaultProvider: z.string().default("claude-code"),
+  defaultModel: z.string().default("sonnet"),
+  providers: z
+    .record(z.string(), ProviderConfigSchema)
+    .default({}),
+  output: z
+    .object({
+      directory: z.string().default(".openreport/reports"),
+      format: z.enum(["markdown", "json"]).default("markdown"),
+      includeMetadata: z.boolean().default(true),
+    })
+    .default({}),
+  agents: z
+    .object({
+      maxConcurrency: z.number().min(1).max(10).default(3),
+      maxStepsOverride: z.record(z.string(), z.number()).default({}),
+      temperature: z.number().min(0).max(1).default(0.3),
+      maxTokens: z.number().default(8192),
+    })
+    .default({}),
+  modelTokenLimits: z.record(z.string(), z.number()).default({}).optional(),
+  scan: z
+    .object({
+      exclude: z.array(z.string()).default([]),
+      maxFileSize: z.number().default(50000),
+      maxDepth: z.number().default(10),
+    })
+    .default({}),
+  ui: z
+    .object({
+      theme: z.enum(["auto", "dark", "light"]).default("auto"),
+      showTokenCount: z.boolean().default(true),
+      streamOutput: z.boolean().default(true),
+    })
+    .default({}),
+  features: z
+    .object({
+      todoList: z.boolean().default(false),
+    })
+    .default({}),
+});
+
+export type OpenReportConfig = z.infer<typeof OpenReportConfigSchema>;

package/src/errors.ts

@@ -0,0 +1,34 @@
+export class OpenReportError extends Error {
+  constructor(message: string, public readonly code: string) {
+    super(message);
+    this.name = "OpenReportError";
+  }
+}
+
+export class ProviderError extends OpenReportError {
+  constructor(message: string) {
+    super(message, "PROVIDER_ERROR");
+    this.name = "ProviderError";
+  }
+}
+
+export class ExtractionError extends OpenReportError {
+  constructor(message: string) {
+    super(message, "EXTRACTION_ERROR");
+    this.name = "ExtractionError";
+  }
+}
+
+export class PipelineError extends OpenReportError {
+  constructor(message: string) {
+    super(message, "PIPELINE_ERROR");
+    this.name = "PipelineError";
+  }
+}
+
+export class ConfigError extends OpenReportError {
+  constructor(message: string) {
+    super(message, "CONFIG_ERROR");
+    this.name = "ConfigError";
+  }
+}