@dataparade/cli 0.0.1

package/dist/src/ai-enrichment/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./types";
+export * from "./candidate-selector";
+export * from "./planner";
+export * from "./merge-rules";
+export * from "./pipeline";
+export * from "./fallbacks";
+export * from "./agent-orchestrator";
+export * from "./tools";
+export * from "./providers";
+export * from "./agents";
+export * from "./types";
+export * from "./merge-rules";
+export * from "./candidate-selector";
+export * from "./planner";
+export * from "./pipeline";

package/dist/src/ai-enrichment/index.js

@@ -0,0 +1,31 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./candidate-selector"), exports);
+__exportStar(require("./planner"), exports);
+__exportStar(require("./merge-rules"), exports);
+__exportStar(require("./pipeline"), exports);
+__exportStar(require("./fallbacks"), exports);
+__exportStar(require("./agent-orchestrator"), exports);
+__exportStar(require("./tools"), exports);
+__exportStar(require("./providers"), exports);
+__exportStar(require("./agents"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./merge-rules"), exports);
+__exportStar(require("./candidate-selector"), exports);
+__exportStar(require("./planner"), exports);
+__exportStar(require("./pipeline"), exports);

package/dist/src/ai-enrichment/merge-rules.d.ts

@@ -0,0 +1,12 @@
+import type { DetectedComponent } from "../core/types/component";
+import type { DetectedDataFlow } from "../core/types/data-flow";
+import type { AiMergeResult, AiMergeThresholds, AiProposal } from "./types";
+/** When true, flow_patch proposals are not applied — data-flow graph stays exactly as detected before AI. */
+export interface MergeAiProposalsOptions {
+    preserveDataFlowTopology?: boolean;
+    enforceIntraSectionFlowChangesOnly?: boolean;
+}
+export declare function mergeAiProposals(components: DetectedComponent[], dataFlows: DetectedDataFlow[], proposals: Array<{
+    id: string;
+    proposal: AiProposal;
+}>, thresholds?: Partial<AiMergeThresholds>, options?: MergeAiProposalsOptions): AiMergeResult;

package/dist/src/ai-enrichment/merge-rules.js

@@ -0,0 +1,321 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeAiProposals = mergeAiProposals;
+const third_party_subtype_1 = require("./third-party-subtype");
+const sorting_1 = require("../core/pipeline/sorting");
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const DEFAULT_THRESHOLDS = {
+    minComponentPatchConfidence: 0.7,
+    minFlowPatchConfidence: 0.75,
+    minInsertFlowConfidence: 0.85,
+};
+function normalizeAlias(raw) {
+    return raw
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/^\.\//, "")
+        .replace(/\/+$/, "")
+        .toLowerCase();
+}
+function stripIndexSuffix(p) {
+    const normalized = normalizeAlias(p);
+    const base = path_1.default.posix.basename(normalized);
+    const stem = base.replace(/\.[^.]+$/, "");
+    if (stem !== "index")
+        return normalized;
+    const dir = path_1.default.posix.dirname(normalized);
+    return dir === "." ? normalized : normalizeAlias(dir);
+}
+function addAlias(aliasMap, alias, componentId) {
+    const key = normalizeAlias(alias);
+    if (!key)
+        return;
+    const set = aliasMap.get(key) ?? new Set();
+    set.add(componentId);
+    aliasMap.set(key, set);
+}
+function buildComponentAliasMap(components) {
+    const aliasMap = new Map();
+    for (const component of components) {
+        addAlias(aliasMap, component.id, component.id);
+        addAlias(aliasMap, component.name, component.id);
+        for (const loc of component.sourceLocations ?? []) {
+            if (!loc.filePath)
+                continue;
+            const fp = normalizeAlias(loc.filePath);
+            addAlias(aliasMap, fp, component.id);
+            addAlias(aliasMap, stripIndexSuffix(fp), component.id);
+            addAlias(aliasMap, path_1.default.posix.dirname(fp), component.id);
+        }
+        for (const ref of component.detectedFrom ?? []) {
+            const fp = ref.sourceLocation?.filePath;
+            if (!fp)
+                continue;
+            const normalized = normalizeAlias(fp);
+            addAlias(aliasMap, normalized, component.id);
+            addAlias(aliasMap, stripIndexSuffix(normalized), component.id);
+            addAlias(aliasMap, path_1.default.posix.dirname(normalized), component.id);
+        }
+    }
+    return aliasMap;
+}
+function remapComponentPatchTarget(patch, componentIds, aliasMap) {
+    if (componentIds.has(patch.targetComponentId))
+        return patch;
+    const key = normalizeAlias(patch.targetComponentId);
+    const matches = aliasMap.get(key);
+    if (!matches || matches.size !== 1)
+        return patch;
+    const [mappedId] = [...matches];
+    if (!mappedId || !componentIds.has(mappedId))
+        return patch;
+    return {
+        ...patch,
+        targetComponentId: mappedId,
+    };
+}
+function proposalTargetKey(proposal) {
+    if (proposal.kind === "component_patch") {
+        const propKeys = Object.keys(proposal.setProperties ?? {}).sort().join("|");
+        const sub = proposal.setSubType ? `sub:${proposal.setSubType}` : "";
+        const desc = proposal.setDescription ? "desc" : "";
+        return `component:${proposal.targetComponentId}:${propKeys}:${sub}:${desc}`;
+    }
+    if (proposal.targetFlowId) {
+        return `flow:${proposal.targetFlowId}`;
+    }
+    return `flow:${proposal.sourceComponentId}->${proposal.targetComponentId}`;
+}
+function proposalRank(proposal) {
+    const confidenceScore = proposal.confidence.score;
+    const evidenceWeight = proposal.evidence.length / 100;
+    const insertPenalty = proposal.kind === "flow_patch" && proposal.insertIfMissing ? -0.02 : 0;
+    const llmBonus = proposal.provider !== "mock" ? 0.25 : 0;
+    return confidenceScore + evidenceWeight + insertPenalty + llmBonus;
+}
+function sortedProposals(proposals) {
+    return [...proposals].sort((a, b) => {
+        const rankDelta = proposalRank(b.proposal) - proposalRank(a.proposal);
+        if (rankDelta !== 0)
+            return rankDelta;
+        const aKey = proposalTargetKey(a.proposal);
+        const bKey = proposalTargetKey(b.proposal);
+        if (aKey !== bKey)
+            return aKey.localeCompare(bKey);
+        return a.id.localeCompare(b.id);
+    });
+}
+function toProvenance(proposal, confidence) {
+    return {
+        source: "ai_agent",
+        provider: proposal.provider,
+        model: proposal.model,
+        agent: proposal.agent,
+        candidateType: proposal.candidateType,
+        confidence,
+        confidenceBand: proposal.confidence.band,
+        evidence: proposal.evidence,
+    };
+}
+function mergeComponentPatch(components, patch) {
+    const component = components.find((item) => item.id === patch.targetComponentId);
+    if (!component)
+        return false;
+    let changed = false;
+    const normalizedSubType = (0, third_party_subtype_1.normalizeThirdPartySubType)(patch.setSubType);
+    if (normalizedSubType && normalizedSubType !== component.subType) {
+        component.subType = normalizedSubType;
+        changed = true;
+    }
+    if (patch.setDescription && patch.setDescription !== component.description) {
+        component.description = patch.setDescription;
+        changed = true;
+    }
+    const currentProperties = component.properties ?? {};
+    const nextProperties = { ...currentProperties };
+    for (const [key, value] of Object.entries(patch.setProperties ?? {})) {
+        const currentValue = currentProperties[key];
+        if (key === "inference_status" && value === "needs_review") {
+            continue;
+        }
+        const normalizedCurrent = normalizeEmptyLikeValue(currentValue);
+        const normalizedNext = normalizeEmptyLikeValue(value);
+        if ((0, util_1.isDeepStrictEqual)(normalizedCurrent, normalizedNext)) {
+            continue;
+        }
+        nextProperties[key] = value;
+        changed = true;
+    }
+    component.properties = nextProperties;
+    return changed;
+}
+function normalizeEmptyLikeValue(value) {
+    if (value == null)
+        return "__empty__";
+    if (typeof value === "string" && value.trim().toLowerCase() === "none") {
+        return "__empty__";
+    }
+    if (Array.isArray(value) && value.length === 0)
+        return "__empty__";
+    return value;
+}
+function normalizeSectionId(raw) {
+    if (raw == null)
+        return undefined;
+    const section = String(raw).trim();
+    return section.length > 0 ? section : undefined;
+}
+function resolveFlowPatchEndpoints(patch, flows) {
+    if (patch.targetFlowId) {
+        const targetFlow = flows.find((flow) => flow.id === patch.targetFlowId);
+        if (!targetFlow)
+            return undefined;
+        return {
+            sourceComponentId: targetFlow.sourceComponentId,
+            targetComponentId: targetFlow.targetComponentId,
+        };
+    }
+    if (patch.sourceComponentId && patch.targetComponentId) {
+        return {
+            sourceComponentId: patch.sourceComponentId,
+            targetComponentId: patch.targetComponentId,
+        };
+    }
+    return undefined;
+}
+function isIntraSectionFlowPatch(patch, componentsById, flows) {
+    const endpoints = resolveFlowPatchEndpoints(patch, flows);
+    if (!endpoints)
+        return false;
+    const source = componentsById.get(endpoints.sourceComponentId);
+    const target = componentsById.get(endpoints.targetComponentId);
+    if (!source || !target)
+        return false;
+    const sourceSectionId = normalizeSectionId(source.properties?.section_id);
+    const targetSectionId = normalizeSectionId(target.properties?.section_id);
+    return sourceSectionId === targetSectionId;
+}
+function mergeFlowPatch(flows, patch) {
+    const flow = patch.targetFlowId
+        ? flows.find((item) => item.id === patch.targetFlowId)
+        : flows.find((item) => item.sourceComponentId === patch.sourceComponentId &&
+            item.targetComponentId === patch.targetComponentId);
+    if (!flow) {
+        if (!patch.insertIfMissing)
+            return false;
+        if (!patch.sourceComponentId || !patch.targetComponentId)
+            return false;
+        const inserted = {
+            id: `flow_ai_${patch.sourceComponentId}_${patch.targetComponentId}_${flows.length + 1}`,
+            sourceComponentId: patch.sourceComponentId,
+            targetComponentId: patch.targetComponentId,
+            type: patch.setType ?? "api_call",
+            description: patch.setDescription,
+            confidence: patch.confidence.score,
+            method: patch.setMethod,
+            endpoint: patch.setEndpoint,
+            sourceLocations: patch.evidence.map((e) => ({
+                filePath: e.filePath,
+                startLine: e.startLine,
+                endLine: e.endLine,
+            })),
+        };
+        flows.push(inserted);
+        return true;
+    }
+    if (patch.setType)
+        flow.type = patch.setType;
+    if (patch.setMethod)
+        flow.method = patch.setMethod;
+    if (patch.setEndpoint)
+        flow.endpoint = patch.setEndpoint;
+    if (patch.setDescription)
+        flow.description = patch.setDescription;
+    flow.confidence = Math.max(flow.confidence, patch.confidence.score);
+    return true;
+}
+function mergeAiProposals(components, dataFlows, proposals, thresholds = {}, options = {}) {
+    const mergedThresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+    const nextComponents = components.map((component) => ({
+        ...component,
+        properties: { ...component.properties },
+    }));
+    const nextFlows = dataFlows.map((flow) => ({ ...flow }));
+    const appliedProposalIds = [];
+    const rejectedProposalIds = [];
+    const provenanceByTarget = {};
+    const componentIds = new Set(nextComponents.map((c) => c.id));
+    const aliasMap = buildComponentAliasMap(nextComponents);
+    const componentsById = new Map(nextComponents.map((c) => [c.id, c]));
+    for (const { id, proposal } of sortedProposals(proposals)) {
+        const resolvedProposal = proposal.kind === "component_patch"
+            ? remapComponentPatchTarget(proposal, componentIds, aliasMap)
+            : proposal;
+        if (options.preserveDataFlowTopology && proposal.kind === "flow_patch") {
+            rejectedProposalIds.push({
+                proposalId: id,
+                reason: "data_flow_topology_preserved",
+            });
+            continue;
+        }
+        if (options.enforceIntraSectionFlowChangesOnly &&
+            resolvedProposal.kind === "flow_patch" &&
+            !isIntraSectionFlowPatch(resolvedProposal, componentsById, nextFlows)) {
+            rejectedProposalIds.push({
+                proposalId: id,
+                reason: "cross_section_flow_change_blocked",
+            });
+            continue;
+        }
+        const minConfidence = resolvedProposal.kind === "component_patch"
+            ? mergedThresholds.minComponentPatchConfidence
+            : resolvedProposal.insertIfMissing
+                ? mergedThresholds.minInsertFlowConfidence
+                : mergedThresholds.minFlowPatchConfidence;
+        if (resolvedProposal.confidence.score < minConfidence) {
+            rejectedProposalIds.push({
+                proposalId: id,
+                reason: `confidence_below_threshold:${minConfidence}`,
+            });
+            continue;
+        }
+        if (resolvedProposal.evidence.length === 0) {
+            rejectedProposalIds.push({ proposalId: id, reason: "missing_evidence" });
+            continue;
+        }
+        const targetKey = proposalTargetKey(resolvedProposal);
+        if (provenanceByTarget[targetKey]) {
+            rejectedProposalIds.push({
+                proposalId: id,
+                reason: "target_already_modified_by_higher_ranked_proposal",
+            });
+            continue;
+        }
+        const merged = resolvedProposal.kind === "component_patch"
+            ? mergeComponentPatch(nextComponents, resolvedProposal)
+            : mergeFlowPatch(nextFlows, resolvedProposal);
+        if (!merged) {
+            rejectedProposalIds.push({
+                proposalId: id,
+                reason: resolvedProposal.kind === "component_patch"
+                    ? "no_meaningful_changes"
+                    : "target_not_found",
+            });
+            continue;
+        }
+        appliedProposalIds.push(id);
+        provenanceByTarget[targetKey] = toProvenance(resolvedProposal, resolvedProposal.confidence.score);
+    }
+    (0, sorting_1.sortDataFlowsDeterministically)(nextFlows);
+    return {
+        components: nextComponents,
+        dataFlows: nextFlows,
+        appliedProposalIds,
+        rejectedProposalIds,
+        provenanceByTarget,
+    };
+}

package/dist/src/ai-enrichment/non-pii-signal-rules.d.ts

@@ -0,0 +1,10 @@
+export interface NonPiiSignalRule {
+    id: string;
+    category: "auth_artifacts" | "usage_metadata" | "telemetry" | "content_files" | "identifiers";
+    labels: string[];
+    patterns: RegExp[];
+    capabilities: string[];
+    directionHint?: "outbound_to_third_party" | "inbound_from_third_party";
+}
+export declare function clearNonPiiSignalRulesCacheForTest(): void;
+export declare function loadNonPiiSignalRules(): NonPiiSignalRule[];

package/dist/src/ai-enrichment/non-pii-signal-rules.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearNonPiiSignalRulesCacheForTest = clearNonPiiSignalRulesCacheForTest;
+exports.loadNonPiiSignalRules = loadNonPiiSignalRules;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const zod_1 = require("zod");
+const nonPiiSignalRuleSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    category: zod_1.z.enum(["auth_artifacts", "usage_metadata", "telemetry", "content_files", "identifiers"]),
+    labels: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    patterns: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    capabilities: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    directionHint: zod_1.z.enum(["outbound_to_third_party", "inbound_from_third_party"]).optional(),
+});
+const nonPiiSignalCatalogSchema = zod_1.z.object({
+    non_pii_signal_rules: zod_1.z.array(nonPiiSignalRuleSchema).default([]),
+});
+let cachedRules;
+function clearNonPiiSignalRulesCacheForTest() {
+    cachedRules = undefined;
+}
+function getNonPiiSignalRulesPath() {
+    const parts = __dirname.split(path_1.default.sep);
+    const distIndex = parts.lastIndexOf("dist");
+    const cliRoot = distIndex !== -1
+        ? parts.slice(0, distIndex).join(path_1.default.sep)
+        : path_1.default.resolve(__dirname, "..", "..");
+    return path_1.default.join(cliRoot, "patterns", "non-pii-signals.rules.yaml");
+}
+function loadNonPiiSignalRules() {
+    if (cachedRules)
+        return cachedRules;
+    const configPath = getNonPiiSignalRulesPath();
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(configPath, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Non-PII signal rules are required but could not be read from '${configPath}': ${message}`);
+    }
+    let parsed;
+    try {
+        parsed = yaml_1.default.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Non-PII signal rules at '${configPath}' could not be parsed as YAML: ${message}`);
+    }
+    let normalized;
+    try {
+        normalized = nonPiiSignalCatalogSchema.parse(parsed);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Non-PII signal rules at '${configPath}' failed schema validation: ${message}`);
+    }
+    cachedRules = normalized.non_pii_signal_rules.map((rule) => ({
+        id: rule.id.trim().toLowerCase(),
+        category: rule.category,
+        labels: rule.labels.map((label) => label.trim()).filter(Boolean),
+        patterns: rule.patterns.map((pattern) => new RegExp(pattern, "i")),
+        capabilities: rule.capabilities.map((cap) => cap.trim().toLowerCase()).filter(Boolean),
+        directionHint: rule.directionHint,
+    }));
+    return cachedRules;
+}

package/dist/src/ai-enrichment/openai-proposals-response.schema.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Zod schema for OpenAI Chat Completions structured outputs (`response_format.type: json_schema`).
+ * Kept in sync with {@link normalizeProposal} shapes in `provider-contract.ts`.
+ */
+import { z } from "zod";
+export declare const openAiProposalsResponseSchema: z.ZodObject<{
+    proposals: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"component_patch">;
+        targetComponentId: z.ZodString;
+        candidateType: z.ZodEnum<{
+            third_party: "third_party";
+            node_property: "node_property";
+            flow_direction: "flow_direction";
+            missing_interaction: "missing_interaction";
+        }>;
+        setSubType: z.ZodOptional<z.ZodString>;
+        setDescription: z.ZodOptional<z.ZodString>;
+        setProperties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        propertyEvidence: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            reason: z.ZodString;
+        }, z.core.$strip>>>;
+        confidence: z.ZodObject<{
+            score: z.ZodNumber;
+            band: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+        }, z.core.$strip>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            reason: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"flow_patch">;
+        candidateType: z.ZodEnum<{
+            third_party: "third_party";
+            node_property: "node_property";
+            flow_direction: "flow_direction";
+            missing_interaction: "missing_interaction";
+        }>;
+        targetFlowId: z.ZodOptional<z.ZodString>;
+        insertIfMissing: z.ZodOptional<z.ZodBoolean>;
+        sourceComponentId: z.ZodOptional<z.ZodString>;
+        targetComponentId: z.ZodOptional<z.ZodString>;
+        setType: z.ZodOptional<z.ZodEnum<{
+            api_call: "api_call";
+            database_query: "database_query";
+            message_queue: "message_queue";
+            file_transfer: "file_transfer";
+            webhook: "webhook";
+            rpc: "rpc";
+        }>>;
+        setDirection: z.ZodOptional<z.ZodEnum<{
+            reverse: "reverse";
+            forward: "forward";
+        }>>;
+        setMethod: z.ZodOptional<z.ZodString>;
+        setEndpoint: z.ZodOptional<z.ZodString>;
+        setDescription: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodObject<{
+            score: z.ZodNumber;
+            band: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+        }, z.core.$strip>;
+        evidence: z.ZodArray<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type OpenAiProposalsResponse = z.infer<typeof openAiProposalsResponseSchema>;
+/**
+ * JSON Schema for `response_format.json_schema`, with `$schema` removed for broader API compatibility.
+ * Use `strict: false` so Zod optional fields (OpenAI: non–all-required) remain valid.
+ */
+export declare function getOpenAiProposalsResponseJsonSchemaForApi(options?: {
+    /** OpenAI `json_schema.strict`; requires every object to list all keys — keep false with Zod optionals. */
+    strict?: boolean;
+}): {
+    name: string;
+    strict: boolean;
+    schema: Record<string, unknown>;
+};

package/dist/src/ai-enrichment/openai-proposals-response.schema.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAiProposalsResponseSchema = void 0;
+exports.getOpenAiProposalsResponseJsonSchemaForApi = getOpenAiProposalsResponseJsonSchemaForApi;
+/**
+ * Zod schema for OpenAI Chat Completions structured outputs (`response_format.type: json_schema`).
+ * Kept in sync with {@link normalizeProposal} shapes in `provider-contract.ts`.
+ */
+const zod_1 = require("zod");
+const aiCandidateTypeSchema = zod_1.z.enum([
+    "third_party",
+    "node_property",
+    "flow_direction",
+    "missing_interaction",
+]);
+const evidenceSchema = zod_1.z.object({
+    filePath: zod_1.z.string().describe("Path from scan payload (detectedFrom / sourceLocations)."),
+    startLine: zod_1.z.number(),
+    endLine: zod_1.z.number(),
+    reason: zod_1.z.string(),
+});
+const confidenceSchema = zod_1.z.object({
+    score: zod_1.z.number().min(0).max(1),
+    band: zod_1.z.enum(["high", "medium", "low"]),
+});
+/** Property bag: snake_case keys; values as returned by the model (strings, bools, numbers, arrays, null). */
+const setPropertiesSchema = zod_1.z
+    .record(zod_1.z.string(), zod_1.z.unknown())
+    .describe("setProperties: snake_case keys from sparsePropertyKeys; arrays for multi-value fields.");
+const propertyEvidenceSchema = zod_1.z
+    .record(zod_1.z.string(), zod_1.z.array(evidenceSchema))
+    .describe("Map each setProperties key you output to a non-empty array of evidence rows (filePath, line range, reason).");
+const componentPatchSchema = zod_1.z.object({
+    kind: zod_1.z.literal("component_patch"),
+    targetComponentId: zod_1.z.string(),
+    candidateType: aiCandidateTypeSchema,
+    setSubType: zod_1.z.string().optional(),
+    setDescription: zod_1.z.string().optional(),
+    setProperties: setPropertiesSchema,
+    propertyEvidence: propertyEvidenceSchema,
+    confidence: confidenceSchema,
+    evidence: zod_1.z.array(evidenceSchema).optional(),
+});
+const dataFlowTypeSchema = zod_1.z.enum([
+    "api_call",
+    "database_query",
+    "message_queue",
+    "file_transfer",
+    "webhook",
+    "rpc",
+]);
+const flowPatchSchema = zod_1.z.object({
+    kind: zod_1.z.literal("flow_patch"),
+    candidateType: aiCandidateTypeSchema,
+    targetFlowId: zod_1.z.string().optional(),
+    insertIfMissing: zod_1.z.boolean().optional(),
+    sourceComponentId: zod_1.z.string().optional(),
+    targetComponentId: zod_1.z.string().optional(),
+    setType: dataFlowTypeSchema.optional(),
+    setDirection: zod_1.z.enum(["forward", "reverse"]).optional(),
+    setMethod: zod_1.z.string().optional(),
+    setEndpoint: zod_1.z.string().optional(),
+    setDescription: zod_1.z.string().optional(),
+    confidence: confidenceSchema,
+    evidence: zod_1.z.array(evidenceSchema),
+});
+exports.openAiProposalsResponseSchema = zod_1.z.object({
+    proposals: zod_1.z.array(zod_1.z.discriminatedUnion("kind", [componentPatchSchema, flowPatchSchema])),
+});
+/**
+ * JSON Schema for `response_format.json_schema`, with `$schema` removed for broader API compatibility.
+ * Use `strict: false` so Zod optional fields (OpenAI: non–all-required) remain valid.
+ */
+function getOpenAiProposalsResponseJsonSchemaForApi(options) {
+    const raw = zod_1.z.toJSONSchema(exports.openAiProposalsResponseSchema);
+    delete raw.$schema;
+    return {
+        name: "dataparade_proposals",
+        strict: options?.strict ?? false,
+        schema: raw,
+    };
+}

package/dist/src/ai-enrichment/pii-signal-rules.d.ts

@@ -0,0 +1,8 @@
+export interface PiiSignalRule {
+    id: string;
+    category: "identifiers" | "profile_data" | "credentials";
+    labels: string[];
+    patterns: RegExp[];
+}
+export declare function clearPiiSignalRulesCacheForTest(): void;
+export declare function loadPiiSignalRules(): PiiSignalRule[];