trickle-cli 0.1.0

package/dist/api-client.d.ts

@@ -0,0 +1,208 @@
+export interface FunctionRow {
+    id: number;
+    function_name: string;
+    module: string;
+    language: string;
+    environment: string;
+    first_seen_at: string;
+    last_seen_at: string;
+}
+export interface FunctionDetail {
+    function: FunctionRow;
+    latestSnapshots: Record<string, TypeSnapshot>;
+}
+export interface TypeSnapshot {
+    id: number;
+    function_id: number;
+    type_hash: string;
+    env: string;
+    args_type: unknown;
+    return_type: unknown;
+    observed_at: string;
+    sample_input?: unknown;
+    sample_output?: unknown;
+}
+export interface ErrorRow {
+    id: number;
+    function_id: number;
+    function_name: string;
+    module: string;
+    language: string;
+    env: string;
+    error_type: string;
+    error_message: string;
+    stack_trace?: string;
+    type_hash?: string;
+    args_type?: unknown;
+    return_type?: unknown;
+    variables_type?: unknown;
+    args_snapshot?: unknown;
+    occurred_at: string;
+}
+export interface ErrorDetail {
+    error: ErrorRow;
+    snapshot: TypeSnapshot | null;
+}
+export interface TypeDiff {
+    kind: "added" | "removed" | "changed";
+    path: string;
+    from?: unknown;
+    to?: unknown;
+    type?: unknown;
+}
+export interface DiffResponse {
+    from: {
+        id: number;
+        env: string;
+        observed_at: string;
+    };
+    to: {
+        id: number;
+        env: string;
+        observed_at: string;
+    };
+    diffs: TypeDiff[];
+}
+export interface TailEvent {
+    event: string;
+    data: Record<string, unknown>;
+}
+export interface ListFunctionsOpts {
+    env?: string;
+    language?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
+export declare function listFunctions(opts?: ListFunctionsOpts): Promise<{
+    functions: FunctionRow[];
+    total: number;
+}>;
+export declare function getFunction(id: number): Promise<FunctionDetail>;
+export interface ListErrorsOpts {
+    env?: string;
+    functionName?: string;
+    since?: string;
+    limit?: number;
+    offset?: number;
+}
+export declare function listErrors(opts?: ListErrorsOpts): Promise<{
+    errors: ErrorRow[];
+    total: number;
+}>;
+export declare function getError(id: number): Promise<ErrorDetail>;
+export interface ListTypesOpts {
+    env?: string;
+    limit?: number;
+}
+export declare function listTypes(functionId: number, opts?: ListTypesOpts): Promise<{
+    snapshots: TypeSnapshot[];
+}>;
+export interface GetTypeDiffOpts {
+    from?: number;
+    to?: number;
+    fromEnv?: string;
+    toEnv?: string;
+}
+export declare function getTypeDiff(functionId: number, opts?: GetTypeDiffOpts): Promise<DiffResponse>;
+export interface CodegenOpts {
+    functionName?: string;
+    env?: string;
+    language?: string;
+    format?: string;
+}
+export declare function fetchCodegen(opts?: CodegenOpts): Promise<{
+    types: string;
+}>;
+export interface AnnotationParam {
+    name: string;
+    type: string;
+}
+export interface AnnotationEntry {
+    params: AnnotationParam[];
+    returnType: string;
+}
+export declare function fetchAnnotations(opts?: {
+    env?: string;
+    language?: string;
+}): Promise<{
+    annotations: Record<string, AnnotationEntry>;
+}>;
+export interface StubsResponse {
+    stubs: Record<string, {
+        ts: string;
+        python: string;
+    }>;
+}
+export declare function fetchStubs(opts?: {
+    env?: string;
+}): Promise<StubsResponse>;
+export interface MockRoute {
+    method: string;
+    path: string;
+    functionName: string;
+    module: string;
+    sampleInput: unknown;
+    sampleOutput: unknown;
+    observedAt: string;
+}
+export declare function fetchMockConfig(): Promise<{
+    routes: MockRoute[];
+}>;
+export interface SnapshotFunction {
+    name: string;
+    module: string;
+    env?: string;
+    argsType: unknown;
+    returnType: unknown;
+}
+export interface CheckSnapshot {
+    version: number;
+    createdAt: string;
+    functions: SnapshotFunction[];
+}
+export declare function fetchSnapshot(opts?: {
+    env?: string;
+}): Promise<CheckSnapshot>;
+export interface OpenApiOpts {
+    env?: string;
+    title?: string;
+    version?: string;
+    serverUrl?: string;
+}
+export declare function fetchOpenApiSpec(opts?: OpenApiOpts): Promise<object>;
+export interface DiffReportEntry {
+    functionName: string;
+    module: string;
+    language: string;
+    from: {
+        id: number;
+        env: string;
+        observed_at: string;
+        type_hash: string;
+    };
+    to: {
+        id: number;
+        env: string;
+        observed_at: string;
+        type_hash: string;
+    };
+    diffs: TypeDiff[];
+}
+export interface DiffReportResponse {
+    mode: "temporal" | "cross-env";
+    entries: DiffReportEntry[];
+    total: number;
+    since?: string | null;
+    env?: string | null;
+    env1?: string;
+    env2?: string;
+}
+export interface DiffReportOpts {
+    since?: string;
+    env?: string;
+    env1?: string;
+    env2?: string;
+}
+export declare function fetchDiffReport(opts?: DiffReportOpts): Promise<DiffReportResponse>;
+export declare function tailEvents(onEvent: (event: TailEvent) => void, filter?: string): () => void;

package/dist/api-client.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFunctions = listFunctions;
+exports.getFunction = getFunction;
+exports.listErrors = listErrors;
+exports.getError = getError;
+exports.listTypes = listTypes;
+exports.getTypeDiff = getTypeDiff;
+exports.fetchCodegen = fetchCodegen;
+exports.fetchAnnotations = fetchAnnotations;
+exports.fetchStubs = fetchStubs;
+exports.fetchMockConfig = fetchMockConfig;
+exports.fetchSnapshot = fetchSnapshot;
+exports.fetchOpenApiSpec = fetchOpenApiSpec;
+exports.fetchDiffReport = fetchDiffReport;
+exports.tailEvents = tailEvents;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const url_1 = require("url");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("./config");
+// ── Helpers ──
+function backendUrl() {
+    return (0, config_1.getBackendUrl)();
+}
+function connectionError() {
+    const url = backendUrl();
+    console.error(chalk_1.default.red(`\nCannot connect to trickle backend at ${chalk_1.default.bold(url)}.`));
+    console.error(chalk_1.default.red("Is the backend running?\n"));
+    process.exit(1);
+}
+async function fetchJson(path, query) {
+    const base = backendUrl();
+    const url = new url_1.URL(path, base);
+    if (query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined && value !== "") {
+                url.searchParams.set(key, value);
+            }
+        }
+    }
+    try {
+        const res = await fetch(url.toString());
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`HTTP ${res.status}: ${body}`);
+        }
+        return (await res.json());
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.startsWith("HTTP ")) {
+            throw err;
+        }
+        connectionError();
+    }
+}
+async function listFunctions(opts) {
+    return fetchJson("/api/functions", {
+        env: opts?.env,
+        language: opts?.language,
+        q: opts?.search,
+        limit: opts?.limit?.toString(),
+        offset: opts?.offset?.toString(),
+    });
+}
+async function getFunction(id) {
+    return fetchJson(`/api/functions/${id}`);
+}
+async function listErrors(opts) {
+    return fetchJson("/api/errors", {
+        env: opts?.env,
+        functionName: opts?.functionName,
+        since: opts?.since,
+        limit: opts?.limit?.toString(),
+        offset: opts?.offset?.toString(),
+    });
+}
+async function getError(id) {
+    return fetchJson(`/api/errors/${id}`);
+}
+async function listTypes(functionId, opts) {
+    return fetchJson(`/api/types/${functionId}`, {
+        env: opts?.env,
+        limit: opts?.limit?.toString(),
+    });
+}
+async function getTypeDiff(functionId, opts) {
+    return fetchJson(`/api/types/${functionId}/diff`, {
+        from: opts?.from?.toString(),
+        to: opts?.to?.toString(),
+        fromEnv: opts?.fromEnv,
+        toEnv: opts?.toEnv,
+    });
+}
+async function fetchCodegen(opts) {
+    const pathStr = opts?.functionName
+        ? `/api/codegen/${encodeURIComponent(opts.functionName)}`
+        : "/api/codegen";
+    return fetchJson(pathStr, {
+        env: opts?.env,
+        language: opts?.language,
+        format: opts?.format,
+    });
+}
+async function fetchAnnotations(opts) {
+    return fetchJson("/api/codegen", {
+        env: opts?.env,
+        language: opts?.language,
+        format: "annotate",
+    });
+}
+async function fetchStubs(opts) {
+    return fetchJson("/api/codegen", {
+        env: opts?.env,
+        format: "stubs",
+    });
+}
+async function fetchMockConfig() {
+    return fetchJson("/api/mock-config");
+}
+async function fetchSnapshot(opts) {
+    return fetchJson("/api/codegen", {
+        format: "snapshot",
+        env: opts?.env,
+    });
+}
+async function fetchOpenApiSpec(opts) {
+    return fetchJson("/api/codegen", {
+        format: "openapi",
+        env: opts?.env,
+        title: opts?.title,
+        version: opts?.version,
+        serverUrl: opts?.serverUrl,
+    });
+}
+async function fetchDiffReport(opts) {
+    return fetchJson("/api/diff", {
+        since: opts?.since,
+        env: opts?.env,
+        env1: opts?.env1,
+        env2: opts?.env2,
+    });
+}
+function tailEvents(onEvent, filter) {
+    const base = backendUrl();
+    const url = new url_1.URL("/api/tail", base);
+    if (filter) {
+        url.searchParams.set("filter", filter);
+    }
+    const mod = url.protocol === "https:" ? https : http;
+    let destroyed = false;
+    let currentReq = null;
+    function connect() {
+        if (destroyed)
+            return;
+        const req = mod.get(url.toString(), (res) => {
+            let buffer = "";
+            res.on("data", (chunk) => {
+                buffer += chunk.toString();
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                let currentEvent = "";
+                for (const line of lines) {
+                    if (line.startsWith("event: ")) {
+                        currentEvent = line.slice(7).trim();
+                    }
+                    else if (line.startsWith("data: ")) {
+                        const dataStr = line.slice(6).trim();
+                        try {
+                            const data = JSON.parse(dataStr);
+                            onEvent({ event: currentEvent, data });
+                        }
+                        catch {
+                            // Ignore invalid JSON
+                        }
+                        currentEvent = "";
+                    }
+                }
+            });
+            res.on("end", () => {
+                if (!destroyed) {
+                    // Reconnect after a delay
+                    setTimeout(connect, 2000);
+                }
+            });
+        });
+        req.on("error", () => {
+            if (!destroyed) {
+                setTimeout(connect, 3000);
+            }
+        });
+        currentReq = req;
+    }
+    connect();
+    return () => {
+        destroyed = true;
+        if (currentReq) {
+            currentReq.destroy();
+        }
+    };
+}

package/dist/commands/annotate.d.ts

@@ -0,0 +1,6 @@
+export interface AnnotateOptions {
+    env?: string;
+    dryRun?: boolean;
+    jsdoc?: boolean;
+}
+export declare function annotateCommand(file: string, opts: AnnotateOptions): Promise<void>;