@aixle/insights 0.1.0

package/dist/hooks/hooks-config.js

@@ -0,0 +1,235 @@
+/**
+ * Install / uninstall / verify Cursor hooks config for the aixle-insights hook-forwarder.
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export const USER_HOOKS_JSON = join(homedir(), ".cursor", "hooks.json");
+export const HOOKS_BACKUP_SUFFIX = ".db90-backup";
+export const FORWARDER_FILENAME = "hook-forwarder.mjs";
+export const REQUIRED_HOOK_FIELDS = ["conversation_id", "model", "workspace_roots"];
+export const P0_HOOK_EVENTS = ["sessionEnd", "postToolUse"];
+export function redactHomePath(p) {
+    return p.replaceAll(homedir(), "~");
+}
+export function parseHooksJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function hooksConfigUsesForwarder(config, forwarderPath) {
+    const normalized = resolve(forwarderPath);
+    const hooks = config.hooks ?? {};
+    for (const entries of Object.values(hooks)) {
+        if (!Array.isArray(entries))
+            continue;
+        for (const entry of entries) {
+            // Current format: forwarder path lives inside the single command string.
+            if (typeof entry?.command === "string" && entry.command.includes(FORWARDER_FILENAME)) {
+                return true;
+            }
+            // Legacy format (command + args): tolerated for detection/uninstall.
+            if (Array.isArray(entry?.args)) {
+                for (const arg of entry.args) {
+                    if (resolve(arg) === normalized || arg.includes(FORWARDER_FILENAME))
+                        return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Quote a path for safe inclusion in a POSIX shell command string.
+ * Single-quoting suppresses all expansions ($var, `cmd`, $(cmd), glob, history).
+ * The only character that cannot appear inside single quotes is a literal single
+ * quote, which we escape by ending the quote, adding an escaped quote, then
+ * reopening: foo'bar → 'foo'\''bar'
+ */
+function shellQuote(p) {
+    return `'${p.replaceAll("'", "'\\''")}'`;
+}
+/**
+ * Build the single-string `command` Cursor runs for each hook. Cursor's schema
+ * has no `args`/`env`, so the interpreter, script path, and appDir flag are all
+ * encoded inline. The forwarder reads `--app-dir` to resolve the queue path,
+ * since it runs as a Cursor subprocess outside the MCP process.
+ */
+export function buildForwarderCommand(forwarderPath, appDir) {
+    return `node ${shellQuote(resolve(forwarderPath))} --app-dir ${shellQuote(appDir)}`;
+}
+/**
+ * Build the hooks.json config that routes P0 events to the forwarder.
+ */
+export function buildUserHooksConfig(forwarderPath, appDir) {
+    const entry = {
+        command: buildForwarderCommand(forwarderPath, appDir),
+    };
+    const hooks = {};
+    for (const event of P0_HOOK_EVENTS) {
+        hooks[event] = [entry];
+    }
+    return { version: 1, hooks };
+}
+/**
+ * Install the db90 hook-forwarder:
+ *  1. Copy hook-forwarder.mjs from srcForwarderPath → {appDir}/hook-forwarder.mjs
+ *  2. Backup existing ~/.cursor/hooks.json if present
+ *  3. Write new hooks.json pointing at the installed forwarder
+ */
+export function installHooksConfig(srcForwarderPath, appDir) {
+    mkdirSync(appDir, { recursive: true });
+    mkdirSync(join(homedir(), ".cursor"), { recursive: true });
+    const installedForwarder = join(appDir, FORWARDER_FILENAME);
+    copyFileSync(srcForwarderPath, installedForwarder);
+    let backupPath = null;
+    if (existsSync(USER_HOOKS_JSON)) {
+        const candidate = USER_HOOKS_JSON + HOOKS_BACKUP_SUFFIX;
+        if (existsSync(candidate)) {
+            // A prior install already captured the user's original — never clobber it.
+            backupPath = candidate;
+        }
+        else {
+            // Only back up if the current config is the user's, not our own install.
+            const current = parseHooksJson(readFileSync(USER_HOOKS_JSON, "utf-8"));
+            const alreadyOurs = current !== null && hooksConfigUsesForwarder(current, installedForwarder);
+            if (!alreadyOurs) {
+                backupPath = candidate;
+                copyFileSync(USER_HOOKS_JSON, candidate);
+            }
+        }
+    }
+    const config = buildUserHooksConfig(installedForwarder, appDir);
+    const tmp = USER_HOOKS_JSON + ".tmp";
+    writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    renameSync(tmp, USER_HOOKS_JSON);
+    return { forwarderInstalled: installedForwarder, backupPath };
+}
+/**
+ * Restore the backed-up hooks.json (or remove the current one if no backup existed).
+ * Warns (does not throw) if a queue file with unprocessed events exists.
+ */
+export function uninstallHooksConfig(appDir, queuePath) {
+    const backupPath = USER_HOOKS_JSON + HOOKS_BACKUP_SUFFIX;
+    let restored = false;
+    let usedBackup = null;
+    if (existsSync(backupPath)) {
+        copyFileSync(backupPath, USER_HOOKS_JSON);
+        try {
+            unlinkSync(backupPath);
+        }
+        catch { /* non-fatal */ }
+        restored = true;
+        usedBackup = backupPath;
+    }
+    else if (existsSync(USER_HOOKS_JSON)) {
+        const current = parseHooksJson(readFileSync(USER_HOOKS_JSON, "utf-8"));
+        const installedForwarder = join(appDir, FORWARDER_FILENAME);
+        if (current && hooksConfigUsesForwarder(current, installedForwarder)) {
+            try {
+                unlinkSync(USER_HOOKS_JSON);
+            }
+            catch { /* non-fatal */ }
+            restored = true;
+        }
+    }
+    const resolvedQueue = queuePath ?? join(appDir, "hooks-queue.ndjson");
+    let queueWarning = null;
+    if (existsSync(resolvedQueue)) {
+        const lines = readHooksQueue(resolvedQueue);
+        if (lines.length > 0) {
+            queueWarning = `hooks-queue.ndjson has ${lines.length} unprocessed event(s) — run aixle-insights run --once before uninstalling to flush them`;
+        }
+    }
+    return { restored, backupPath: usedBackup, queueWarning };
+}
+export function readHooksQueue(queuePath) {
+    if (!existsSync(queuePath))
+        return [];
+    const raw = readFileSync(queuePath, "utf-8");
+    const events = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            events.push({ hook_event_name: "log_parse_error" });
+        }
+    }
+    return events;
+}
+function isNonEmptyString(v) {
+    return typeof v === "string" && v.trim().length > 0;
+}
+function workspaceRootsPopulated(v) {
+    if (!Array.isArray(v) || v.length === 0)
+        return false;
+    return v.some((r) => isNonEmptyString(r));
+}
+export function analyzeHookEvent(event) {
+    const field_checks = REQUIRED_HOOK_FIELDS.map((field) => {
+        const value = event[field];
+        const present = value !== undefined;
+        let populated = false;
+        let note;
+        if (field === "workspace_roots") {
+            populated = workspaceRootsPopulated(value);
+            if (present && !populated)
+                note = "empty or non-string array";
+        }
+        else {
+            populated = isNonEmptyString(value);
+            if (present && !populated)
+                note = "empty string";
+        }
+        return { field, present, populated, note };
+    });
+    return {
+        captured_at: typeof event.captured_at === "string" ? event.captured_at : null,
+        hook_event_name: typeof event.hook_event_name === "string" ? event.hook_event_name : null,
+        field_checks,
+        passes_required_fields: field_checks.every((c) => c.populated),
+    };
+}
+export function verifyHooksConfig(appDir) {
+    const installedForwarder = join(appDir, FORWARDER_FILENAME);
+    const queuePath = join(appDir, "hooks-queue.ndjson");
+    let hooks_json_installed = false;
+    if (existsSync(USER_HOOKS_JSON)) {
+        const config = parseHooksJson(readFileSync(USER_HOOKS_JSON, "utf-8"));
+        hooks_json_installed = config !== null && hooksConfigUsesForwarder(config, installedForwarder);
+    }
+    const events = readHooksQueue(queuePath);
+    const analyzed = events.map(analyzeHookEvent);
+    const passing = analyzed.filter((a) => a.passes_required_fields);
+    const required_fields_verified = passing.length > 0;
+    const sample_events = passing.slice(-3);
+    if (sample_events.length === 0 && analyzed.length > 0) {
+        sample_events.push(...analyzed.slice(-2));
+    }
+    const next_steps = [];
+    if (!hooks_json_installed) {
+        next_steps.push("Run: aixle-insights init --hooks");
+    }
+    else if (events.length === 0) {
+        next_steps.push("Restart Cursor, then run an Agent session to emit hook events.");
+        next_steps.push("Re-run: aixle-insights verify-hooks");
+    }
+    return {
+        captured_at: new Date().toISOString(),
+        platform: process.platform,
+        hooks_json_installed,
+        backup_exists: existsSync(USER_HOOKS_JSON + HOOKS_BACKUP_SUFFIX),
+        queue_path_redacted: redactHomePath(queuePath),
+        queue_depth: events.length,
+        required_fields_verified,
+        sample_events,
+        next_steps,
+    };
+}

package/dist/install/claude.d.ts

@@ -0,0 +1,37 @@
+/**
+ * User-scope Claude Code MCP servers live in ~/.claude.json under top-level `mcpServers`
+ * (see Anthropic Claude Code MCP docs: user scope → ~/.claude.json; project scope → .mcp.json).
+ */
+export type InstallResult = {
+    kind: "already-configured";
+} | {
+    kind: "installed";
+} | {
+    kind: "requires-force";
+    detail: string;
+} | {
+    kind: "error";
+    message: string;
+};
+export interface InstallClaudeUserMcpOptions {
+    /** Tests: full path to the Claude user config file (default ~/.claude.json). */
+    claudeConfigPath?: string;
+    force?: boolean;
+}
+export declare function defaultClaudeUserConfigPath(): string;
+/** Exposed for tests; `platform` defaults to `process.platform`. */
+export declare function desiredAixleInsightsEntry(platform?: NodeJS.Platform): {
+    command: string;
+    args: string[];
+};
+export declare function aixleInsightsEntryMatchesDesired(existing: unknown, desired: {
+    command: string;
+    args: string[];
+}): boolean;
+/**
+ * Merges top-level `mcpServers.aixle-insights` into ~/.claude.json (or overridden path).
+ * Preserves all other keys and MCP server entries. If a legacy `mcpServers.db90`
+ * entry from a prior install is present, removes it so Claude Code does not
+ * spawn both old and new MCP servers (delete-old-key shim).
+ */
+export declare function installClaudeUserMcp(options?: InstallClaudeUserMcpOptions): InstallResult;

package/dist/install/claude.js

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+export function defaultClaudeUserConfigPath() {
+    const override = process.env["DB90_CLAUDE_USER_CONFIG_PATH"]?.trim();
+    if (override)
+        return override;
+    return join(homedir(), ".claude.json");
+}
+/** Exposed for tests; `platform` defaults to `process.platform`. */
+export function desiredAixleInsightsEntry(platform = process.platform) {
+    if (platform === "win32") {
+        return {
+            command: "cmd",
+            args: ["/c", "npx", "-y", "@aixle/insights", "run"],
+        };
+    }
+    return {
+        command: "npx",
+        args: ["-y", "@aixle/insights", "run"],
+    };
+}
+function readRootObject(path) {
+    if (!existsSync(path)) {
+        return {};
+    }
+    try {
+        const raw = readFileSync(path, "utf-8");
+        if (!raw.trim()) {
+            return {};
+        }
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return {
+                kind: "error",
+                message: `${path}: top-level JSON value must be an object.`,
+            };
+        }
+        return parsed;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { kind: "error", message: `Cannot read ${path}: ${msg}` };
+    }
+}
+function normalizeCommandEntry(e) {
+    if (typeof e !== "object" || e === null)
+        return null;
+    const o = e;
+    if (typeof o.command !== "string")
+        return null;
+    if (!Array.isArray(o.args) || !o.args.every((x) => typeof x === "string"))
+        return null;
+    return { command: o.command, args: [...o.args] };
+}
+export function aixleInsightsEntryMatchesDesired(existing, desired) {
+    const norm = normalizeCommandEntry(existing);
+    if (!norm)
+        return false;
+    if (norm.command !== desired.command || norm.args.length !== desired.args.length)
+        return false;
+    return norm.args.every((a, i) => a === desired.args[i]);
+}
+function atomicWriteJson(path, data) {
+    try {
+        const dir = dirname(path);
+        mkdirSync(dir, { recursive: true });
+        const serialized = `${JSON.stringify(data, null, 2)}\n`;
+        const tmpPath = join(dir, `.aixle-insights-claude-json-${randomBytes(8).toString("hex")}.tmp`);
+        writeFileSync(tmpPath, serialized, "utf-8");
+        renameSync(tmpPath, path);
+        return { kind: "installed" };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { kind: "error", message: `Failed to write ${path}: ${msg}` };
+    }
+}
+const LEGACY_MCP_KEY = "db90";
+const AIXLE_INSIGHTS_MCP_KEY = "aixle-insights";
+/**
+ * Merges top-level `mcpServers.aixle-insights` into ~/.claude.json (or overridden path).
+ * Preserves all other keys and MCP server entries. If a legacy `mcpServers.db90`
+ * entry from a prior install is present, removes it so Claude Code does not
+ * spawn both old and new MCP servers (delete-old-key shim).
+ */
+export function installClaudeUserMcp(options = {}) {
+    const path = options.claudeConfigPath ?? defaultClaudeUserConfigPath();
+    const force = options.force === true;
+    const desired = desiredAixleInsightsEntry();
+    const rootRead = readRootObject(path);
+    if ("kind" in rootRead && typeof rootRead.kind === "string" && rootRead.kind === "error") {
+        return rootRead;
+    }
+    const root = {
+        ...rootRead,
+    };
+    const rawServers = root["mcpServers"];
+    let mcpServers;
+    if (rawServers === undefined) {
+        mcpServers = {};
+    }
+    else if (typeof rawServers === "object" &&
+        rawServers !== null &&
+        !Array.isArray(rawServers)) {
+        mcpServers = { ...rawServers };
+    }
+    else {
+        return {
+            kind: "error",
+            message: `Invalid Claude config at ${path}: "mcpServers" must be an object when present.`,
+        };
+    }
+    const existing = mcpServers[AIXLE_INSIGHTS_MCP_KEY];
+    if (existing !== undefined) {
+        if (aixleInsightsEntryMatchesDesired(existing, desired)) {
+            // Even if the new entry matches, clean up the legacy "db90" key if it
+            // somehow still exists (defensive — handles users who manually copied
+            // both keys, or partial-state from earlier installs).
+            if (mcpServers[LEGACY_MCP_KEY] !== undefined) {
+                delete mcpServers[LEGACY_MCP_KEY];
+                root["mcpServers"] = mcpServers;
+                return atomicWriteJson(path, root);
+            }
+            return { kind: "already-configured" };
+        }
+        if (!force) {
+            return {
+                kind: "requires-force",
+                detail: 'A different "aixle-insights" MCP server entry already exists in the Claude Code user config (~/.claude.json). Re-run with `init --force` to replace only that entry.',
+            };
+        }
+    }
+    // Delete-old-key shim: an existing "db90" entry from a prior install must
+    // go before we write the new "aixle-insights" entry. Otherwise Claude Code
+    // would spawn BOTH MCP servers and we would get duplicate ingestion.
+    if (mcpServers[LEGACY_MCP_KEY] !== undefined) {
+        delete mcpServers[LEGACY_MCP_KEY];
+    }
+    mcpServers[AIXLE_INSIGHTS_MCP_KEY] = { command: desired.command, args: desired.args };
+    root["mcpServers"] = mcpServers;
+    return atomicWriteJson(path, root);
+}

package/dist/install/index.d.ts

@@ -0,0 +1,8 @@
+import { type InstallClaudeUserMcpOptions, type InstallResult } from "./claude.js";
+export type SupportedEditor = "claude";
+export type { InstallClaudeUserMcpOptions, InstallResult };
+/**
+ * Editor dispatch for MCP install hooks. Only Claude Code is supported in this story.
+ */
+export declare function installEditorMcp(editor: SupportedEditor, options?: InstallClaudeUserMcpOptions): InstallResult;
+export { installClaudeUserMcp, defaultClaudeUserConfigPath, desiredAixleInsightsEntry, aixleInsightsEntryMatchesDesired, } from "./claude.js";

package/dist/install/index.js

@@ -0,0 +1,11 @@
+import { installClaudeUserMcp, } from "./claude.js";
+/**
+ * Editor dispatch for MCP install hooks. Only Claude Code is supported in this story.
+ */
+export function installEditorMcp(editor, options = {}) {
+    if (editor === "claude") {
+        return installClaudeUserMcp(options);
+    }
+    return { kind: "error", message: `Unsupported editor for MCP install: ${String(editor)}` };
+}
+export { installClaudeUserMcp, defaultClaudeUserConfigPath, desiredAixleInsightsEntry, aixleInsightsEntryMatchesDesired, } from "./claude.js";

package/dist/lib/args.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared CLI argument base type. Every connector exposes at minimum these
+ * flags; each extends this shape with tool-specific flags (claude adds
+ * `--watch` / `--watch-interval`, cursor adds `--since`).
+ *
+ * The full argv parsing loop stays in each connector's `cli.ts` because the
+ * flag sets diverge enough that a generic parser would be more complex than
+ * two small switch statements. This type + the helpers below are the shared
+ * vocabulary.
+ */
+export interface BaseArgs {
+    token?: string;
+    host?: string;
+    projectId?: string;
+    dryRun: boolean;
+    verbose: boolean;
+    help: boolean;
+}
+export declare const BASE_ARGS_DEFAULTS: BaseArgs;
+/**
+ * If `arg` is of the form `--name=VALUE`, return VALUE. Otherwise undefined.
+ * Callers are responsible for checking the name prefix separately.
+ *
+ * Example: extractEqualsValue("--token=abc", "--token") === "abc"
+ */
+export declare function extractEqualsValue(arg: string, name: string): string | undefined;

package/dist/lib/args.js

@@ -0,0 +1,17 @@
+export const BASE_ARGS_DEFAULTS = {
+    dryRun: false,
+    verbose: false,
+    help: false,
+};
+/**
+ * If `arg` is of the form `--name=VALUE`, return VALUE. Otherwise undefined.
+ * Callers are responsible for checking the name prefix separately.
+ *
+ * Example: extractEqualsValue("--token=abc", "--token") === "abc"
+ */
+export function extractEqualsValue(arg, name) {
+    const prefix = `${name}=`;
+    if (arg.startsWith(prefix))
+        return arg.slice(prefix.length);
+    return undefined;
+}

package/dist/lib/client.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Minimum payload contract for ingestion — every connector produces events that
+ * at least carry an ISO timestamp. Connectors add their own fields; we don't
+ * constrain them here so the SDK stays tool-agnostic.
+ */
+export interface IngestPayload {
+    occurred_at: string;
+    [key: string]: unknown;
+}
+export interface PostEventOptions {
+    /** Override default console.error on non-ok HTTP response. */
+    onHttpError?: (status: number, statusText: string, body: string) => void;
+    /** Override default console.error on network-level failure. */
+    onNetworkError?: (err: unknown) => void;
+    /**
+     * Called when the server responds with 429 Too Many Requests.
+     * @param retryAfter - seconds to wait before retrying (from Retry-After header, capped at 3600).
+     * @param quotaExceeded - true when the monthly event quota is exhausted (code: "quota_exceeded").
+     */
+    on429?: (retryAfter: number, quotaExceeded: boolean) => void;
+}
+/**
+ * POST a single event payload to the db90 ingest endpoint.
+ *
+ * Shared HTTP primitive for all connectors. Each connector wraps this in its
+ * own batching / watermarking logic (cursor tracks `lastSentAt` across a
+ * batch; claude aggregates `sent`/`failed` counts). Result shapes differ by
+ * connector, so they are NOT unified here.
+ *
+ * Returns true on 2xx response, false on any HTTP error or network failure.
+ * Never throws — callers can rely on Promise.allSettled-style aggregation.
+ */
+export declare function postEvent(payload: IngestPayload, host: string, token: string, options?: PostEventOptions): Promise<boolean>;

package/dist/lib/client.js

@@ -0,0 +1,52 @@
+/**
+ * POST a single event payload to the db90 ingest endpoint.
+ *
+ * Shared HTTP primitive for all connectors. Each connector wraps this in its
+ * own batching / watermarking logic (cursor tracks `lastSentAt` across a
+ * batch; claude aggregates `sent`/`failed` counts). Result shapes differ by
+ * connector, so they are NOT unified here.
+ *
+ * Returns true on 2xx response, false on any HTTP error or network failure.
+ * Never throws — callers can rely on Promise.allSettled-style aggregation.
+ */
+export async function postEvent(payload, host, token, options = {}) {
+    const url = `${host.replace(/\/$/, "")}/api/v1/ingest/events`;
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+    };
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+        });
+        if (response.ok) {
+            return true;
+        }
+        if (response.status === 429) {
+            const raw = response.headers.get("Retry-After") ?? "60";
+            const parsed = parseInt(raw, 10);
+            const retryAfter = Number.isFinite(parsed) && parsed > 0 ? parsed : 60;
+            const bodyJson = await response.json().catch(() => ({}));
+            const quotaExceeded = bodyJson?.code === "quota_exceeded";
+            options.on429?.(retryAfter, quotaExceeded);
+            return false;
+        }
+        const body = await response.text().catch(() => "");
+        const onHttpError = options.onHttpError ??
+            ((status, statusText, errBody) => {
+                console.error(`Failed to post event: HTTP ${status} ${statusText}${errBody ? ` — ${errBody}` : ""}`);
+            });
+        onHttpError(response.status, response.statusText, body);
+        return false;
+    }
+    catch (err) {
+        const onNetworkError = options.onNetworkError ??
+            ((error) => {
+                console.error(`Network error posting event: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        onNetworkError(err);
+        return false;
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Common config envelope every connector's `config.json` file carries. Pricing
+ * is connector-specific (claude = model-keyed, cursor = flat line-cost rates)
+ * so it's extracted through a caller-provided parser rather than baked in.
+ */
+export interface BaseConfig {
+    token?: string;
+    host?: string;
+    project_id?: string;
+}
+/**
+ * Load a connector's `config.json` from disk. Returns `{}` on missing or
+ * malformed files — callers fall back to env vars / CLI flags / defaults.
+ *
+ * @param configDir Directory containing `config.json`, typically the
+ *                  connector's `APP_DIR` (`~/.db90-claude` / `~/.db90-cursor`).
+ * @param parsePricing Optional callback that extracts a connector-specific
+ *                     pricing shape from the raw parsed JSON. Returns
+ *                     `undefined` when the pricing block is missing or invalid.
+ *                     The callback is the extension point for connector-specific
+ *                     validation (claude uses structural checks on a model map;
+ *                     cursor coerces a fixed set of numeric rates).
+ */
+export declare function loadBaseConfig<TPricing = never>(configDir: string, parsePricing?: (raw: Record<string, unknown>) => TPricing | undefined): BaseConfig & {
+    pricing?: TPricing;
+};

package/dist/lib/config.js

@@ -0,0 +1,39 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Load a connector's `config.json` from disk. Returns `{}` on missing or
+ * malformed files — callers fall back to env vars / CLI flags / defaults.
+ *
+ * @param configDir Directory containing `config.json`, typically the
+ *                  connector's `APP_DIR` (`~/.db90-claude` / `~/.db90-cursor`).
+ * @param parsePricing Optional callback that extracts a connector-specific
+ *                     pricing shape from the raw parsed JSON. Returns
+ *                     `undefined` when the pricing block is missing or invalid.
+ *                     The callback is the extension point for connector-specific
+ *                     validation (claude uses structural checks on a model map;
+ *                     cursor coerces a fixed set of numeric rates).
+ */
+export function loadBaseConfig(configDir, parsePricing) {
+    const configPath = join(configDir, "config.json");
+    try {
+        const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (typeof parsed === "object" && parsed !== null) {
+            const obj = parsed;
+            const result = {
+                token: typeof obj.token === "string" ? obj.token : undefined,
+                host: typeof obj.host === "string" ? obj.host : undefined,
+                project_id: typeof obj.project_id === "string" ? obj.project_id : undefined,
+            };
+            if (parsePricing) {
+                const pricing = parsePricing(obj);
+                if (pricing !== undefined)
+                    result.pricing = pricing;
+            }
+            return result;
+        }
+    }
+    catch {
+        // missing or invalid config — fall through
+    }
+    return {};
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./project-resolver.js";
+export * from "./client.js";
+export * from "./config.js";
+export * from "./args.js";

package/dist/lib/index.js

@@ -0,0 +1,4 @@
+export * from "./project-resolver.js";
+export * from "./client.js";
+export * from "./config.js";
+export * from "./args.js";