intentdna 1.5.16 → 1.5.18

package/dist/schema/validate.js

@@ -7,6 +7,70 @@
  *   - Codon values in valid ranges
  *   - No circular inheritance
  */
+function isLegibilityAssetArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "object" && item !== null &&
+        typeof item.type === "string" &&
+        typeof item.path === "string");
+}
+function validateLegibilityAssets(dna, roleNamesSet, errors, warnings) {
+    const la = dna.legibility_assets;
+    if (!la)
+        return;
+    const validateAssetList = (assets, path) => {
+        for (let i = 0; i < assets.length; i++) {
+            const asset = assets[i];
+            const itemPath = `${path}[${i}]`;
+            if (!["required_read", "repo_map", "manifest", "artifact_index"].includes(asset.type)) {
+                errors.push({ path: `${itemPath}.type`, message: `unknown legibility asset type '${asset.type}'` });
+            }
+            if (!asset.path) {
+                errors.push({ path: `${itemPath}.path`, message: "legibility asset path cannot be empty" });
+            }
+            if (asset.tags !== undefined) {
+                if (!Array.isArray(asset.tags) || asset.tags.some((tag) => typeof tag !== "string" || !tag)) {
+                    errors.push({ path: `${itemPath}.tags`, message: "tags must be an array of non-empty strings" });
+                }
+            }
+        }
+    };
+    if (la.mandatory) {
+        if (!isLegibilityAssetArray(la.mandatory)) {
+            errors.push({ path: "legibility_assets.mandatory", message: "must be an array of legibility assets" });
+        }
+        else {
+            validateAssetList(la.mandatory, "legibility_assets.mandatory");
+        }
+    }
+    if (la.per_role) {
+        for (const [roleName, assets] of Object.entries(la.per_role)) {
+            if (roleNamesSet.size > 0 && !roleNamesSet.has(roleName)) {
+                warnings.push({ path: `legibility_assets.per_role.${roleName}`, message: `references unknown role '${roleName}'` });
+            }
+            if (!isLegibilityAssetArray(assets)) {
+                errors.push({ path: `legibility_assets.per_role.${roleName}`, message: "must be an array of legibility assets" });
+            }
+            else {
+                validateAssetList(assets, `legibility_assets.per_role.${roleName}`);
+            }
+        }
+    }
+    if (la.per_workflow) {
+        const wfNames = new Set(Object.keys(dna.workflows ?? {}));
+        if (dna.workflow)
+            wfNames.add(dna.workflow.name);
+        for (const [wfName, assets] of Object.entries(la.per_workflow)) {
+            if (wfNames.size > 0 && !wfNames.has(wfName)) {
+                warnings.push({ path: `legibility_assets.per_workflow.${wfName}`, message: `references unknown workflow '${wfName}'` });
+            }
+            if (!isLegibilityAssetArray(assets)) {
+                errors.push({ path: `legibility_assets.per_workflow.${wfName}`, message: "must be an array of legibility assets" });
+            }
+            else {
+                validateAssetList(assets, `legibility_assets.per_workflow.${wfName}`);
+            }
+        }
+    }
+}
 function validateCodon(codon, path) {
     const errors = [];
     switch (codon.type) {
@@ -186,6 +250,55 @@ function validateRole(name, role, geneNames) {
     }
     return errors;
 }
+function getCompletionCheckFields(check) {
+    if (typeof check !== "object" || check === null || Array.isArray(check))
+        return [];
+    const fields = [];
+    if (check.file_exists !== undefined)
+        fields.push("file_exists");
+    if (check.file_not_empty !== undefined)
+        fields.push("file_not_empty");
+    if (check.file_contains !== undefined)
+        fields.push("file_contains");
+    if (check.command_success !== undefined)
+        fields.push("command_success");
+    return fields;
+}
+function validateCompletionCheck(check, path) {
+    const errors = [];
+    if (typeof check !== "object" || check === null || Array.isArray(check)) {
+        errors.push({ path, message: "completion check must be an object" });
+        return errors;
+    }
+    const fields = getCompletionCheckFields(check);
+    if (fields.length !== 1) {
+        errors.push({ path, message: "completion check must define exactly one of: file_exists, file_not_empty, file_contains, command_success" });
+        return errors;
+    }
+    if (check.file_exists !== undefined && (typeof check.file_exists !== "string" || !check.file_exists)) {
+        errors.push({ path: `${path}.file_exists`, message: "must be a non-empty string" });
+    }
+    if (check.file_not_empty !== undefined && (typeof check.file_not_empty !== "string" || !check.file_not_empty)) {
+        errors.push({ path: `${path}.file_not_empty`, message: "must be a non-empty string" });
+    }
+    if (check.command_success !== undefined && (typeof check.command_success !== "string" || !check.command_success)) {
+        errors.push({ path: `${path}.command_success`, message: "must be a non-empty string" });
+    }
+    if (check.file_contains !== undefined) {
+        if (typeof check.file_contains !== "object" || check.file_contains === null) {
+            errors.push({ path: `${path}.file_contains`, message: "must define path and pattern" });
+        }
+        else {
+            if (typeof check.file_contains.path !== "string" || !check.file_contains.path) {
+                errors.push({ path: `${path}.file_contains.path`, message: "must be a non-empty string" });
+            }
+            if (typeof check.file_contains.pattern !== "string" || !check.file_contains.pattern) {
+                errors.push({ path: `${path}.file_contains.pattern`, message: "must be a non-empty string" });
+            }
+        }
+    }
+    return errors;
+}
 function validateWorkflow(workflow, roleNames, pathPrefix) {
     const errors = [];
     const path = pathPrefix ?? "workflow";
@@ -259,6 +372,16 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
                 });
             }
         }
+        if (step.completion !== undefined) {
+            if (!Array.isArray(step.completion)) {
+                errors.push({ path: `${stepPath}.completion`, message: "completion must be an array" });
+            }
+            else {
+                for (let j = 0; j < step.completion.length; j++) {
+                    errors.push(...validateCompletionCheck(step.completion[j], `${stepPath}.completion[${j}]`));
+                }
+            }
+        }
         // checkpoints validation
         if (step.checkpoints) {
             if (!Array.isArray(step.checkpoints)) {
@@ -478,6 +601,7 @@ export function validateDNA(dna) {
             }
         }
     }
+    validateLegibilityAssets(dna, roleNamesSet, errors, warnings);
     // Validate context_files
     if (dna.context_files) {
         const cf = dna.context_files;
@@ -505,6 +629,25 @@ export function validateDNA(dna) {
             }
         }
     }
+    // Validate verifier_policy
+    if (dna.verifier_policy) {
+        const { allow_commands, allow_command_prefixes, allow_builtin_asserts } = dna.verifier_policy;
+        if (allow_commands !== undefined) {
+            if (!Array.isArray(allow_commands) || allow_commands.some((value) => typeof value !== "string" || !value)) {
+                errors.push({ path: "verifier_policy.allow_commands", message: "must be an array of non-empty strings" });
+            }
+        }
+        if (allow_command_prefixes !== undefined) {
+            if (!Array.isArray(allow_command_prefixes) || allow_command_prefixes.some((value) => typeof value !== "string" || !value)) {
+                errors.push({ path: "verifier_policy.allow_command_prefixes", message: "must be an array of non-empty strings" });
+            }
+        }
+        if (allow_builtin_asserts !== undefined) {
+            if (!Array.isArray(allow_builtin_asserts) || allow_builtin_asserts.some((value) => typeof value !== "string" || !value)) {
+                errors.push({ path: "verifier_policy.allow_builtin_asserts", message: "must be an array of non-empty strings" });
+            }
+        }
+    }
     // Validate epigenetic markers
     for (let i = 0; i < (dna.epigenetic?.markers?.length ?? 0); i++) {
         const marker = dna.epigenetic.markers[i];

package/dist/signals/index.d.ts

@@ -0,0 +1,45 @@
+import type { TraceEntry, VerifierResultEntry } from "../hooks/state.js";
+import type { ExecutionOutcome } from "../evolution/types.js";
+export type SignalKind = "trace" | "verifier" | "external";
+export type SignalStatus = "positive" | "negative" | "neutral";
+export interface SignalEvidence {
+    target?: string;
+    evidence?: string;
+    exit_code?: number;
+    artifact?: string;
+    message?: string;
+}
+export interface SignalEnvelope {
+    id: string;
+    kind: SignalKind;
+    status: SignalStatus;
+    timestamp: string;
+    gene?: string;
+    source: string;
+    detail?: string;
+    adapter?: string;
+    evidence_payload?: SignalEvidence;
+}
+export interface ExternalSignalInput {
+    id?: string;
+    status: SignalStatus;
+    timestamp?: string;
+    gene?: string;
+    source: string;
+    detail?: string;
+    target?: string;
+    evidence?: string;
+    exit_code?: number;
+    artifact?: string;
+    message?: string;
+}
+export interface SignalSourceAdapter<T = unknown> {
+    name: string;
+    adapt(payload: T): SignalEnvelope[];
+}
+export declare const newapiSignalAdapter: SignalSourceAdapter<ExternalSignalInput | ExternalSignalInput[]>;
+export declare const gatewaySignalAdapter: SignalSourceAdapter<ExternalSignalInput | ExternalSignalInput[]>;
+export declare function adaptSignals<T>(adapter: SignalSourceAdapter<T>, payload: T): SignalEnvelope[];
+export declare function traceToSignals(traces: TraceEntry[]): SignalEnvelope[];
+export declare function verifierResultsToSignals(results: VerifierResultEntry[]): SignalEnvelope[];
+export declare function signalsToOutcomes(signals: SignalEnvelope[], dnaId?: string): ExecutionOutcome[];

package/dist/signals/index.js

@@ -0,0 +1,117 @@
+import { extractGeneFromReason } from "../evolution/trace-bridge.js";
+function toSignalEvidence(result) {
+    const payload = {
+        target: result.target,
+        evidence: result.evidence,
+        exit_code: result.exit_code,
+        artifact: result.artifact,
+        message: result.message,
+    };
+    return Object.values(payload).some((value) => value !== undefined) ? payload : undefined;
+}
+function normalizeExternalSignals(adapterName, payload) {
+    const items = Array.isArray(payload) ? payload : [payload];
+    return items.map((item, index) => {
+        const timestamp = item.timestamp ?? new Date().toISOString();
+        return {
+            id: item.id ?? `${adapterName}:${item.source}:${timestamp}:${index}`,
+            kind: "external",
+            status: item.status,
+            timestamp,
+            gene: item.gene,
+            source: item.source,
+            detail: item.detail ?? item.message ?? item.evidence,
+            adapter: adapterName,
+            evidence_payload: toSignalEvidence(item),
+        };
+    });
+}
+export const newapiSignalAdapter = {
+    name: "newapi",
+    adapt(payload) {
+        return normalizeExternalSignals("newapi", payload);
+    },
+};
+export const gatewaySignalAdapter = {
+    name: "gateway",
+    adapt(payload) {
+        return normalizeExternalSignals("gateway", payload);
+    },
+};
+export function adaptSignals(adapter, payload) {
+    return adapter.adapt(payload);
+}
+export function traceToSignals(traces) {
+    const signals = [];
+    for (const trace of traces) {
+        const gene = extractGeneFromReason(trace.reason);
+        if (!gene)
+            continue;
+        const status = trace.decision === "allow" ? "positive" : trace.decision === "warn" ? "neutral" : "negative";
+        signals.push({
+            id: trace.trace_id,
+            kind: "trace",
+            status,
+            timestamp: trace.timestamp,
+            gene,
+            source: trace.event,
+            detail: trace.reason,
+        });
+    }
+    return signals;
+}
+export function verifierResultsToSignals(results) {
+    const signals = [];
+    for (const result of results) {
+        const genes = result.source_genes && result.source_genes.length > 0 ? result.source_genes : [undefined];
+        const status = result.status === "pass" ? "positive" : result.severity === "warn" ? "neutral" : "negative";
+        for (const gene of genes) {
+            signals.push({
+                id: `${result.verifier_id}:${gene ?? "unknown"}:${result.timestamp}`,
+                kind: "verifier",
+                status,
+                timestamp: result.timestamp,
+                gene,
+                source: result.verifier_id,
+                detail: result.message ?? result.evidence,
+                evidence_payload: toSignalEvidence(result),
+            });
+        }
+    }
+    return signals;
+}
+export function signalsToOutcomes(signals, dnaId = "default") {
+    const feedbackByGene = new Map();
+    for (const signal of signals) {
+        if (!signal.gene)
+            continue;
+        const effect = signal.status === "positive"
+            ? "helped"
+            : signal.status === "negative"
+                ? "hindered"
+                : "neutral";
+        const existing = feedbackByGene.get(signal.gene) ?? [];
+        existing.push({
+            gene: signal.gene,
+            effect,
+            detail: signal.detail ?? signal.evidence_payload?.message ?? signal.source,
+        });
+        feedbackByGene.set(signal.gene, existing);
+    }
+    const outcomes = [];
+    for (const [gene, feedback] of feedbackByGene) {
+        const hindered = feedback.filter((item) => item.effect === "hindered").length;
+        const helped = feedback.filter((item) => item.effect === "helped").length;
+        outcomes.push({
+            id: `signal_${gene}_${feedback.length}`,
+            timestamp: new Date().toISOString(),
+            dna_id: dnaId,
+            action: `signals:${gene} helped=${helped} hindered=${hindered}`,
+            active_genes: [gene],
+            constraints_applied: [gene],
+            success: helped >= hindered,
+            constraint_feedback: feedback,
+        });
+    }
+    return outcomes;
+}

package/dist/templates/code-review-pipeline.dna.yaml

@@ -71,6 +71,10 @@ roles:
 
 contexts: {}
 
+verifier_policy:
+  allow_command_prefixes:
+    - npm test
+    - npx tsc --noEmit
 
 workflow:
   name: review-cycle