@dataparade/cli 0.0.1

package/dist/src/ai-enrichment/providers/platform-proxy-provider.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformProxyProvider = void 0;
+function resolvePollTimeoutMs(configured) {
+    if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {
+        return Math.floor(configured);
+    }
+    const fromEnv = Number(process.env.SCAN_AI_HTTP_TIMEOUT_MS ?? "");
+    if (Number.isFinite(fromEnv) && fromEnv > 0)
+        return Math.floor(fromEnv);
+    return 180_000;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class PlatformProxyProvider {
+    constructor(config) {
+        this.config = config;
+        this.id = "openai";
+    }
+    authHeaders() {
+        return {
+            Authorization: `Bearer ${this.config.workspaceApiKey}`,
+            "Content-Type": "application/json",
+        };
+    }
+    apiBase() {
+        return this.config.apiBaseUrl.replace(/\/$/, "");
+    }
+    async readErrorMessage(res) {
+        let message = `Platform AI infer failed (${res.status})`;
+        try {
+            const body = (await res.json());
+            if (typeof body.message === "string")
+                message = body.message;
+            else if (Array.isArray(body.message))
+                message = body.message.join(", ");
+        }
+        catch {
+            // ignore
+        }
+        return message;
+    }
+    throwPlatformError(res, message) {
+        if (res.status >= 500) {
+            const detail = message === `Platform AI infer failed (${res.status})`
+                ? "Internal server error"
+                : message;
+            throw new Error(`Platform AI service error (${res.status}): ${detail}. If this persists, redeploy the API with the CLI bundle and verify SCAN_WORKER_LLM_API_KEY.`);
+        }
+        throw new Error(message);
+    }
+    async infer(request) {
+        const submitRes = await fetch(`${this.apiBase()}/api/scans/cli/ai/infer/tasks`, {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({
+                jobId: this.config.jobId,
+                tasks: [
+                    {
+                        prompt: request.prompt,
+                        maxTokens: request.maxTokens,
+                        temperature: request.temperature,
+                    },
+                ],
+            }),
+        });
+        if (!submitRes.ok) {
+            const message = await this.readErrorMessage(submitRes);
+            this.throwPlatformError(submitRes, message);
+        }
+        const submitBody = (await submitRes.json());
+        const task = submitBody.tasks?.[0];
+        if (!task?.taskId) {
+            throw new Error("Platform AI infer submit returned no task id");
+        }
+        const pollIntervalMs = Math.max(500, Math.floor(this.config.pollIntervalMs ?? 1500));
+        const deadline = Date.now() + resolvePollTimeoutMs(this.config.pollTimeoutMs);
+        while (Date.now() < deadline) {
+            const pollRes = await fetch(`${this.apiBase()}/api/scans/cli/ai/infer/tasks?jobId=${encodeURIComponent(this.config.jobId)}&taskIds=${encodeURIComponent(task.taskId)}`, {
+                method: "GET",
+                headers: this.authHeaders(),
+            });
+            if (!pollRes.ok) {
+                const message = await this.readErrorMessage(pollRes);
+                this.throwPlatformError(pollRes, message);
+            }
+            const pollBody = (await pollRes.json());
+            const current = pollBody.tasks?.[0];
+            if (!current) {
+                throw new Error("Platform AI infer poll returned no task");
+            }
+            if (current.status === "completed") {
+                const proposals = (Array.isArray(current.proposals) ? current.proposals : []);
+                const usage = current.usage;
+                return {
+                    proposals,
+                    usage: usage && typeof usage.totalTokens === "number"
+                        ? {
+                            inputTokens: Math.max(0, usage.inputTokens ?? 0),
+                            outputTokens: Math.max(0, usage.outputTokens ?? 0),
+                            totalTokens: Math.max(0, usage.totalTokens),
+                        }
+                        : undefined,
+                };
+            }
+            if (current.status === "failed") {
+                throw new Error(current.errorMessage?.trim() ||
+                    "Platform AI infer task failed without details");
+            }
+            await sleep(pollIntervalMs);
+        }
+        throw new Error(`Platform AI infer task timed out after ${resolvePollTimeoutMs(this.config.pollTimeoutMs)}ms (taskId=${task.taskId})`);
+    }
+}
+exports.PlatformProxyProvider = PlatformProxyProvider;

package/dist/src/ai-enrichment/providers/presets.d.ts

@@ -0,0 +1,14 @@
+import type { AiProviderId } from "../types";
+/** How the CLI speaks HTTP to a model API (not a vendor brand). */
+export type AiApiFamily = "chat-completions" | "messages" | "generate-content" | "ollama-generate" | "mock";
+export type AiProviderAuthStyle = "bearer" | "x-api-key" | "query-key" | "none";
+export type AiStructuredOutputMode = "openai-json-schema" | "openai-json-object" | "gemini-json-mime" | "prompt-only";
+export interface AiProviderPresetDefinition {
+    family: AiApiFamily;
+    defaultEndpoint: string;
+    auth: AiProviderAuthStyle;
+    defaultModel: string;
+    structuredOutput?: AiStructuredOutputMode;
+}
+export declare const AI_PROVIDER_PRESETS: Record<AiProviderId, AiProviderPresetDefinition>;
+export declare function getProviderPreset(presetId: AiProviderId): AiProviderPresetDefinition;

package/dist/src/ai-enrichment/providers/presets.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_PROVIDER_PRESETS = void 0;
+exports.getProviderPreset = getProviderPreset;
+exports.AI_PROVIDER_PRESETS = {
+    openai: {
+        family: "chat-completions",
+        defaultEndpoint: "https://api.openai.com/v1/chat/completions",
+        auth: "bearer",
+        defaultModel: "gpt-4o-mini",
+        structuredOutput: "openai-json-schema",
+    },
+    anthropic: {
+        family: "messages",
+        defaultEndpoint: "https://api.anthropic.com/v1/messages",
+        auth: "x-api-key",
+        defaultModel: "claude-sonnet-4-5",
+        structuredOutput: "prompt-only",
+    },
+    gemini: {
+        family: "generate-content",
+        defaultEndpoint: "https://generativelanguage.googleapis.com/v1beta/models",
+        auth: "query-key",
+        defaultModel: "gemini-1.5-flash",
+        structuredOutput: "gemini-json-mime",
+    },
+    openrouter: {
+        family: "chat-completions",
+        defaultEndpoint: "https://openrouter.ai/api/v1/chat/completions",
+        auth: "bearer",
+        defaultModel: "openai/gpt-4o-mini",
+        structuredOutput: "openai-json-object",
+    },
+    local: {
+        family: "ollama-generate",
+        defaultEndpoint: "http://localhost:11434/api/generate",
+        auth: "none",
+        defaultModel: "llama3.1",
+        structuredOutput: "prompt-only",
+    },
+    mock: {
+        family: "mock",
+        defaultEndpoint: "",
+        auth: "none",
+        defaultModel: "heuristic",
+    },
+};
+function getProviderPreset(presetId) {
+    return exports.AI_PROVIDER_PRESETS[presetId];
+}

package/dist/src/ai-enrichment/providers/provider-contract.d.ts

@@ -0,0 +1,20 @@
+import type { AiAgentName, AiProposal, AiProviderId } from "../types";
+/** Built from the JSON user payload ({@link buildProviderPromptPayload}) to validate evidence. */
+export interface ProposalsValidationContext {
+    excerptPaths: Set<string>;
+    excerptsByNormPath: Map<string, string>;
+    allowedPathsByComponentId: Map<string, Set<string>>;
+}
+export declare function buildProposalsValidationContext(userPrompt: string): ProposalsValidationContext | null;
+export declare function parseAgentFromPrompt(prompt: string): AiAgentName;
+export declare function aiDebugEnabled(): boolean;
+export interface StrictParseProposalsOptions {
+    debugLabel: string;
+    /** JSON user message from {@link buildProviderPromptPayload}; validates evidence paths and line ranges. */
+    userPrompt?: string;
+}
+export declare function strictParseAndNormalizeProposals(raw: unknown, defaults: {
+    provider: AiProviderId;
+    model: string;
+    agent: AiAgentName;
+}, options: StrictParseProposalsOptions): AiProposal[];