@collage-dam/mcp-server 0.1.0

package/dist/tools/audit/types.d.ts

@@ -0,0 +1,526 @@
+import { z } from 'zod';
+/**
+ * Audit score. Always 0–100 inclusive, integer, deterministic.
+ *
+ * Each audit MUST document its scoring formula in code comments. A score
+ * of 100 means "no findings"; lower scores reflect penalties summed across
+ * findings, weighted by severity. Scores are clamped at 0 — they never go
+ * negative even if penalties exceed 100.
+ */
+export declare const AuditScoreSchema: z.ZodNumber;
+export type AuditScore = z.infer<typeof AuditScoreSchema>;
+export declare const AuditSeveritySchema: z.ZodEnum<["info", "warning", "critical"]>;
+export type AuditSeverity = z.infer<typeof AuditSeveritySchema>;
+/**
+ * A single structured finding.
+ *
+ *   id                 — stable identifier within this report; used by
+ *                        downstream code to correlate next-step hints
+ *                        back to the finding that produced them.
+ *   category           — bucket name (e.g. `untagged_assets`,
+ *                        `inconsistent_casing`). Stable across runs so
+ *                        clients can group / dedupe across reports.
+ *   severity           — `info` | `warning` | `critical`. Drives both UI
+ *                        styling and score penalty weight.
+ *   count              — total number of items in this category. Always
+ *                        equals the *underlying* count, even if
+ *                        `sample_asset_ids` is truncated.
+ *   sample_asset_ids   — bounded sample (caller decides bound; default
+ *                        suggestion is 10) of asset IDs for spot-checks.
+ *   message            — human-readable summary. Treat as display copy,
+ *                        not data — never parse it.
+ */
+export declare function auditFindingSchema<TMeta extends z.ZodTypeAny>(metaSchema: TMeta): z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "critical"]>;
+    count: z.ZodNumber;
+    sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+    message: z.ZodString;
+    meta: z.ZodOptional<TMeta>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    id: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "critical"]>;
+    count: z.ZodNumber;
+    sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+    message: z.ZodString;
+    meta: z.ZodOptional<TMeta>;
+}>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+    id: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "critical"]>;
+    count: z.ZodNumber;
+    sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+    message: z.ZodString;
+    meta: z.ZodOptional<TMeta>;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+export declare const BaseAuditFindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "critical"]>;
+    count: z.ZodNumber;
+    sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+    message: z.ZodString;
+    meta: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    id: string;
+    category: string;
+    severity: "info" | "warning" | "critical";
+    count: number;
+    sample_asset_ids: string[];
+    meta?: unknown;
+}, {
+    message: string;
+    id: string;
+    category: string;
+    severity: "info" | "warning" | "critical";
+    count: number;
+    sample_asset_ids: string[];
+    meta?: unknown;
+}>;
+export type AuditFinding<TMeta = unknown> = {
+    id: string;
+    category: string;
+    severity: AuditSeverity;
+    count: number;
+    sample_asset_ids: string[];
+    message: string;
+    meta?: TMeta;
+};
+/**
+ * Structured next-step hint pointing at an existing mutating tool.
+ *
+ * Phase 1 only emits `add_tags` / `remove_tags` / `set_tags` actions and
+ * targets `bulk_add_tags` / `bulk_remove_tags` / `bulk_set_tags`. The
+ * `action` enum is intentionally extensible — Phase 1.5 will add
+ * `rename_assets`, `move_assets`, `normalize_filenames` without breaking
+ * the schema (additive only).
+ *
+ * The shape carries the exact argument set the caller would pass to the
+ * mutating tool, so a router can dispatch directly without re-interpreting
+ * the finding.
+ */
+export declare const AuditNextStepActionSchema: z.ZodEnum<["add_tags", "remove_tags", "set_tags"]>;
+export type AuditNextStepAction = z.infer<typeof AuditNextStepActionSchema>;
+export declare const AuditNextStepSchema: z.ZodObject<{
+    action: z.ZodEnum<["add_tags", "remove_tags", "set_tags"]>;
+    /**
+     * Name of the mutating tool that should be invoked to apply this hint.
+     * Stored as a string (not enum) so Phase 1.5 can introduce new tools
+     * without bumping the schema major version.
+     */
+    tool: z.ZodString;
+    /** Asset IDs the caller should target. Always a non-empty list. */
+    target_asset_ids: z.ZodArray<z.ZodString, "many">;
+    /** Tags to add / remove / set, when `action` is tag-related. */
+    suggested_tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Short rationale linking the hint back to its originating finding. */
+    reason: z.ZodString;
+    /** ID of the finding this hint addresses (optional but encouraged). */
+    finding_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    tool: string;
+    reason: string;
+    action: "add_tags" | "remove_tags" | "set_tags";
+    target_asset_ids: string[];
+    suggested_tags?: string[] | undefined;
+    finding_id?: string | undefined;
+}, {
+    tool: string;
+    reason: string;
+    action: "add_tags" | "remove_tags" | "set_tags";
+    target_asset_ids: string[];
+    suggested_tags?: string[] | undefined;
+    finding_id?: string | undefined;
+}>;
+export type AuditNextStep = z.infer<typeof AuditNextStepSchema>;
+export declare const AuditSummaryCountsSchema: z.ZodObject<{
+    total_assets_scanned: z.ZodNumber;
+    total_findings: z.ZodNumber;
+    by_severity: z.ZodObject<{
+        info: z.ZodNumber;
+        warning: z.ZodNumber;
+        critical: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        info: number;
+        warning: number;
+        critical: number;
+    }, {
+        info: number;
+        warning: number;
+        critical: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    total_assets_scanned: number;
+    total_findings: number;
+    by_severity: {
+        info: number;
+        warning: number;
+        critical: number;
+    };
+}, {
+    total_assets_scanned: number;
+    total_findings: number;
+    by_severity: {
+        info: number;
+        warning: number;
+        critical: number;
+    };
+}>;
+export type AuditSummaryCounts = z.infer<typeof AuditSummaryCountsSchema>;
+/**
+ * Top-level envelope returned by every audit tool.
+ *
+ *   score              — 0–100 (see {@link AuditScoreSchema})
+ *   summary_counts     — quick-glance roll-up
+ *   findings           — every detected issue, structured
+ *   next_steps         — structured fix suggestions pointing at existing
+ *                        mutating tools
+ *   truncated          — true when findings or next_steps were trimmed to
+ *                        stay under the response budget. When true, the
+ *                        report is *partial* and the caller should re-run
+ *                        with a tighter scope or paginated input.
+ *   truncation_reason  — populated when `truncated` is true.
+ */
+export declare function auditReportSchema<TMeta extends z.ZodTypeAny>(metaSchema: TMeta): z.ZodObject<{
+    score: z.ZodNumber;
+    summary_counts: z.ZodObject<{
+        total_assets_scanned: z.ZodNumber;
+        total_findings: z.ZodNumber;
+        by_severity: z.ZodObject<{
+            info: z.ZodNumber;
+            warning: z.ZodNumber;
+            critical: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            info: number;
+            warning: number;
+            critical: number;
+        }, {
+            info: number;
+            warning: number;
+            critical: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        total_assets_scanned: number;
+        total_findings: number;
+        by_severity: {
+            info: number;
+            warning: number;
+            critical: number;
+        };
+    }, {
+        total_assets_scanned: number;
+        total_findings: number;
+        by_severity: {
+            info: number;
+            warning: number;
+            critical: number;
+        };
+    }>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+        count: z.ZodNumber;
+        sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+        message: z.ZodString;
+        meta: z.ZodOptional<TMeta>;
+    }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+        id: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+        count: z.ZodNumber;
+        sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+        message: z.ZodString;
+        meta: z.ZodOptional<TMeta>;
+    }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+        id: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+        count: z.ZodNumber;
+        sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+        message: z.ZodString;
+        meta: z.ZodOptional<TMeta>;
+    }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>, "many">;
+    next_steps: z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<["add_tags", "remove_tags", "set_tags"]>;
+        /**
+         * Name of the mutating tool that should be invoked to apply this hint.
+         * Stored as a string (not enum) so Phase 1.5 can introduce new tools
+         * without bumping the schema major version.
+         */
+        tool: z.ZodString;
+        /** Asset IDs the caller should target. Always a non-empty list. */
+        target_asset_ids: z.ZodArray<z.ZodString, "many">;
+        /** Tags to add / remove / set, when `action` is tag-related. */
+        suggested_tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Short rationale linking the hint back to its originating finding. */
+        reason: z.ZodString;
+        /** ID of the finding this hint addresses (optional but encouraged). */
+        finding_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        reason: string;
+        action: "add_tags" | "remove_tags" | "set_tags";
+        target_asset_ids: string[];
+        suggested_tags?: string[] | undefined;
+        finding_id?: string | undefined;
+    }, {
+        tool: string;
+        reason: string;
+        action: "add_tags" | "remove_tags" | "set_tags";
+        target_asset_ids: string[];
+        suggested_tags?: string[] | undefined;
+        finding_id?: string | undefined;
+    }>, "many">;
+    truncated: z.ZodBoolean;
+    truncation_reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    truncated: boolean;
+    score: number;
+    summary_counts: {
+        total_assets_scanned: number;
+        total_findings: number;
+        by_severity: {
+            info: number;
+            warning: number;
+            critical: number;
+        };
+    };
+    findings: (z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+        id: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+        count: z.ZodNumber;
+        sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+        message: z.ZodString;
+        meta: z.ZodOptional<TMeta>;
+    }>, any> extends infer T_2 ? { [k in keyof T_2]: T_2[k]; } : never)[];
+    next_steps: {
+        tool: string;
+        reason: string;
+        action: "add_tags" | "remove_tags" | "set_tags";
+        target_asset_ids: string[];
+        suggested_tags?: string[] | undefined;
+        finding_id?: string | undefined;
+    }[];
+    truncation_reason?: string | undefined;
+}, {
+    truncated: boolean;
+    score: number;
+    summary_counts: {
+        total_assets_scanned: number;
+        total_findings: number;
+        by_severity: {
+            info: number;
+            warning: number;
+            critical: number;
+        };
+    };
+    findings: (z.baseObjectInputType<{
+        id: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+        count: z.ZodNumber;
+        sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+        message: z.ZodString;
+        meta: z.ZodOptional<TMeta>;
+    }> extends infer T_3 ? { [k_1 in keyof T_3]: T_3[k_1]; } : never)[];
+    next_steps: {
+        tool: string;
+        reason: string;
+        action: "add_tags" | "remove_tags" | "set_tags";
+        target_asset_ids: string[];
+        suggested_tags?: string[] | undefined;
+        finding_id?: string | undefined;
+    }[];
+    truncation_reason?: string | undefined;
+}>;
+export declare const BaseAuditReportSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    summary_counts: z.ZodObject<{
+        total_assets_scanned: z.ZodNumber;
+        total_findings: z.ZodNumber;
+        by_severity: z.ZodObject<{
+            info: z.ZodNumber;
+            warning: z.ZodNumber;
+            critical: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            info: number;
+            warning: number;
+            critical: number;
+        }, {
+            info: number;
+            warning: number;
+            critical: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        total_assets_scanned: number;
+        total_findings: number;
+        by_severity: {
+            info: number;
+            warning: number;
+            critical: number;
+        };
+    }, {
+        total_assets_scanned: number;
+        total_findings: number;
+        by_severity: {
+            info: number;
+            warning: number;
+            critical: number;
+        };
+    }>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+        count: z.ZodNumber;
+        sample_asset_ids: z.ZodArray<z.ZodString, "many">;
+        message: z.ZodString;
+        meta: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        id: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        count: number;
+        sample_asset_ids: string[];
+        meta?: unknown;
+    }, {
+        message: string;
+        id: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        count: number;
+        sample_asset_ids: string[];
+        meta?: unknown;
+    }>, "many">;
+    next_steps: z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<["add_tags", "remove_tags", "set_tags"]>;
+        /**
+         * Name of the mutating tool that should be invoked to apply this hint.
+         * Stored as a string (not enum) so Phase 1.5 can introduce new tools
+         * without bumping the schema major version.
+         */
+        tool: z.ZodString;
+        /** Asset IDs the caller should target. Always a non-empty list. */
+        target_asset_ids: z.ZodArray<z.ZodString, "many">;
+        /** Tags to add / remove / set, when `action` is tag-related. */
+        suggested_tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Short rationale linking the hint back to its originating finding. */
+        reason: z.ZodString;
+        /** ID of the finding this hint addresses (optional but encouraged). */
+        finding_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        reason: string;
+        action: "add_tags" | "remove_tags" | "set_tags";
+        target_asset_ids: string[];
+        suggested_tags?: string[] | undefined;
+        finding_id?: string | undefined;
+    }, {
+        tool: string;
+        reason: string;
+        action: "add_tags" | "remove_tags" | "set_tags";
+        target_asset_ids: string[];
+        suggested_tags?: string[] | undefined;
+        finding_id?: string | undefined;
+    }>, "many">;
+    truncated: z.ZodBoolean;
+    truncation_reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    truncated: boolean;
+    score: number;
+    summary_counts: {
+        total_assets_scanned: number;
+        total_findings: number;
+        by_severity: {
+            info: number;
+            warning: number;
+            critical: number;
+        };
+    };
+    findings: {
+        message: string;
+        id: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        count: number;
+        sample_asset_ids: string[];
+        meta?: unknown;
+    }[];
+    next_steps: {
+        tool: string;
+        reason: string;
+        action: "add_tags" | "remove_tags" | "set_tags";
+        target_asset_ids: string[];
+        suggested_tags?: string[] | undefined;
+        finding_id?: string | undefined;
+    }[];
+    truncation_reason?: string | undefined;
+}, {
+    truncated: boolean;
+    score: number;
+    summary_counts: {
+        total_assets_scanned: number;
+        total_findings: number;
+        by_severity: {
+            info: number;
+            warning: number;
+            critical: number;
+        };
+    };
+    findings: {
+        message: string;
+        id: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        count: number;
+        sample_asset_ids: string[];
+        meta?: unknown;
+    }[];
+    next_steps: {
+        tool: string;
+        reason: string;
+        action: "add_tags" | "remove_tags" | "set_tags";
+        target_asset_ids: string[];
+        suggested_tags?: string[] | undefined;
+        finding_id?: string | undefined;
+    }[];
+    truncation_reason?: string | undefined;
+}>;
+export interface AuditReport<TFindingMeta = unknown> {
+    score: AuditScore;
+    summary_counts: AuditSummaryCounts;
+    findings: AuditFinding<TFindingMeta>[];
+    next_steps: AuditNextStep[];
+    truncated: boolean;
+    truncation_reason?: string;
+}
+/**
+ * Default penalty weights per severity level. Individual audits MAY override
+ * but the shared default keeps cross-audit scores comparable.
+ */
+export declare const DEFAULT_SEVERITY_WEIGHTS: Readonly<Record<AuditSeverity, number>>;
+/**
+ * Compute an `AuditScore` from a list of findings using the shared severity
+ * weight table (or a caller-supplied one). The score is `100 - sum(weights)`,
+ * clamped to `[0, 100]`. With no findings the score is 100.
+ *
+ * The formula is intentionally simple, deterministic, and easy to defend:
+ *   - one weight per finding (NOT per affected asset) — keeps a single
+ *     widespread issue from collapsing the score to 0
+ *   - severity drives the weight; counts surface in the finding itself
+ *   - clamped at 0; never negative
+ */
+export declare function computeAuditScore(findings: ReadonlyArray<{
+    severity: AuditSeverity;
+}>, weights?: Readonly<Record<AuditSeverity, number>>): AuditScore;
+/**
+ * Roll up findings into the summary-counts shape.
+ */
+export declare function summarizeFindings(findings: ReadonlyArray<AuditFinding<unknown>>, totalAssetsScanned: number): AuditSummaryCounts;
+//# sourceMappingURL=types.d.ts.map

package/dist/tools/audit/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tools/audit/types.ts"],"names":[],"mappings":"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"}