@mcoda/codali 0.1.66

package/dist/cognitive/EvidenceGate.js

@@ -0,0 +1,75 @@
+const toNumber = (value) => {
+    if (!Number.isFinite(value))
+        return 0;
+    return value ?? 0;
+};
+const uniqueStrings = (values) => {
+    return Array.from(new Set(values.filter((value) => value.length > 0)));
+};
+const buildRequiredMetrics = (config) => {
+    return {
+        search_hits: Math.max(0, Math.floor(toNumber(config.minSearchHits))),
+        open_or_snippet: Math.max(0, Math.floor(toNumber(config.minOpenOrSnippet))),
+        symbols_or_ast: Math.max(0, Math.floor(toNumber(config.minSymbolsOrAst))),
+        impact: Math.max(0, Math.floor(toNumber(config.minImpact))),
+        warnings: Math.max(0, Math.floor(toNumber(config.maxWarnings))),
+    };
+};
+const buildObservedMetrics = (evidence, toolUsage, warnings) => {
+    const warningList = uniqueStrings([
+        ...(evidence?.warnings ?? []),
+        ...(warnings ?? []),
+    ]);
+    const searchHits = toNumber(evidence?.search_hits);
+    const snippetCount = toNumber(evidence?.snippet_count);
+    const symbolFiles = toNumber(evidence?.symbol_files);
+    const astFiles = toNumber(evidence?.ast_files);
+    const impactFiles = toNumber(evidence?.impact_files);
+    const impactEdges = toNumber(evidence?.impact_edges);
+    const toolOpenOrSnippet = toNumber(toolUsage?.open_or_snippet);
+    const toolSymbolsOrAst = toNumber(toolUsage?.symbols_or_ast);
+    const toolImpact = toNumber(toolUsage?.impact);
+    const metrics = {
+        search_hits: searchHits,
+        open_or_snippet: Math.max(snippetCount, toolOpenOrSnippet),
+        symbols_or_ast: Math.max(symbolFiles + astFiles, toolSymbolsOrAst),
+        impact: Math.max(impactFiles, impactEdges, toolImpact),
+        warnings: warningList.length,
+    };
+    return { metrics, warningList, gaps: evidence?.gaps };
+};
+const buildMissingSignals = (observed, required) => {
+    const missing = [];
+    if (observed.search_hits < required.search_hits)
+        missing.push("search_hits");
+    if (observed.open_or_snippet < required.open_or_snippet) {
+        missing.push("open_or_snippet");
+    }
+    if (observed.symbols_or_ast < required.symbols_or_ast) {
+        missing.push("symbols_or_ast");
+    }
+    if (observed.impact < required.impact)
+        missing.push("impact");
+    if (observed.warnings > required.warnings)
+        missing.push("warnings");
+    return missing;
+};
+export const evaluateEvidenceGate = ({ config, evidence, toolUsage, warnings, }) => {
+    const required = buildRequiredMetrics(config);
+    const { metrics: observed, warningList, gaps } = buildObservedMetrics(evidence, toolUsage, warnings);
+    const missing = buildMissingSignals(observed, required);
+    const totalSignals = 5;
+    const score = (totalSignals - missing.length) / totalSignals;
+    const threshold = 1;
+    const status = missing.length === 0 ? "pass" : "fail";
+    return {
+        status,
+        score,
+        threshold,
+        missing,
+        required,
+        observed,
+        warnings: warningList.length ? warningList : undefined,
+        gaps,
+    };
+};

package/dist/cognitive/GoldenExampleIndexer.d.ts

@@ -0,0 +1,12 @@
+import type { DocdexClient } from "../docdex/DocdexClient.js";
+export interface GoldenExample {
+    intent: string;
+    patch: string;
+    score?: number;
+}
+export declare class GoldenExampleIndexer {
+    private client;
+    constructor(client: DocdexClient);
+    findExamples(intent: string, limit?: number): Promise<GoldenExample[]>;
+}
+//# sourceMappingURL=GoldenExampleIndexer.d.ts.map

package/dist/cognitive/GoldenExampleIndexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GoldenExampleIndexer.d.ts","sourceRoot":"","sources":["../../src/cognitive/GoldenExampleIndexer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,oBAAoB;IACnB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAElC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;CAiCxE"}

package/dist/cognitive/GoldenExampleIndexer.js

@@ -0,0 +1,34 @@
+export class GoldenExampleIndexer {
+    constructor(client) {
+        this.client = client;
+    }
+    async findExamples(intent, limit = 3) {
+        try {
+            // 1. Recall from Repo Memory using the intent
+            const result = await this.client.memoryRecall(intent, limit * 3);
+            const hits = result.results || [];
+            const examples = [];
+            for (const hit of hits) {
+                if (!hit.content.startsWith("GOLDEN_EXAMPLE"))
+                    continue;
+                // Parse the stored format:
+                // GOLDEN_EXAMPLE
+                // INTENT: <intent>
+                // PATCH: <patch>
+                const intentMatch = hit.content.match(/INTENT:\s*(.*?)\nPATCH:/s);
+                const patchMatch = hit.content.match(/PATCH:\s*([\s\S]*)$/);
+                if (intentMatch && patchMatch) {
+                    examples.push({
+                        intent: intentMatch[1].trim(),
+                        patch: patchMatch[1].trim(),
+                        score: hit.score
+                    });
+                }
+            }
+            return examples.slice(0, limit);
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/cognitive/GoldenSetStore.d.ts

@@ -0,0 +1,33 @@
+export interface GoldenSetEntry {
+    intent: string;
+    plan_summary: string;
+    touched_files: string[];
+    review_notes?: string;
+    qa_notes?: string;
+    patch_summary?: string;
+    created_at: string;
+}
+export interface GoldenSetStoreOptions {
+    workspaceRoot: string;
+    storagePath?: string;
+    maxEntries?: number;
+}
+export interface GoldenExampleSummary {
+    intent: string;
+    patch: string;
+    score?: number;
+}
+export declare class GoldenSetStore {
+    private workspaceRoot;
+    private storagePath;
+    private maxEntries;
+    constructor(options: GoldenSetStoreOptions);
+    private resolveStoragePath;
+    private sanitizeEntry;
+    load(): Promise<GoldenSetEntry[]>;
+    append(entry: Omit<GoldenSetEntry, "created_at"> & {
+        created_at?: string;
+    }): Promise<GoldenSetEntry[]>;
+    findExamples(intent: string, limit?: number): Promise<GoldenExampleSummary[]>;
+}
+//# sourceMappingURL=GoldenSetStore.d.ts.map

package/dist/cognitive/GoldenSetStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GoldenSetStore.d.ts","sourceRoot":"","sources":["../../src/cognitive/GoldenSetStore.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA6ED,qBAAa,cAAc;IACzB,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAS;gBAEf,OAAO,EAAE,qBAAqB;IAM1C,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,aAAa;IAYf,IAAI,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAkBjC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,GAAG;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAiBtG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC;CAuB/E"}

package/dist/cognitive/GoldenSetStore.js

@@ -0,0 +1,159 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const DEFAULT_STORAGE_PATH = ".mcoda/codali/golden-examples.jsonl";
+const DEFAULT_MAX_ENTRIES = 50;
+const REDACTION_PATTERNS = [
+    [/AKIA[0-9A-Z]{16}/g, "[REDACTED_AWS_KEY]"],
+    [/\bsk-[A-Za-z0-9]{20,}\b/g, "[REDACTED_TOKEN]"],
+    [/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]"],
+    [/-----BEGIN [^-]+ PRIVATE KEY-----[\s\S]*?-----END [^-]+ PRIVATE KEY-----/g, "[REDACTED_PRIVATE_KEY]"],
+];
+const normalizeText = (value) => {
+    let next = value;
+    for (const [pattern, replacement] of REDACTION_PATTERNS) {
+        next = next.replace(pattern, replacement);
+    }
+    return next.trim();
+};
+const tokenize = (value) => {
+    const matches = value.toLowerCase().match(/[a-z0-9_./-]{3,}/g);
+    return new Set(matches ?? []);
+};
+const scoreEntry = (queryTokens, entryText) => {
+    if (queryTokens.size === 0)
+        return 0;
+    const entryTokens = tokenize(entryText);
+    let overlap = 0;
+    for (const token of queryTokens) {
+        if (entryTokens.has(token))
+            overlap += 1;
+    }
+    return overlap / queryTokens.size;
+};
+const safeParseJson = (line) => {
+    try {
+        const parsed = JSON.parse(line);
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        if (typeof parsed.intent !== "string" || typeof parsed.plan_summary !== "string")
+            return undefined;
+        return {
+            intent: parsed.intent,
+            plan_summary: parsed.plan_summary,
+            touched_files: Array.isArray(parsed.touched_files)
+                ? parsed.touched_files.filter((item) => typeof item === "string")
+                : [],
+            review_notes: typeof parsed.review_notes === "string" ? parsed.review_notes : undefined,
+            qa_notes: typeof parsed.qa_notes === "string" ? parsed.qa_notes : undefined,
+            patch_summary: typeof parsed.patch_summary === "string" ? parsed.patch_summary : undefined,
+            created_at: typeof parsed.created_at === "string" && parsed.created_at.trim().length > 0
+                ? parsed.created_at
+                : new Date(0).toISOString(),
+        };
+    }
+    catch {
+        return undefined;
+    }
+};
+const toPatchSummary = (entry) => {
+    const parts = [];
+    parts.push(`plan=${entry.plan_summary}`);
+    if (entry.touched_files.length > 0) {
+        parts.push(`files=${entry.touched_files.join(", ")}`);
+    }
+    if (entry.review_notes) {
+        parts.push(`review=${entry.review_notes}`);
+    }
+    if (entry.qa_notes) {
+        parts.push(`qa=${entry.qa_notes}`);
+    }
+    if (entry.patch_summary) {
+        parts.push(`patch=${entry.patch_summary}`);
+    }
+    return parts.join(" | ");
+};
+export class GoldenSetStore {
+    constructor(options) {
+        this.workspaceRoot = path.resolve(options.workspaceRoot);
+        this.storagePath = this.resolveStoragePath(options.storagePath ?? DEFAULT_STORAGE_PATH);
+        this.maxEntries = options.maxEntries && options.maxEntries > 0 ? Math.floor(options.maxEntries) : DEFAULT_MAX_ENTRIES;
+    }
+    resolveStoragePath(storagePath) {
+        const absolute = path.resolve(this.workspaceRoot, storagePath);
+        const relative = path.relative(this.workspaceRoot, absolute);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            throw new Error("GoldenSetStore storage path must be inside workspace root");
+        }
+        return absolute;
+    }
+    sanitizeEntry(entry) {
+        return {
+            intent: normalizeText(entry.intent),
+            plan_summary: normalizeText(entry.plan_summary),
+            touched_files: entry.touched_files.map((item) => item.trim()).filter(Boolean),
+            review_notes: entry.review_notes ? normalizeText(entry.review_notes) : undefined,
+            qa_notes: entry.qa_notes ? normalizeText(entry.qa_notes) : undefined,
+            patch_summary: entry.patch_summary ? normalizeText(entry.patch_summary) : undefined,
+            created_at: entry.created_at,
+        };
+    }
+    async load() {
+        try {
+            const raw = await fs.readFile(this.storagePath, "utf8");
+            const entries = raw
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .map((line) => safeParseJson(line))
+                .filter((entry) => Boolean(entry));
+            return entries.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+        }
+        catch (error) {
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async append(entry) {
+        const nextEntry = this.sanitizeEntry({
+            ...entry,
+            created_at: entry.created_at ?? new Date().toISOString(),
+        });
+        if (!nextEntry.intent || !nextEntry.plan_summary) {
+            throw new Error("GoldenSetStore entries require intent and plan_summary");
+        }
+        const existing = await this.load();
+        const all = [...existing, nextEntry];
+        const bounded = all.slice(Math.max(0, all.length - this.maxEntries));
+        await fs.mkdir(path.dirname(this.storagePath), { recursive: true });
+        const payload = bounded.map((item) => JSON.stringify(item)).join("\n");
+        await fs.writeFile(this.storagePath, payload.length > 0 ? `${payload}\n` : "", "utf8");
+        return bounded;
+    }
+    async findExamples(intent, limit = 3) {
+        const safeLimit = Math.max(1, Math.floor(limit));
+        const entries = await this.load();
+        if (entries.length === 0)
+            return [];
+        const queryTokens = tokenize(intent);
+        return entries
+            .map((entry) => {
+            const text = `${entry.intent}\n${entry.plan_summary}\n${entry.touched_files.join(" ")}\n${entry.review_notes ?? ""}\n${entry.qa_notes ?? ""}`;
+            const score = scoreEntry(queryTokens, text);
+            return {
+                intent: entry.intent,
+                patch: toPatchSummary(entry),
+                score,
+                createdAt: Date.parse(entry.created_at),
+            };
+        })
+            .sort((a, b) => {
+            if (b.score !== a.score)
+                return b.score - a.score;
+            return b.createdAt - a.createdAt;
+        })
+            .slice(0, safeLimit)
+            .map((entry) => ({ intent: entry.intent, patch: entry.patch, score: entry.score }));
+    }
+}

package/dist/cognitive/IntentSignals.d.ts

@@ -0,0 +1,7 @@
+export type IntentBucket = "ui" | "content" | "behavior" | "data" | "testing" | "infra" | "security" | "performance" | "observability";
+export interface IntentSignals {
+    intents: IntentBucket[];
+    matches: Record<IntentBucket, string[]>;
+}
+export declare const deriveIntentSignals: (request: string) => IntentSignals;
+//# sourceMappingURL=IntentSignals.d.ts.map

package/dist/cognitive/IntentSignals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntentSignals.d.ts","sourceRoot":"","sources":["../../src/cognitive/IntentSignals.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GACpB,IAAI,GACJ,SAAS,GACT,UAAU,GACV,MAAM,GACN,SAAS,GACT,OAAO,GACP,UAAU,GACV,aAAa,GACb,eAAe,CAAC;AAEpB,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC;CACzC;AAsPD,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,aAkDrD,CAAC"}

package/dist/cognitive/IntentSignals.js

@@ -0,0 +1,285 @@
+const UI_KEYWORDS = [
+    "ui",
+    "ux",
+    "page",
+    "screen",
+    "layout",
+    "header",
+    "hero",
+    "navbar",
+    "footer",
+    "landing",
+    "welcome",
+    "title",
+    "button",
+    "style",
+    "css",
+    "html",
+    "markup",
+    "template",
+    "component",
+    "view",
+];
+const CONTENT_KEYWORDS = [
+    "copy",
+    "text",
+    "label",
+    "wording",
+    "message",
+    "string",
+    "content",
+];
+const BEHAVIOR_KEYWORDS = [
+    "logic",
+    "behavior",
+    "bug",
+    "fix",
+    "error",
+    "crash",
+    "api",
+    "backend",
+    "server",
+    "endpoint",
+    "route",
+    "router",
+    "handler",
+    "healthz",
+    "health",
+    "logging",
+    "logger",
+    "uptime",
+    "flow",
+    "auth",
+    "estimate",
+    "estimation",
+    "stats",
+    "stat",
+    "completion",
+    "completions",
+    "calculate",
+    "computed",
+    "compute",
+    "count",
+    "aggregate",
+    "summary",
+];
+const DATA_KEYWORDS = [
+    "schema",
+    "database",
+    "db",
+    "model",
+    "migration",
+    "table",
+    "field",
+    "column",
+    "sql",
+];
+const TESTING_KEYWORDS = [
+    "test",
+    "tests",
+    "testing",
+    "unit",
+    "integration",
+    "e2e",
+    "spec",
+    "specs",
+    "snapshot",
+    "snapshots",
+    "golden",
+    "approval",
+    "assertion",
+    "assertions",
+    "jest",
+    "vitest",
+    "mocha",
+    "pytest",
+    "rspec",
+    "junit",
+    "xunit",
+    "cypress",
+    "playwright",
+    "fixture",
+    "fixtures",
+    "mock",
+    "mocking",
+    "coverage",
+];
+const INFRA_BASE_KEYWORDS = [
+    "infra",
+    "infrastructure",
+    "ops",
+    "devops",
+    "ci",
+    "cd",
+    "pipeline",
+    "deploy",
+    "deployment",
+    "docker",
+    "compose",
+    "k8s",
+    "kubernetes",
+    "helm",
+    "terraform",
+    "ansible",
+    "makefile",
+    "workflow",
+    "runner",
+    "github actions",
+    "gitlab",
+    "gitlab ci",
+    "circleci",
+    "artifact",
+    "registry",
+];
+const INFRA_CONDITIONAL_KEYWORDS = ["build", "release", "package"];
+const SECURITY_KEYWORDS = [
+    "security",
+    "secure",
+    "auth",
+    "authentication",
+    "authorization",
+    "permission",
+    "permissions",
+    "rbac",
+    "acl",
+    "policy",
+    "jwt",
+    "oauth",
+    "sso",
+    "csrf",
+    "xss",
+    "samesite",
+    "csp",
+    "encrypt",
+    "encryption",
+    "crypto",
+    "secret",
+    "secrets",
+    "vault",
+    "audit",
+    "vulnerability",
+    "sanitize",
+];
+const PERFORMANCE_KEYWORDS = [
+    "performance",
+    "perf",
+    "slow",
+    "slowdown",
+    "latency",
+    "throughput",
+    "optimize",
+    "optimization",
+    "cache",
+    "caching",
+    "cache miss",
+    "memo",
+    "benchmark",
+    "profiling",
+    "profile",
+    "hot path",
+    "n+1",
+    "memory",
+    "cpu",
+    "throttle",
+    "rate limit",
+    "rate-limit",
+    "batch",
+    "queue",
+    "timeout",
+];
+const OBSERVABILITY_KEYWORDS = [
+    "observability",
+    "telemetry",
+    "instrument",
+    "instrumentation",
+    "logging",
+    "log",
+    "logger",
+    "log level",
+    "structured logging",
+    "metrics",
+    "monitor",
+    "monitoring",
+    "trace",
+    "tracing",
+    "trace id",
+    "span",
+    "otel",
+    "opentelemetry",
+    "sentry",
+    "datadog",
+    "prometheus",
+    "grafana",
+    "alert",
+    "alerts",
+];
+const OBSERVABILITY_LOGGING_ONLY = new Set([
+    "logging",
+    "log",
+    "logger",
+    "log level",
+    "structured logging",
+]);
+const normalize = (value) => value.toLowerCase().replace(/[^a-z0-9\\s]/g, " ");
+const collectMatches = (text, keywords) => {
+    const matches = [];
+    for (const keyword of keywords) {
+        if (text.includes(keyword))
+            matches.push(keyword);
+    }
+    return matches;
+};
+export const deriveIntentSignals = (request) => {
+    const normalized = normalize(request ?? "");
+    const uiMatches = collectMatches(normalized, UI_KEYWORDS);
+    const contentMatches = collectMatches(normalized, CONTENT_KEYWORDS);
+    const behaviorMatches = collectMatches(normalized, BEHAVIOR_KEYWORDS);
+    const dataMatches = collectMatches(normalized, DATA_KEYWORDS);
+    const testingMatches = collectMatches(normalized, TESTING_KEYWORDS);
+    const infraBaseMatches = collectMatches(normalized, INFRA_BASE_KEYWORDS);
+    const infraConditionalMatches = collectMatches(normalized, INFRA_CONDITIONAL_KEYWORDS);
+    const infraMatches = infraBaseMatches.length > 0
+        ? [...infraBaseMatches, ...infraConditionalMatches]
+        : infraBaseMatches;
+    const securityMatches = collectMatches(normalized, SECURITY_KEYWORDS);
+    const performanceMatches = collectMatches(normalized, PERFORMANCE_KEYWORDS);
+    const observabilityMatches = collectMatches(normalized, OBSERVABILITY_KEYWORDS);
+    const observabilityHasSignal = observabilityMatches.some((match) => !OBSERVABILITY_LOGGING_ONLY.has(match));
+    const observabilityFinal = observabilityHasSignal ? observabilityMatches : [];
+    const intents = [];
+    if (uiMatches.length)
+        intents.push("ui");
+    if (contentMatches.length)
+        intents.push("content");
+    if (behaviorMatches.length)
+        intents.push("behavior");
+    if (dataMatches.length)
+        intents.push("data");
+    if (testingMatches.length)
+        intents.push("testing");
+    if (infraMatches.length)
+        intents.push("infra");
+    if (securityMatches.length)
+        intents.push("security");
+    if (performanceMatches.length)
+        intents.push("performance");
+    if (observabilityFinal.length)
+        intents.push("observability");
+    if (intents.length === 0) {
+        intents.push("behavior");
+    }
+    return {
+        intents,
+        matches: {
+            ui: uiMatches,
+            content: contentMatches,
+            behavior: behaviorMatches,
+            data: dataMatches,
+            testing: testingMatches,
+            infra: infraMatches,
+            security: securityMatches,
+            performance: performanceMatches,
+            observability: observabilityFinal,
+        },
+    };
+};