@dataparade/cli 0.0.1

package/dist/src/core/schema/dataflow-wrapper.schema.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const dataflowMetadataSchema: z.ZodObject<{
+    componentsCount: z.ZodOptional<z.ZodNumber>;
+    dataFlowsCount: z.ZodOptional<z.ZodNumber>;
+    filesScanned: z.ZodOptional<z.ZodNumber>;
+    scanDurationMs: z.ZodOptional<z.ZodNumber>;
+    terraform: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            static_tf: "static_tf";
+            json_overlay: "json_overlay";
+            json_only: "json_only";
+        }>;
+        staticTfFiles: z.ZodNumber;
+        jsonInputPath: z.ZodOptional<z.ZodString>;
+        jsonFindingsMerged: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$loose>;
+export declare const dataflowWrapperSchema: z.ZodObject<{
+    schemaVersion: z.ZodString;
+    graph: z.ZodObject<{
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+            data: z.ZodObject<{
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                privacy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                security: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                engineering: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$catchall<z.ZodUnknown>>;
+            selected: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodString;
+            target: z.ZodString;
+            type: z.ZodOptional<z.ZodString>;
+            data: z.ZodOptional<z.ZodObject<{
+                label: z.ZodOptional<z.ZodString>;
+                privacy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                security: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                narrative: z.ZodOptional<z.ZodString>;
+                properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+            selected: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        viewport: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            zoom: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        componentsCount: z.ZodOptional<z.ZodNumber>;
+        dataFlowsCount: z.ZodOptional<z.ZodNumber>;
+        filesScanned: z.ZodOptional<z.ZodNumber>;
+        scanDurationMs: z.ZodOptional<z.ZodNumber>;
+        terraform: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                static_tf: "static_tf";
+                json_overlay: "json_overlay";
+                json_only: "json_only";
+            }>;
+            staticTfFiles: z.ZodNumber;
+            jsonInputPath: z.ZodOptional<z.ZodString>;
+            jsonFindingsMerged: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export type DataflowMetadataSchema = z.infer<typeof dataflowMetadataSchema>;
+export type DataflowWrapperSchema = z.infer<typeof dataflowWrapperSchema>;
+export declare function parseDataflowJson(input: unknown): DataflowWrapperSchema;
+export declare function validateDataflowJson(input: unknown): {
+    ok: true;
+    value: DataflowWrapperSchema;
+} | {
+    ok: false;
+    errors: string[];
+};

package/dist/src/core/schema/dataflow-wrapper.schema.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataflowWrapperSchema = exports.dataflowMetadataSchema = void 0;
+exports.parseDataflowJson = parseDataflowJson;
+exports.validateDataflowJson = validateDataflowJson;
+const zod_1 = require("zod");
+const diagram_graph_schema_1 = require("./diagram-graph.schema");
+const terraformMetadataSchema = zod_1.z
+    .object({
+    mode: zod_1.z.enum(["static_tf", "json_overlay", "json_only"]),
+    staticTfFiles: zod_1.z.number().int().nonnegative(),
+    jsonInputPath: zod_1.z.string().optional(),
+    jsonFindingsMerged: zod_1.z.number().int().nonnegative(),
+})
+    .strict();
+exports.dataflowMetadataSchema = zod_1.z
+    .object({
+    componentsCount: zod_1.z.number().int().nonnegative().optional(),
+    dataFlowsCount: zod_1.z.number().int().nonnegative().optional(),
+    filesScanned: zod_1.z.number().int().nonnegative().optional(),
+    scanDurationMs: zod_1.z.number().int().nonnegative().optional(),
+    terraform: terraformMetadataSchema.optional(),
+})
+    .passthrough();
+exports.dataflowWrapperSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.string().min(1),
+    graph: diagram_graph_schema_1.diagramGraphJsonSchema,
+    metadata: exports.dataflowMetadataSchema.optional(),
+});
+function parseDataflowJson(input) {
+    return exports.dataflowWrapperSchema.parse(input);
+}
+function validateDataflowJson(input) {
+    const result = exports.dataflowWrapperSchema.safeParse(input);
+    if (!result.success) {
+        const errors = result.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`);
+        return { ok: false, errors };
+    }
+    return { ok: true, value: result.data };
+}

package/dist/src/core/schema/diagram-graph.schema.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+export declare const viewportSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    zoom: z.ZodNumber;
+}, z.core.$strip>;
+export declare const nodeDataSchema: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    privacy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    security: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    engineering: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const diagramNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    data: z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        privacy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        security: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        engineering: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    selected: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const edgeDataSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    privacy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    security: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    narrative: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const diagramEdgeSchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        privacy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        security: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        narrative: z.ZodOptional<z.ZodString>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    selected: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const diagramGraphJsonSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            privacy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            security: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            engineering: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+        selected: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        target: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            privacy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            security: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            narrative: z.ZodOptional<z.ZodString>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        selected: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    viewport: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        zoom: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ViewportSchema = z.infer<typeof viewportSchema>;
+export type NodeDataSchema = z.infer<typeof nodeDataSchema>;
+export type DiagramNodeSchema = z.infer<typeof diagramNodeSchema>;
+export type EdgeDataSchema = z.infer<typeof edgeDataSchema>;
+export type DiagramEdgeSchema = z.infer<typeof diagramEdgeSchema>;
+export type DiagramGraphJsonSchema = z.infer<typeof diagramGraphJsonSchema>;

package/dist/src/core/schema/diagram-graph.schema.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagramGraphJsonSchema = exports.diagramEdgeSchema = exports.edgeDataSchema = exports.diagramNodeSchema = exports.nodeDataSchema = exports.viewportSchema = void 0;
+const zod_1 = require("zod");
+exports.viewportSchema = zod_1.z.object({
+    x: zod_1.z.number(),
+    y: zod_1.z.number(),
+    zoom: zod_1.z.number().min(0.1).max(4),
+});
+exports.nodeDataSchema = zod_1.z
+    .object({
+    label: zod_1.z.string().min(1).max(255),
+    description: zod_1.z.string().optional(),
+    // Privacy / security / engineering are kept flexible to avoid tight coupling.
+    privacy: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    security: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    engineering: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+})
+    .catchall(zod_1.z.unknown());
+exports.diagramNodeSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().min(1),
+    type: zod_1.z.string().min(1),
+    position: zod_1.z.object({
+        x: zod_1.z.number(),
+        y: zod_1.z.number(),
+    }),
+    data: exports.nodeDataSchema,
+    selected: zod_1.z.boolean().optional(),
+})
+    .catchall(zod_1.z.unknown());
+exports.edgeDataSchema = zod_1.z
+    .object({
+    label: zod_1.z.string().optional(),
+    privacy: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    security: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    narrative: zod_1.z.string().optional(),
+    properties: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+})
+    .catchall(zod_1.z.unknown());
+exports.diagramEdgeSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().min(1),
+    source: zod_1.z.string().min(1),
+    target: zod_1.z.string().min(1),
+    type: zod_1.z.string().optional(),
+    data: exports.edgeDataSchema.optional(),
+    selected: zod_1.z.boolean().optional(),
+})
+    .catchall(zod_1.z.unknown());
+exports.diagramGraphJsonSchema = zod_1.z.object({
+    nodes: zod_1.z.array(exports.diagramNodeSchema),
+    edges: zod_1.z.array(exports.diagramEdgeSchema),
+    viewport: exports.viewportSchema.optional(),
+});

package/dist/src/core/schema/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./scan-config.schema";
+export * from "./scan-result.schema";
+export * from "./diagram-graph.schema";
+export * from "./dataflow-wrapper.schema";

package/dist/src/core/schema/index.js

@@ -0,0 +1,20 @@
+"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("./scan-config.schema"), exports);
+__exportStar(require("./scan-result.schema"), exports);
+__exportStar(require("./diagram-graph.schema"), exports);
+__exportStar(require("./dataflow-wrapper.schema"), exports);

package/dist/src/core/schema/scan-config.schema.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import type { ScanConfiguration } from "../types";
+export declare const scanConfigurationSchema: z.ZodObject<{
+    projectName: z.ZodOptional<z.ZodString>;
+    excludePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enableAPIDetection: z.ZodBoolean;
+    enableDatabaseDetection: z.ZodBoolean;
+    enableDataFlowDetection: z.ZodBoolean;
+    languages: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        typescript: "typescript";
+        javascript: "javascript";
+        json: "json";
+        yaml: "yaml";
+        env: "env";
+        python: "python";
+        terraform: "terraform";
+        dockerfile: "dockerfile";
+    }>>>;
+    minimumConfidence: z.ZodNumber;
+    deepAnalysis: z.ZodOptional<z.ZodBoolean>;
+    terraformJsonPath: z.ZodOptional<z.ZodString>;
+    terraformPlanPath: z.ZodOptional<z.ZodString>;
+    terraformStackSectionPathDepth: z.ZodOptional<z.ZodNumber>;
+    autoInferTerraformStackSectionPathDepth: z.ZodOptional<z.ZodBoolean>;
+    monorepoPackageSectionPathDepth: z.ZodOptional<z.ZodNumber>;
+    autoInferMonorepoPackageSectionPathDepth: z.ZodOptional<z.ZodBoolean>;
+    enableAiInference: z.ZodOptional<z.ZodBoolean>;
+    aiProvider: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        openai: "openai";
+        anthropic: "anthropic";
+        gemini: "gemini";
+        openrouter: "openrouter";
+        mock: "mock";
+    }>>;
+    aiModel: z.ZodOptional<z.ZodString>;
+    aiEndpoint: z.ZodOptional<z.ZodString>;
+    aiApiKey: z.ZodOptional<z.ZodString>;
+    aiTemperature: z.ZodOptional<z.ZodNumber>;
+    aiMaxTokens: z.ZodOptional<z.ZodNumber>;
+    aiMaxModelCalls: z.ZodOptional<z.ZodNumber>;
+    aiBudgetTokens: z.ZodOptional<z.ZodNumber>;
+    aiProviderConcurrency: z.ZodOptional<z.ZodNumber>;
+    aiMaxCandidatesPerAgent: z.ZodOptional<z.ZodNumber>;
+    aiInferenceScope: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        third_party_only: "third_party_only";
+    }>>;
+    aiVerbose: z.ZodOptional<z.ZodBoolean>;
+    workspaceApiKey: z.ZodOptional<z.ZodString>;
+    aiMode: z.ZodOptional<z.ZodEnum<{
+        byok: "byok";
+        platform: "platform";
+        none: "none";
+    }>>;
+    platformApiBaseUrl: z.ZodOptional<z.ZodString>;
+    cliQuotaJobId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function parseScanConfiguration(input: unknown): ScanConfiguration;
+export declare function validateScanConfiguration(input: unknown): {
+    ok: true;
+    value: ScanConfiguration;
+} | {
+    ok: false;
+    errors: string[];
+};

package/dist/src/core/schema/scan-config.schema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanConfigurationSchema = void 0;
+exports.parseScanConfiguration = parseScanConfiguration;
+exports.validateScanConfiguration = validateScanConfiguration;
+const zod_1 = require("zod");
+const types_1 = require("../../ai-enrichment/types");
+const validate_scan_ai_1 = require("../../config/validate-scan-ai");
+const fileLanguageEnum = zod_1.z.enum([
+    "typescript",
+    "javascript",
+    "json",
+    "yaml",
+    "env",
+    "python",
+    "terraform",
+    "dockerfile",
+]);
+exports.scanConfigurationSchema = zod_1.z.object({
+    projectName: zod_1.z.string().min(1).max(255).optional(),
+    excludePaths: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+    enableAPIDetection: zod_1.z.boolean(),
+    enableDatabaseDetection: zod_1.z.boolean(),
+    enableDataFlowDetection: zod_1.z.boolean(),
+    languages: zod_1.z.array(fileLanguageEnum).optional(),
+    minimumConfidence: zod_1.z.number().min(0).max(1),
+    deepAnalysis: zod_1.z.boolean().optional(),
+    terraformJsonPath: zod_1.z.string().min(1).optional(),
+    terraformPlanPath: zod_1.z.string().min(1).optional(),
+    terraformStackSectionPathDepth: zod_1.z.number().int().positive().optional(),
+    autoInferTerraformStackSectionPathDepth: zod_1.z.boolean().optional(),
+    monorepoPackageSectionPathDepth: zod_1.z.number().int().positive().optional(),
+    autoInferMonorepoPackageSectionPathDepth: zod_1.z.boolean().optional(),
+    enableAiInference: zod_1.z.boolean().optional(),
+    aiProvider: zod_1.z.enum(types_1.AI_PROVIDER_IDS).optional(),
+    aiModel: zod_1.z.string().min(1).optional(),
+    aiEndpoint: zod_1.z.string().min(1).optional(),
+    aiApiKey: zod_1.z.string().min(1).optional(),
+    aiTemperature: zod_1.z.number().min(0).max(2).optional(),
+    aiMaxTokens: zod_1.z.number().int().positive().optional(),
+    aiMaxModelCalls: zod_1.z.number().int().positive().optional(),
+    aiBudgetTokens: zod_1.z.number().int().positive().optional(),
+    aiProviderConcurrency: zod_1.z.number().int().positive().optional(),
+    aiMaxCandidatesPerAgent: zod_1.z.number().int().min(0).optional(),
+    aiInferenceScope: zod_1.z.enum(["default", "third_party_only"]).optional(),
+    aiVerbose: zod_1.z.boolean().optional(),
+    workspaceApiKey: zod_1.z.string().min(1).optional(),
+    aiMode: zod_1.z.enum(["byok", "platform", "none"]).optional(),
+    platformApiBaseUrl: zod_1.z.string().min(1).optional(),
+    cliQuotaJobId: zod_1.z.string().min(1).optional(),
+});
+function parseScanConfiguration(input) {
+    return exports.scanConfigurationSchema.parse(input);
+}
+function validateScanConfiguration(input) {
+    const result = exports.scanConfigurationSchema.safeParse(input);
+    if (!result.success) {
+        const errors = result.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`);
+        return { ok: false, errors };
+    }
+    const value = result.data;
+    const aiErrors = (0, validate_scan_ai_1.validateAiInferenceCredentials)(value);
+    if (aiErrors.length > 0) {
+        return { ok: false, errors: aiErrors };
+    }
+    return { ok: true, value };
+}