@mcoda/core 0.1.8 → 0.1.11

package/dist/services/docs/review/gates/SdsAdaptersGate.js

@@ -0,0 +1,196 @@
+import { promises as fs } from "node:fs";
+const isFenceLine = (line) => /^```|^~~~/.test(line.trim());
+const extractSection = (lines, headingMatch) => {
+    let inFence = false;
+    let capture = false;
+    let startLine = 0;
+    const collected = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const trimmed = line.trim();
+        if (isFenceLine(trimmed)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        const heading = trimmed.match(/^#{1,6}\s+(.*)$/);
+        if (heading) {
+            const title = heading[1]?.trim() ?? "";
+            if (headingMatch.test(title)) {
+                capture = true;
+                startLine = i + 1;
+                continue;
+            }
+            if (capture)
+                break;
+        }
+        if (capture && trimmed)
+            collected.push(trimmed);
+    }
+    if (!capture)
+        return undefined;
+    return { content: collected, line: startLine };
+};
+const containsAny = (lines, patterns) => lines.some((line) => patterns.some((pattern) => pattern.test(line)));
+const buildIssue = (input) => ({
+    id: input.id,
+    gateId: "gate-sds-external-adapters",
+    severity: "high",
+    category: "completeness",
+    artifact: "sds",
+    message: input.message,
+    remediation: input.remediation,
+    location: {
+        kind: "line_range",
+        path: input.record.path,
+        lineStart: input.line ?? 1,
+        lineEnd: input.line ?? 1,
+        excerpt: input.message,
+    },
+    metadata: input.metadata,
+});
+const EXTERNAL_SERVICE_PATTERNS = [
+    { name: "Brave", pattern: /\bBrave(?:\s+Search)?\b/i },
+    { name: "OpenRouter", pattern: /\bOpenRouter\b/i },
+    { name: "OpenAI", pattern: /\bOpenAI\b/i },
+    { name: "Anthropic", pattern: /\bAnthropic\b/i },
+    { name: "Cohere", pattern: /\bCohere\b/i },
+    { name: "Mistral", pattern: /\bMistral\b/i },
+    { name: "Stripe", pattern: /\bStripe\b/i },
+    { name: "Twilio", pattern: /\bTwilio\b/i },
+    { name: "SendGrid", pattern: /\bSendGrid\b/i },
+    { name: "Sentry", pattern: /\bSentry\b/i },
+    { name: "Datadog", pattern: /\bDatadog\b/i },
+    { name: "PostHog", pattern: /\bPostHog\b/i },
+    { name: "Algolia", pattern: /\bAlgolia\b/i },
+];
+const ADAPTER_SECTION = /adapter|integration|external|third[- ]?party|provider|vendor|connector|dependency|contract/i;
+const CONSTRAINT_PATTERNS = [
+    /rate limit/i,
+    /quota/i,
+    /sla/i,
+    /contract/i,
+    /auth/i,
+    /api key/i,
+    /token/i,
+    /timeout/i,
+    /latency/i,
+    /limit/i,
+    /pricing/i,
+];
+const ERROR_HANDLING_PATTERNS = [
+    /error/i,
+    /retry/i,
+    /backoff/i,
+    /circuit/i,
+    /failover/i,
+    /dead[- ]?letter/i,
+];
+const FALLBACK_PATTERNS = [/fallback/i, /degrade/i, /alternate/i, /secondary/i, /backup/i, /switch/i];
+export const runSdsAdaptersGate = async (input) => {
+    const sds = input.artifacts.sds;
+    if (!sds) {
+        return {
+            gateId: "gate-sds-external-adapters",
+            gateName: "SDS External Adapters",
+            status: "skipped",
+            issues: [],
+            notes: ["No SDS artifact available for external adapter validation."],
+        };
+    }
+    const issues = [];
+    const notes = [];
+    try {
+        const content = await fs.readFile(sds.path, "utf8");
+        const lines = content.split(/\r?\n/);
+        const references = new Map();
+        let inFence = false;
+        lines.forEach((line, index) => {
+            const trimmed = line.trim();
+            if (isFenceLine(trimmed)) {
+                inFence = !inFence;
+                return;
+            }
+            if (inFence)
+                return;
+            for (const entry of EXTERNAL_SERVICE_PATTERNS) {
+                if (entry.pattern.test(line)) {
+                    if (!references.has(entry.name)) {
+                        references.set(entry.name, index + 1);
+                    }
+                }
+            }
+        });
+        if (references.size === 0) {
+            return {
+                gateId: "gate-sds-external-adapters",
+                gateName: "SDS External Adapters",
+                status: "pass",
+                issues: [],
+                metadata: { issueCount: 0 },
+            };
+        }
+        const adapterSection = extractSection(lines, ADAPTER_SECTION);
+        if (!adapterSection) {
+            for (const [service, line] of references.entries()) {
+                issues.push(buildIssue({
+                    id: `gate-sds-external-adapters-missing-section-${service.toLowerCase()}`,
+                    message: `SDS references ${service} but lacks an external adapter section.`,
+                    remediation: `Add an External Integrations/Adapters section describing constraints, error handling, and fallback for ${service}.`,
+                    record: sds,
+                    line,
+                    metadata: { issueType: "missing_adapter_section", service },
+                }));
+            }
+        }
+        else {
+            const adapterText = adapterSection.content.join(" ");
+            for (const [service, line] of references.entries()) {
+                const pattern = EXTERNAL_SERVICE_PATTERNS.find((entry) => entry.name === service)?.pattern;
+                if (pattern && !pattern.test(adapterText)) {
+                    issues.push(buildIssue({
+                        id: `gate-sds-external-adapters-missing-${service.toLowerCase()}`,
+                        message: `SDS references ${service} but the adapter details are missing.`,
+                        remediation: `Describe the ${service} adapter/contract, including constraints, error handling, and fallback behavior.`,
+                        record: sds,
+                        line,
+                        metadata: { issueType: "missing_adapter_description", service },
+                    }));
+                }
+            }
+            const missing = [];
+            if (!containsAny(adapterSection.content, CONSTRAINT_PATTERNS)) {
+                missing.push("constraints");
+            }
+            if (!containsAny(adapterSection.content, ERROR_HANDLING_PATTERNS)) {
+                missing.push("error_handling");
+            }
+            if (!containsAny(adapterSection.content, FALLBACK_PATTERNS)) {
+                missing.push("fallback");
+            }
+            if (missing.length > 0) {
+                issues.push(buildIssue({
+                    id: "gate-sds-external-adapters-missing-details",
+                    message: `External adapter section is missing ${missing.join(", ")} details.`,
+                    remediation: "Expand the adapter section to document integration constraints, error handling, and fallback behavior.",
+                    record: sds,
+                    line: adapterSection.line,
+                    metadata: { issueType: "missing_adapter_details", missing },
+                }));
+            }
+        }
+    }
+    catch (error) {
+        notes.push(`Unable to read SDS ${sds.path}: ${error.message ?? String(error)}`);
+    }
+    const status = issues.length === 0 ? "pass" : "fail";
+    return {
+        gateId: "gate-sds-external-adapters",
+        gateName: "SDS External Adapters",
+        status,
+        issues,
+        notes: notes.length ? notes : undefined,
+        metadata: { issueCount: issues.length },
+    };
+};

package/dist/services/docs/review/gates/SdsDecisionsGate.d.ts

@@ -0,0 +1,7 @@
+import { DocgenArtifactInventory } from "../../DocgenRunContext.js";
+import { ReviewGateResult } from "../ReviewTypes.js";
+export interface SdsDecisionsGateInput {
+    artifacts: DocgenArtifactInventory;
+}
+export declare const runSdsDecisionsGate: (input: SdsDecisionsGateInput) => Promise<ReviewGateResult>;
+//# sourceMappingURL=SdsDecisionsGate.d.ts.map

package/dist/services/docs/review/gates/SdsDecisionsGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdsDecisionsGate.d.ts","sourceRoot":"","sources":["../../../../../src/services/docs/review/gates/SdsDecisionsGate.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAe,MAAM,mBAAmB,CAAC;AAElE,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,uBAAuB,CAAC;CACpC;AAqCD,eAAO,MAAM,mBAAmB,GAC9B,OAAO,qBAAqB,KAC3B,OAAO,CAAC,gBAAgB,CAiE1B,CAAC"}

package/dist/services/docs/review/gates/SdsDecisionsGate.js

@@ -0,0 +1,89 @@
+import { promises as fs } from "node:fs";
+const DECISION_HEADINGS = /architecture|tech stack|technology|database|storage|runtime|language|framework|deployment/i;
+const OPTIONS_HEADING = /options considered|alternatives/i;
+const isFenceLine = (line) => /^```|^~~~/.test(line.trim());
+const isAmbiguousDecision = (line) => {
+    const trimmed = line.toLowerCase();
+    if (trimmed.includes("either ") || trimmed.includes(" or ") || trimmed.includes("/")) {
+        return /\b\w+\s+(or|\/)+\s+\w+/.test(trimmed) || /either\s+\w+\s+or\s+\w+/.test(trimmed);
+    }
+    return false;
+};
+const buildIssue = (input) => ({
+    id: `gate-sds-explicit-decisions-${input.line}`,
+    gateId: "gate-sds-explicit-decisions",
+    severity: "high",
+    category: "decision",
+    artifact: "sds",
+    message: "SDS decision section contains ambiguous technology choice.",
+    remediation: "Replace ambiguous choices with a single explicit decision.",
+    location: {
+        kind: "line_range",
+        path: input.record.path,
+        lineStart: input.line,
+        lineEnd: input.line,
+        excerpt: input.excerpt,
+    },
+    metadata: { issueType: "ambiguous_decision" },
+});
+export const runSdsDecisionsGate = async (input) => {
+    const sds = input.artifacts.sds;
+    if (!sds) {
+        return {
+            gateId: "gate-sds-explicit-decisions",
+            gateName: "SDS Explicit Decisions",
+            status: "skipped",
+            issues: [],
+            notes: ["No SDS artifact available for explicit decision validation."],
+        };
+    }
+    const issues = [];
+    const notes = [];
+    try {
+        const content = await fs.readFile(sds.path, "utf8");
+        const lines = content.split(/\r?\n/);
+        let inFence = false;
+        let inDecisionSection = false;
+        let inOptionsSection = false;
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i] ?? "";
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            if (isFenceLine(trimmed)) {
+                inFence = !inFence;
+                continue;
+            }
+            if (inFence)
+                continue;
+            const heading = trimmed.match(/^#{1,6}\s+(.*)$/);
+            if (heading) {
+                const title = heading[1]?.trim() ?? "";
+                inOptionsSection = OPTIONS_HEADING.test(title);
+                inDecisionSection = DECISION_HEADINGS.test(title) && !inOptionsSection;
+                continue;
+            }
+            if (!inDecisionSection || inOptionsSection)
+                continue;
+            if (!isAmbiguousDecision(trimmed))
+                continue;
+            issues.push(buildIssue({
+                record: sds,
+                line: i + 1,
+                excerpt: trimmed,
+            }));
+        }
+    }
+    catch (error) {
+        notes.push(`Unable to read SDS ${sds.path}: ${error.message ?? String(error)}`);
+    }
+    const status = issues.length === 0 ? "pass" : "fail";
+    return {
+        gateId: "gate-sds-explicit-decisions",
+        gateName: "SDS Explicit Decisions",
+        status,
+        issues,
+        notes: notes.length ? notes : undefined,
+        metadata: { issueCount: issues.length },
+    };
+};

package/dist/services/docs/review/gates/SdsOpsGate.d.ts

@@ -0,0 +1,7 @@
+import { DocgenArtifactInventory } from "../../DocgenRunContext.js";
+import { ReviewGateResult } from "../ReviewTypes.js";
+export interface SdsOpsGateInput {
+    artifacts: DocgenArtifactInventory;
+}
+export declare const runSdsOpsGate: (input: SdsOpsGateInput) => Promise<ReviewGateResult>;
+//# sourceMappingURL=SdsOpsGate.d.ts.map

package/dist/services/docs/review/gates/SdsOpsGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdsOpsGate.d.ts","sourceRoot":"","sources":["../../../../../src/services/docs/review/gates/SdsOpsGate.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAe,MAAM,mBAAmB,CAAC;AAElE,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,uBAAuB,CAAC;CACpC;AAgED,eAAO,MAAM,aAAa,GAAU,OAAO,eAAe,KAAG,OAAO,CAAC,gBAAgB,CAgIpF,CAAC"}

package/dist/services/docs/review/gates/SdsOpsGate.js

@@ -0,0 +1,162 @@
+import { promises as fs } from "node:fs";
+const isFenceLine = (line) => /^```|^~~~/.test(line.trim());
+const extractSection = (lines, headingMatch) => {
+    let inFence = false;
+    let capture = false;
+    let startLine = 0;
+    const collected = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const trimmed = line.trim();
+        if (isFenceLine(trimmed)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        const heading = trimmed.match(/^#{1,6}\s+(.*)$/);
+        if (heading) {
+            const title = heading[1]?.trim() ?? "";
+            if (headingMatch.test(title)) {
+                capture = true;
+                startLine = i + 1;
+                continue;
+            }
+            if (capture)
+                break;
+        }
+        if (capture && trimmed)
+            collected.push(trimmed);
+    }
+    if (!capture)
+        return undefined;
+    return { content: collected, line: startLine };
+};
+const containsAny = (lines, patterns) => lines.some((line) => patterns.some((pattern) => pattern.test(line)));
+const buildIssue = (input) => ({
+    id: input.id,
+    gateId: "gate-sds-ops-observability-testing",
+    severity: "high",
+    category: "completeness",
+    artifact: "sds",
+    message: input.message,
+    remediation: input.remediation,
+    location: {
+        kind: "line_range",
+        path: input.record.path,
+        lineStart: input.line ?? 1,
+        lineEnd: input.line ?? 1,
+        excerpt: input.message,
+    },
+    metadata: input.metadata,
+});
+export const runSdsOpsGate = async (input) => {
+    const sds = input.artifacts.sds;
+    if (!sds) {
+        return {
+            gateId: "gate-sds-ops-observability-testing",
+            gateName: "SDS Ops & Observability",
+            status: "skipped",
+            issues: [],
+            notes: ["No SDS artifact available for ops/observability validation."],
+        };
+    }
+    const issues = [];
+    const notes = [];
+    try {
+        const content = await fs.readFile(sds.path, "utf8");
+        const lines = content.split(/\r?\n/);
+        const opsSection = extractSection(lines, /operations|deployment|environment/i);
+        const observabilitySection = extractSection(lines, /observability|monitoring|slo|alert/i);
+        const testingSection = extractSection(lines, /testing|quality|test gates?/i);
+        const failureSection = extractSection(lines, /failure|recovery|rollback|incident/i);
+        if (!opsSection) {
+            issues.push(buildIssue({
+                id: "gate-sds-ops-observability-testing-missing-ops",
+                message: "SDS is missing an operations/deployment section.",
+                remediation: "Add environment, secrets strategy, and deployment details.",
+                record: sds,
+                metadata: { issueType: "missing_ops" },
+            }));
+        }
+        else if (!containsAny(opsSection.content, [/environment/i, /secrets?/i, /deploy/i])) {
+            issues.push(buildIssue({
+                id: "gate-sds-ops-observability-testing-incomplete-ops",
+                message: "Operations section lacks environment/secrets details.",
+                remediation: "Describe deployment environments and secrets handling.",
+                record: sds,
+                line: opsSection.line,
+                metadata: { issueType: "incomplete_ops" },
+            }));
+        }
+        if (!observabilitySection) {
+            issues.push(buildIssue({
+                id: "gate-sds-ops-observability-testing-missing-observability",
+                message: "SDS is missing an observability section.",
+                remediation: "Add SLOs, alerting thresholds, and monitoring targets.",
+                record: sds,
+                metadata: { issueType: "missing_observability" },
+            }));
+        }
+        else if (!containsAny(observabilitySection.content, [/slo/i, /alert/i, /threshold/i])) {
+            issues.push(buildIssue({
+                id: "gate-sds-ops-observability-testing-incomplete-observability",
+                message: "Observability section lacks SLOs or alert thresholds.",
+                remediation: "Define SLOs and alert thresholds for critical metrics.",
+                record: sds,
+                line: observabilitySection.line,
+                metadata: { issueType: "incomplete_observability" },
+            }));
+        }
+        if (!testingSection) {
+            issues.push(buildIssue({
+                id: "gate-sds-ops-observability-testing-missing-testing",
+                message: "SDS is missing a testing gates section.",
+                remediation: "Describe test gates and release validation steps.",
+                record: sds,
+                metadata: { issueType: "missing_testing" },
+            }));
+        }
+        else if (!containsAny(testingSection.content, [/test/i, /gate/i, /validation/i])) {
+            issues.push(buildIssue({
+                id: "gate-sds-ops-observability-testing-incomplete-testing",
+                message: "Testing section lacks explicit test gates or validation criteria.",
+                remediation: "List required test gates for deployment readiness.",
+                record: sds,
+                line: testingSection.line,
+                metadata: { issueType: "incomplete_testing" },
+            }));
+        }
+        if (!failureSection) {
+            issues.push(buildIssue({
+                id: "gate-sds-ops-observability-testing-missing-failure",
+                message: "SDS is missing failure modes and recovery procedures.",
+                remediation: "Document failure modes and recovery/runbook steps.",
+                record: sds,
+                metadata: { issueType: "missing_failure" },
+            }));
+        }
+        else if (!containsAny(failureSection.content, [/failure/i, /recovery/i, /rollback/i])) {
+            issues.push(buildIssue({
+                id: "gate-sds-ops-observability-testing-incomplete-failure",
+                message: "Failure section lacks recovery or rollback details.",
+                remediation: "Include recovery procedures and rollback steps.",
+                record: sds,
+                line: failureSection.line,
+                metadata: { issueType: "incomplete_failure" },
+            }));
+        }
+    }
+    catch (error) {
+        notes.push(`Unable to read SDS ${sds.path}: ${error.message ?? String(error)}`);
+    }
+    const status = issues.length === 0 ? "pass" : "fail";
+    return {
+        gateId: "gate-sds-ops-observability-testing",
+        gateName: "SDS Ops & Observability",
+        status,
+        issues,
+        notes: notes.length ? notes : undefined,
+        metadata: { issueCount: issues.length },
+    };
+};

package/dist/services/docs/review/gates/SdsPolicyTelemetryGate.d.ts

@@ -0,0 +1,7 @@
+import { DocgenArtifactInventory } from "../../DocgenRunContext.js";
+import { ReviewGateResult } from "../ReviewTypes.js";
+export interface SdsPolicyTelemetryGateInput {
+    artifacts: DocgenArtifactInventory;
+}
+export declare const runSdsPolicyTelemetryGate: (input: SdsPolicyTelemetryGateInput) => Promise<ReviewGateResult>;
+//# sourceMappingURL=SdsPolicyTelemetryGate.d.ts.map

package/dist/services/docs/review/gates/SdsPolicyTelemetryGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdsPolicyTelemetryGate.d.ts","sourceRoot":"","sources":["../../../../../src/services/docs/review/gates/SdsPolicyTelemetryGate.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAe,MAAM,mBAAmB,CAAC;AAElE,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,uBAAuB,CAAC;CACpC;AAgED,eAAO,MAAM,yBAAyB,GACpC,OAAO,2BAA2B,KACjC,OAAO,CAAC,gBAAgB,CAgI1B,CAAC"}

package/dist/services/docs/review/gates/SdsPolicyTelemetryGate.js

@@ -0,0 +1,166 @@
+import { promises as fs } from "node:fs";
+const isFenceLine = (line) => /^```|^~~~/.test(line.trim());
+const extractSection = (lines, headingMatch) => {
+    let inFence = false;
+    let capture = false;
+    let startLine = 0;
+    const collected = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const trimmed = line.trim();
+        if (isFenceLine(trimmed)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        const heading = trimmed.match(/^#{1,6}\s+(.*)$/);
+        if (heading) {
+            const title = heading[1]?.trim() ?? "";
+            if (headingMatch.test(title)) {
+                capture = true;
+                startLine = i + 1;
+                continue;
+            }
+            if (capture)
+                break;
+        }
+        if (capture && trimmed)
+            collected.push(trimmed);
+    }
+    if (!capture)
+        return undefined;
+    return { content: collected, line: startLine };
+};
+const containsAny = (lines, patterns) => lines.some((line) => patterns.some((pattern) => pattern.test(line)));
+const buildIssue = (input) => ({
+    id: input.id,
+    gateId: "gate-sds-policy-telemetry-metering",
+    severity: "high",
+    category: "completeness",
+    artifact: "sds",
+    message: input.message,
+    remediation: input.remediation,
+    location: {
+        kind: "line_range",
+        path: input.record.path,
+        lineStart: input.line ?? 1,
+        lineEnd: input.line ?? 1,
+        excerpt: input.message,
+    },
+    metadata: input.metadata,
+});
+export const runSdsPolicyTelemetryGate = async (input) => {
+    const sds = input.artifacts.sds;
+    if (!sds) {
+        return {
+            gateId: "gate-sds-policy-telemetry-metering",
+            gateName: "SDS Policy, Telemetry & Metering",
+            status: "skipped",
+            issues: [],
+            notes: ["No SDS artifact available for policy/telemetry validation."],
+        };
+    }
+    const issues = [];
+    const notes = [];
+    try {
+        const content = await fs.readFile(sds.path, "utf8");
+        const lines = content.split(/\r?\n/);
+        const policySection = extractSection(lines, /policy|cache|consent/i);
+        const telemetrySection = extractSection(lines, /telemetry|metrics|logging|events?/i);
+        const meteringSection = extractSection(lines, /metering|usage|billing|rate limits?/i);
+        if (!policySection) {
+            issues.push(buildIssue({
+                id: "gate-sds-policy-telemetry-metering-missing-policy",
+                message: "SDS is missing a policy/cache section.",
+                remediation: "Add cache key policy, TTL tiers, and consent matrix details.",
+                record: sds,
+                metadata: { issueType: "missing_policy" },
+            }));
+        }
+        else {
+            const policyOk = containsAny(policySection.content, [
+                /cache key/i,
+                /ttl/i,
+                /consent matrix/i,
+                /consent/i,
+            ]);
+            if (!policyOk) {
+                issues.push(buildIssue({
+                    id: "gate-sds-policy-telemetry-metering-incomplete-policy",
+                    message: "Policy section lacks cache key/TTL/consent matrix details.",
+                    remediation: "Include cache key rules, TTL tiers, and a consent matrix.",
+                    record: sds,
+                    line: policySection.line,
+                    metadata: { issueType: "incomplete_policy" },
+                }));
+            }
+        }
+        if (!telemetrySection) {
+            issues.push(buildIssue({
+                id: "gate-sds-policy-telemetry-metering-missing-telemetry",
+                message: "SDS is missing a telemetry schema section.",
+                remediation: "Add telemetry schema definitions for anonymous and identified data.",
+                record: sds,
+                metadata: { issueType: "missing_telemetry" },
+            }));
+        }
+        else {
+            const telemetryOk = containsAny(telemetrySection.content, [
+                /schema/i,
+                /anonymous/i,
+                /identified/i,
+            ]);
+            if (!telemetryOk) {
+                issues.push(buildIssue({
+                    id: "gate-sds-policy-telemetry-metering-incomplete-telemetry",
+                    message: "Telemetry section lacks schema details for anonymous/identified data.",
+                    remediation: "Describe telemetry schemas and how anonymous vs identified data are captured.",
+                    record: sds,
+                    line: telemetrySection.line,
+                    metadata: { issueType: "incomplete_telemetry" },
+                }));
+            }
+        }
+        if (!meteringSection) {
+            issues.push(buildIssue({
+                id: "gate-sds-policy-telemetry-metering-missing-metering",
+                message: "SDS is missing a metering/usage section.",
+                remediation: "Add metering rules and enforcement details.",
+                record: sds,
+                metadata: { issueType: "missing_metering" },
+            }));
+        }
+        else {
+            const meteringOk = containsAny(meteringSection.content, [
+                /meter/i,
+                /usage/i,
+                /rate/i,
+                /limit/i,
+                /enforce/i,
+            ]);
+            if (!meteringOk) {
+                issues.push(buildIssue({
+                    id: "gate-sds-policy-telemetry-metering-incomplete-metering",
+                    message: "Metering section lacks usage tracking or enforcement rules.",
+                    remediation: "Describe usage tracking, rate limits, and enforcement actions.",
+                    record: sds,
+                    line: meteringSection.line,
+                    metadata: { issueType: "incomplete_metering" },
+                }));
+            }
+        }
+    }
+    catch (error) {
+        notes.push(`Unable to read SDS ${sds.path}: ${error.message ?? String(error)}`);
+    }
+    const status = issues.length === 0 ? "pass" : "fail";
+    return {
+        gateId: "gate-sds-policy-telemetry-metering",
+        gateName: "SDS Policy, Telemetry & Metering",
+        status,
+        issues,
+        notes: notes.length ? notes : undefined,
+        metadata: { issueCount: issues.length },
+    };
+};

package/dist/services/docs/review/gates/SqlRequiredTablesGate.d.ts

@@ -0,0 +1,7 @@
+import { DocgenArtifactInventory } from "../../DocgenRunContext.js";
+import { ReviewGateResult } from "../ReviewTypes.js";
+export interface SqlRequiredTablesGateInput {
+    artifacts: DocgenArtifactInventory;
+}
+export declare const runSqlRequiredTablesGate: (input: SqlRequiredTablesGateInput) => Promise<ReviewGateResult>;
+//# sourceMappingURL=SqlRequiredTablesGate.d.ts.map

package/dist/services/docs/review/gates/SqlRequiredTablesGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqlRequiredTablesGate.d.ts","sourceRoot":"","sources":["../../../../../src/services/docs/review/gates/SqlRequiredTablesGate.ts"],"names":[],"mappings":"AAEA,OAAO,EAAqB,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAe,MAAM,mBAAmB,CAAC;AAElE,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,uBAAuB,CAAC;CACpC;AA8MD,eAAO,MAAM,wBAAwB,GACnC,OAAO,0BAA0B,KAChC,OAAO,CAAC,gBAAgB,CA4H1B,CAAC"}