intentdna 1.7.4 → 1.8.0

package/dist/assets/catalog.d.ts

@@ -0,0 +1,101 @@
+import { type TemplateCatalogEntry } from "../templates/catalog.js";
+import { type WorkflowAssetEvidenceLink } from "./metadata.js";
+export interface WorkflowAssetRoleSummary {
+    id: string;
+    description?: string;
+    readScope: string[];
+    writeScope: string[];
+    allowTools: string[];
+    denyTools: string[];
+}
+export interface WorkflowAssetStepSummary {
+    id: string;
+    role: string;
+    description?: string;
+    dependsOn: string[];
+    consumes: number;
+    produces: number;
+    checkpoints: number;
+}
+export interface WorkflowAssetWorkflowSummary {
+    id: string;
+    name: string;
+    description?: string;
+    stepCount: number;
+    steps: WorkflowAssetStepSummary[];
+}
+export interface WorkflowAssetControllerSummary {
+    id: string;
+    name: string;
+    kind: string;
+    description?: string;
+    maxRounds?: number;
+    progressArtifactPath?: string;
+    diagnosisWorkflow?: string;
+    fixWorkflow?: string;
+}
+export interface WorkflowAssetCascadeSummary {
+    declared: boolean;
+    type?: string;
+    inherits: string[];
+    priority?: number;
+}
+export interface WorkflowAssetEvolutionSummary {
+    supported: boolean;
+    posture: "preview_supported" | "marker_seeded";
+    declaredMarkers: number;
+    markerIds: string[];
+    outcomeStore: string;
+    previewCommand: string;
+    mutatingCommand: string;
+    reviewMode: "preview_first";
+}
+export interface WorkflowAssetSummary {
+    id: string;
+    name: string;
+    dnaId?: string;
+    displayName?: string;
+    purpose?: string;
+    maturity: "draft" | "reviewed" | "adopted" | "unknown";
+    fit: string[];
+    notFor: string[];
+    inputs: string[];
+    outputs: string[];
+    lineage?: Record<string, unknown>;
+    source: TemplateCatalogEntry["source"];
+    path: string;
+    namespace?: string;
+    version?: string;
+    contentHash: string;
+    positioning?: string;
+    keywords: readonly string[];
+    roles: WorkflowAssetRoleSummary[];
+    workflows: WorkflowAssetWorkflowSummary[];
+    controllers: WorkflowAssetControllerSummary[];
+    cascade: WorkflowAssetCascadeSummary;
+    evolution: WorkflowAssetEvolutionSummary;
+    evidence: readonly WorkflowAssetEvidenceLink[];
+    status: WorkflowAssetStatus;
+}
+export type WorkflowAssetEvidencePosture = "dogfood_linked" | "reference_linked" | "unlinked";
+export type WorkflowAssetManagementStatus = "dogfood_ready" | "asset_ready" | "template_only";
+export interface WorkflowAssetStatus {
+    managementStatus: WorkflowAssetManagementStatus;
+    evidencePosture: WorkflowAssetEvidencePosture;
+    configurationPosture: "configured" | "available";
+    cascadePosture: "declared" | "standalone";
+    evolutionPosture: "preview_supported" | "marker_seeded";
+    configured: boolean;
+    configPaths: string[];
+    hasWorkflow: boolean;
+    hasController: boolean;
+    hasCascade: boolean;
+    hasEvidence: boolean;
+    notes: string[];
+}
+export declare function listWorkflowAssets(options?: {
+    projectDir?: string;
+}): Promise<WorkflowAssetSummary[]>;
+export declare function findWorkflowAsset(name: string, options?: {
+    projectDir?: string;
+}): Promise<WorkflowAssetSummary | undefined>;

package/dist/assets/catalog.js

@@ -0,0 +1,311 @@
+import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { detectDNAConfigs } from "../compiler/index.js";
+import { DEFAULT_EVOLUTION_CONFIG } from "../evolution/types.js";
+import { parseYAML } from "../schema/yaml-parser.js";
+import { listTemplateCatalog, findTemplateCatalogEntry } from "../templates/catalog.js";
+import { getWorkflowAssetMetadata } from "./metadata.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function assetMaturity(value) {
+    return value === "draft" || value === "reviewed" || value === "adopted" ? value : "unknown";
+}
+function asEvidenceKind(value) {
+    return value === "doc" || value === "dogfood" || value === "reference" ? value : undefined;
+}
+function recordEntries(value) {
+    if (!isRecord(value))
+        return [];
+    return Object.entries(value)
+        .filter((entry) => isRecord(entry[1]));
+}
+function templateEvidenceLinks(data) {
+    if (!Array.isArray(data.evidence))
+        return [];
+    const links = [];
+    for (const entry of data.evidence) {
+        if (!isRecord(entry))
+            continue;
+        const label = asString(entry.label);
+        const path = asString(entry.path);
+        const kind = asEvidenceKind(entry.kind);
+        if (!label || !path || !kind)
+            continue;
+        links.push({
+            label,
+            path,
+            kind,
+            description: asString(entry.description),
+        });
+    }
+    return links;
+}
+function mergeEvidenceLinks(links) {
+    const seen = new Set();
+    const merged = [];
+    for (const link of links) {
+        const key = `${link.kind}:${link.path}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(link);
+    }
+    return merged;
+}
+function workflowRecords(data) {
+    const workflows = recordEntries(data.workflows);
+    if (workflows.length > 0)
+        return workflows;
+    if (isRecord(data.workflow)) {
+        const name = asString(data.workflow.name) ?? "workflow";
+        return [[name, data.workflow]];
+    }
+    return [];
+}
+function roleSummaries(data) {
+    return recordEntries(data.roles).map(([id, role]) => {
+        const toolPermissions = isRecord(role.tool_permissions) ? role.tool_permissions : {};
+        const scope = isRecord(role.scope) ? role.scope : {};
+        return {
+            id,
+            description: asString(role.description),
+            readScope: asStringArray(scope.read),
+            writeScope: asStringArray(scope.write),
+            allowTools: asStringArray(toolPermissions.allow),
+            denyTools: asStringArray(toolPermissions.deny),
+        };
+    });
+}
+function stepSummaries(workflow) {
+    if (!Array.isArray(workflow.steps))
+        return [];
+    return workflow.steps
+        .filter((step) => isRecord(step))
+        .filter((step) => typeof step.id === "string" && typeof step.role === "string")
+        .map((step) => {
+        const handoff = isRecord(step.handoff) ? step.handoff : {};
+        return {
+            id: step.id,
+            role: step.role,
+            description: asString(step.description),
+            dependsOn: asStringArray(step.depends_on),
+            consumes: Array.isArray(handoff.consumes) ? handoff.consumes.length : 0,
+            produces: Array.isArray(handoff.produces) ? handoff.produces.length : 0,
+            checkpoints: Array.isArray(step.checkpoints) ? step.checkpoints.length : 0,
+        };
+    });
+}
+function workflowSummaries(data) {
+    return workflowRecords(data).map(([id, workflow]) => {
+        const steps = stepSummaries(workflow);
+        return {
+            id,
+            name: asString(workflow.name) ?? id,
+            description: asString(workflow.description),
+            stepCount: steps.length,
+            steps,
+        };
+    });
+}
+function controllerSummaries(data) {
+    return recordEntries(data.controllers).map(([id, controller]) => ({
+        id,
+        name: asString(controller.name) ?? id,
+        kind: asString(controller.kind) ?? "unknown",
+        description: asString(controller.description),
+        maxRounds: typeof controller.max_rounds === "number" ? controller.max_rounds : undefined,
+        progressArtifactPath: asString(controller.progress_artifact_path),
+        diagnosisWorkflow: asString(controller.diagnosis_workflow),
+        fixWorkflow: asString(controller.fix_workflow),
+    }));
+}
+function cascadeSummary(data) {
+    const cascade = isRecord(data.cascade) ? data.cascade : {};
+    const inherits = asStringArray(cascade.inherits);
+    const priority = typeof cascade.priority === "number" ? cascade.priority : undefined;
+    return {
+        declared: inherits.length > 0 || priority !== undefined,
+        type: asString(data.type),
+        inherits,
+        priority,
+    };
+}
+function evolutionSummary(dnaId, data) {
+    const epigenetic = isRecord(data.epigenetic) ? data.epigenetic : {};
+    const markers = Array.isArray(epigenetic.markers)
+        ? epigenetic.markers.filter((marker) => isRecord(marker))
+        : [];
+    const markerIds = markers
+        .map((marker) => asString(marker.id))
+        .filter((id) => id !== undefined);
+    return {
+        supported: true,
+        posture: markerIds.length > 0 ? "marker_seeded" : "preview_supported",
+        declaredMarkers: markerIds.length,
+        markerIds,
+        outcomeStore: DEFAULT_EVOLUTION_CONFIG.store_dir,
+        previewCommand: `dna evolve ${dnaId}`,
+        mutatingCommand: "dna sync --evolve",
+        reviewMode: "preview_first",
+    };
+}
+function templateIdForAsset(assetName) {
+    return `template_${assetName.replaceAll("-", "_")}`;
+}
+function relativeConfigPath(projectDir, configPath) {
+    const rel = relative(projectDir, configPath);
+    return rel.length > 0 && !rel.startsWith("..") ? rel : configPath;
+}
+function configMatchesAsset(config, template) {
+    if (!isRecord(config))
+        return false;
+    const sourceTemplate = asString(config._source_template);
+    if (sourceTemplate === template.name)
+        return true;
+    const namespace = asString(config.namespace);
+    if (namespace !== undefined && namespace === template.namespace)
+        return true;
+    const id = asString(config.id);
+    return id === templateIdForAsset(template.name);
+}
+async function loadProjectDNAConfigs(projectDir) {
+    const configPaths = await detectDNAConfigs(projectDir);
+    const configs = [];
+    for (const configPath of configPaths) {
+        try {
+            const raw = await readFile(configPath, "utf-8");
+            const parsed = configPath.endsWith(".json") ? JSON.parse(raw) : parseYAML(raw);
+            configs.push({ path: relativeConfigPath(projectDir, configPath), data: parsed });
+        }
+        catch {
+            // Asset status is read-only inventory; invalid configs are reported by validate/health.
+        }
+    }
+    return configs;
+}
+function configuredAssetPaths(template, projectConfigs) {
+    return projectConfigs
+        .filter((config) => configMatchesAsset(config.data, template))
+        .map((config) => config.path);
+}
+function assetStatus(params) {
+    const hasWorkflow = params.workflows.length > 0;
+    const hasController = params.controllers.length > 0;
+    const hasCascade = params.cascade.declared;
+    const hasEvidence = params.evidence.length > 0;
+    const configured = params.configPaths.length > 0;
+    const hasDogfood = params.evidence.some((evidence) => evidence.kind === "dogfood");
+    const evidencePosture = hasDogfood
+        ? "dogfood_linked"
+        : hasEvidence
+            ? "reference_linked"
+            : "unlinked";
+    const managementStatus = hasDogfood
+        ? "dogfood_ready"
+        : hasWorkflow || hasController
+            ? "asset_ready"
+            : "template_only";
+    const notes = [];
+    if (!hasWorkflow)
+        notes.push("No workflow definition found; this asset is role/policy-only until workflow steps are declared.");
+    if (!hasController)
+        notes.push("No controller definition found; execution loop status is not represented.");
+    if (!hasCascade)
+        notes.push("No cascade inheritance declared; this asset is standalone until an org/project layer is attached.");
+    if (!hasEvidence)
+        notes.push("No evidence/reference links registered for this asset.");
+    if (!configured)
+        notes.push("This workflow asset is available in the catalog but not configured in this project.");
+    if (hasDogfood)
+        notes.push("Dogfood evidence is linked as a human review surface; runtime truth still lives in source evidence files.");
+    if (params.evolution.reviewMode === "preview_first")
+        notes.push("Evolution is preview-first; marker mutation requires an explicit sync/evolve path and human review.");
+    return {
+        managementStatus,
+        evidencePosture,
+        configurationPosture: configured ? "configured" : "available",
+        cascadePosture: hasCascade ? "declared" : "standalone",
+        evolutionPosture: params.evolution.posture,
+        configured,
+        configPaths: params.configPaths,
+        hasWorkflow,
+        hasController,
+        hasCascade,
+        hasEvidence,
+        notes,
+    };
+}
+async function assetFromTemplate(template, projectConfigs) {
+    const content = await readFile(template.path, "utf-8");
+    const parsed = parseYAML(content);
+    if (!isRecord(parsed))
+        return null;
+    const roles = roleSummaries(parsed);
+    const workflows = workflowSummaries(parsed);
+    const controllers = controllerSummaries(parsed);
+    if (roles.length === 0 && workflows.length === 0 && controllers.length === 0)
+        return null;
+    const dnaId = asString(parsed.id) ?? templateIdForAsset(template.name);
+    const cascade = cascadeSummary(parsed);
+    const evolution = evolutionSummary(dnaId, parsed);
+    const metadata = getWorkflowAssetMetadata(template.name);
+    const evidence = mergeEvidenceLinks([
+        ...(metadata?.evidence ?? []),
+        ...templateEvidenceLinks(parsed),
+    ]);
+    const configPaths = configuredAssetPaths(template, projectConfigs);
+    return {
+        id: template.name,
+        name: template.name,
+        dnaId,
+        displayName: template.displayName,
+        purpose: asString(parsed.purpose),
+        maturity: assetMaturity(parsed.maturity),
+        fit: asStringArray(parsed.fit),
+        notFor: asStringArray(parsed.not_for),
+        inputs: asStringArray(parsed.inputs),
+        outputs: asStringArray(parsed.outputs),
+        lineage: isRecord(parsed.lineage) ? parsed.lineage : undefined,
+        source: template.source,
+        path: template.path,
+        namespace: template.namespace,
+        version: template.version,
+        contentHash: template.contentHash,
+        positioning: metadata?.positioning,
+        keywords: template.keywords,
+        roles,
+        workflows,
+        controllers,
+        cascade,
+        evolution,
+        evidence,
+        status: assetStatus({ workflows, controllers, cascade, evolution, evidence, configPaths }),
+    };
+}
+export async function listWorkflowAssets(options) {
+    const projectDir = options?.projectDir ?? process.cwd();
+    const templates = await listTemplateCatalog({ projectDir });
+    const projectConfigs = await loadProjectDNAConfigs(projectDir);
+    const assets = [];
+    for (const template of templates) {
+        const asset = await assetFromTemplate(template, projectConfigs);
+        if (asset)
+            assets.push(asset);
+    }
+    return assets;
+}
+export async function findWorkflowAsset(name, options) {
+    const projectDir = options?.projectDir ?? process.cwd();
+    const template = await findTemplateCatalogEntry(name, { projectDir });
+    if (!template)
+        return undefined;
+    const projectConfigs = await loadProjectDNAConfigs(projectDir);
+    return (await assetFromTemplate(template, projectConfigs)) ?? undefined;
+}

package/dist/assets/evidence.d.ts

@@ -0,0 +1,93 @@
+export type WorkflowAssetEvidenceVerdict = "PASS" | "CONTINUE" | "REQUEST_CHANGES" | "BLOCKED" | "UNKNOWN";
+export type WorkflowAssetRuntimeArtifactTarget = "claude_code";
+export type WorkflowAssetRuntimeArtifactKind = "agent_prompt" | "skill_entrypoint" | "skill_map";
+export type WorkflowAssetEvidenceCaptureFact = "command" | "result" | "retry" | "manual_intervention" | "blocker" | "handoff";
+export type WorkflowAssetEvidenceCaptureResult = "success" | "failure" | "blocked" | "skipped" | "unknown" | "unsupported";
+export interface WorkflowAssetEvidenceCapture {
+    eventId: string;
+    capturedAt: string;
+    source: string;
+    workflowAsset: string;
+    workflowId: string;
+    runId: string;
+    stepId: string;
+    fact: WorkflowAssetEvidenceCaptureFact;
+    summary: string;
+    command?: string;
+    result?: WorkflowAssetEvidenceCaptureResult;
+    evidenceRefs: Array<{
+        type: string;
+        ref: string;
+    }>;
+    path: string;
+}
+export interface WorkflowAssetRuntimeArtifact {
+    target: WorkflowAssetRuntimeArtifactTarget;
+    kind: WorkflowAssetRuntimeArtifactKind;
+    name: string;
+    path: string;
+    managed: boolean;
+    source?: string;
+    description?: string;
+    roles?: string[];
+    consumes?: number;
+    produces?: number;
+    bodyPath?: string;
+}
+export interface WorkflowAssetEvidenceModule {
+    module: string;
+    verdict: WorkflowAssetEvidenceVerdict;
+    review?: string;
+    moduleComplete: boolean;
+    round?: number;
+    runId?: string;
+    gitHead?: string;
+    lastFixCommit?: string;
+    fixedCount: number;
+    newRedCount: number;
+    blockedCount: number;
+    remainingCount: number;
+    remainingUnimplementedSkippedCount: number;
+    updatedAt?: string;
+    progressJsonPath: string;
+    progressMarkdownPath?: string;
+    evidencePaths: string[];
+    failureReason?: string;
+    nextRoundFocus?: string;
+}
+export interface WorkflowAssetEvidenceIndex {
+    asset: string;
+    projectPath: string;
+    progressDir: string;
+    sourceDescription?: string;
+    totals: {
+        modules: number;
+        pass: number;
+        continue: number;
+        requestChanges: number;
+        blocked: number;
+        unknown: number;
+        complete: number;
+        remaining: number;
+        remainingUnimplementedSkipped: number;
+        newRed: number;
+        runtimeArtifacts: number;
+        agentPrompts: number;
+        skillEntrypoints: number;
+        captureFacts: number;
+        captureBlocked: number;
+        captureFailures: number;
+        captureManualInterventions: number;
+        captureRetries: number;
+    };
+    modules: WorkflowAssetEvidenceModule[];
+    runtimeArtifacts: WorkflowAssetRuntimeArtifact[];
+    captureFacts: WorkflowAssetEvidenceCapture[];
+    warnings: string[];
+}
+export interface WorkflowAssetEvidenceOptions {
+    projectDir?: string;
+    dogfoodProjectPath?: string;
+    dogfoodProgressDir?: string;
+}
+export declare function buildWorkflowAssetEvidenceIndex(name: string, options?: WorkflowAssetEvidenceOptions): Promise<WorkflowAssetEvidenceIndex | undefined>;