intentdna 1.7.4 → 1.8.0

package/dist/organization/index.js

@@ -0,0 +1,413 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { parseYAML } from "../schema/yaml-parser.js";
+import { activeEvidenceFollowupReviewRoute, buildWorkflowAssetEvidenceIndex, listWorkflowAssets } from "../assets/index.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function slug(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "org";
+}
+function orgPath(projectDir) {
+    return join(projectDir, ".dna", "org.yaml");
+}
+function quote(value) {
+    return /^[A-Za-z0-9_./:-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function profileToYaml(profile) {
+    const lines = [
+        `schema_version: ${profile.schema_version}`,
+        "organization:",
+        `  id: ${quote(profile.organization.id)}`,
+        `  name: ${quote(profile.organization.name)}`,
+        "projects:",
+    ];
+    for (const project of profile.projects) {
+        lines.push(`  - id: ${quote(project.id)}`);
+        lines.push(`    name: ${quote(project.name)}`);
+        lines.push(`    path: ${quote(project.path)}`);
+        if (project.assets.length === 0) {
+            lines.push("    assets: []");
+        }
+        else {
+            lines.push("    assets:");
+            for (const asset of project.assets) {
+                lines.push(`      - asset: ${quote(asset.asset)}`);
+                lines.push(`        status: ${asset.status}`);
+            }
+        }
+        lines.push(`    sync_targets: [${project.syncTargets.map(quote).join(", ")}]`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function parseAssets(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((entry) => isRecord(entry))
+        .flatMap((entry) => {
+        const asset = stringValue(entry.asset);
+        if (!asset)
+            return [];
+        const status = entry.status === "active" || entry.status === "paused" ? entry.status : "planned";
+        return [{ asset, status }];
+    });
+}
+function normalizeProfile(parsed, projectDir) {
+    if (!isRecord(parsed) || !isRecord(parsed.organization))
+        return undefined;
+    const id = stringValue(parsed.organization.id);
+    const name = stringValue(parsed.organization.name);
+    if (!id || !name)
+        return undefined;
+    const projects = Array.isArray(parsed.projects) ? parsed.projects : [];
+    return {
+        schema_version: "intentdna.organization.v1",
+        organization: { id, name },
+        projects: projects
+            .filter((entry) => isRecord(entry))
+            .flatMap((entry) => {
+            const projectId = stringValue(entry.id);
+            const projectName = stringValue(entry.name);
+            if (!projectId || !projectName)
+                return [];
+            return [{
+                    id: projectId,
+                    name: projectName,
+                    path: stringValue(entry.path) ?? ".",
+                    assets: parseAssets(entry.assets),
+                    syncTargets: stringArray(entry.sync_targets),
+                }];
+        })
+            .concat(projects.length === 0 ? [{
+                id: "local-project",
+                name: "Local Project",
+                path: relative(projectDir, projectDir) || ".",
+                assets: [],
+                syncTargets: [],
+            }] : []),
+    };
+}
+export async function readOrganizationProfile(options) {
+    const projectDir = options?.projectDir ?? process.cwd();
+    const path = orgPath(projectDir);
+    try {
+        const parsed = parseYAML(await readFile(path, "utf-8"));
+        return { path, profile: normalizeProfile(parsed, projectDir) };
+    }
+    catch {
+        return { path };
+    }
+}
+export async function createOrganizationProfile(input) {
+    const projectDir = input.projectDir ?? process.cwd();
+    const organizationName = input.orgName.trim() || "IntentDNA Organization";
+    const projectName = input.projectName?.trim() || "Local Project";
+    const profile = {
+        schema_version: "intentdna.organization.v1",
+        organization: {
+            id: slug(organizationName),
+            name: organizationName,
+        },
+        projects: [{
+                id: slug(projectName),
+                name: projectName,
+                path: ".",
+                assets: input.asset ? [{ asset: input.asset, status: "planned" }] : [],
+                syncTargets: input.syncTarget ? [input.syncTarget] : [],
+            }],
+    };
+    const yaml = profileToYaml(profile);
+    const path = orgPath(projectDir);
+    await mkdir(join(projectDir, ".dna"), { recursive: true });
+    await writeFile(path, yaml, "utf-8");
+    return { path, profile, yaml };
+}
+export function isOrganizationAssetStatus(value) {
+    return value === "planned" || value === "active" || value === "paused";
+}
+function normalizeAssetStatus(value) {
+    return value && isOrganizationAssetStatus(value) ? value : "planned";
+}
+export async function bindOrganizationAsset(input) {
+    const projectDir = input.projectDir ?? process.cwd();
+    const { path, profile } = await readOrganizationProfile({ projectDir });
+    if (!profile)
+        return undefined;
+    const asset = input.asset.trim();
+    if (!asset)
+        return undefined;
+    const targetProject = input.project
+        ? profile.projects.find((project) => project.id === input.project || project.name === input.project)
+        : profile.projects[0];
+    if (!targetProject)
+        return undefined;
+    const status = normalizeAssetStatus(input.status);
+    const existing = targetProject.assets.find((binding) => binding.asset === asset);
+    const addedAsset = existing === undefined;
+    if (existing) {
+        existing.status = status;
+    }
+    else {
+        targetProject.assets.push({ asset, status });
+    }
+    const addedSyncTargets = [];
+    if (input.syncTarget && !targetProject.syncTargets.includes(input.syncTarget)) {
+        targetProject.syncTargets.push(input.syncTarget);
+        addedSyncTargets.push(input.syncTarget);
+    }
+    const yaml = profileToYaml(profile);
+    await mkdir(join(projectDir, ".dna"), { recursive: true });
+    await writeFile(path, yaml, "utf-8");
+    return {
+        path,
+        profile,
+        yaml,
+        projectId: targetProject.id,
+        asset,
+        status,
+        addedAsset,
+        addedSyncTargets,
+        guidance: {
+            bindingEffect: addedAsset
+                ? "Added this asset binding to the project; existing asset bindings were left unchanged."
+                : "Updated this asset binding in place; other project asset bindings were left unchanged.",
+            reviewCommand: "dna org review",
+            rolloutCommand: "dna org rollout",
+            replacementBoundary: "Binding an accepted version does not automatically pause, replace, configure, sync, or deploy older bindings; manager review and rollout decide the next safe action.",
+        },
+    };
+}
+function configuredAssetNames(assets) {
+    return new Set(assets.filter((asset) => asset.status.configured).map((asset) => asset.name));
+}
+function evidenceGate(index) {
+    if (!index)
+        return "unknown";
+    return index.totals.continue > 0 || index.totals.blocked > 0 || index.totals.requestChanges > 0 || index.totals.remaining > 0
+        ? "open"
+        : "clear";
+}
+function syncCommand(targets) {
+    return targets.some((target) => target === "codex" || target === "codex_cli") ? "dna sync --codex" : "dna sync";
+}
+function assetDiffReceiptPath(from, to) {
+    const slug = `${from}-to-${to}`.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "asset-diff";
+    return `.dna/reports/asset-diff-${slug}.json`;
+}
+function predecessorAsset(assetName, assets) {
+    const activeFollowupMatch = /^(.*)-active-followup$/.exec(assetName);
+    if (activeFollowupMatch)
+        return assets.find((asset) => asset.name === activeFollowupMatch[1]);
+    const versionMatch = /^(.*)-v\d+$/.exec(assetName);
+    if (versionMatch)
+        return assets.find((asset) => asset.name === versionMatch[1]);
+    return undefined;
+}
+function predecessorReviewEvidence(assetName, assets) {
+    const predecessor = predecessorAsset(assetName, assets);
+    if (!predecessor)
+        return [];
+    const receiptPathHint = assetDiffReceiptPath(predecessor.name, assetName);
+    return [{
+            mode: "local_asset_diff_review_evidence",
+            authority: "manager_review_handoff_only",
+            receiptCommand: `dna assets diff ${predecessor.name} ${assetName} --json > ${receiptPathHint}`,
+            receiptPathHint,
+            boundaries: [
+                "Predecessor diff evidence is a local manager review handoff only; it does not adopt, bind, rollout, sync, publish, or approve runtime behavior.",
+                "Manager acceptance of high-risk diffs remains a separate human decision before organization binding or publication readiness.",
+                "Runtime sync remains a later local dna action after adoption, organization binding, and rollout review.",
+            ],
+        }];
+}
+function successorReviewEvidence(assetName, assets) {
+    const followup = assets.find((asset) => asset.name === `${assetName}-active-followup`);
+    if (!followup)
+        return [];
+    const receiptPathHint = assetDiffReceiptPath(assetName, followup.name);
+    return [{
+            mode: "local_asset_diff_review_evidence",
+            authority: "manager_review_handoff_only",
+            receiptCommand: `dna assets diff ${assetName} ${followup.name} --json > ${receiptPathHint}`,
+            receiptPathHint,
+            boundaries: [
+                "Successor diff evidence is a local manager review handoff only; it does not replace the source asset or approve runtime behavior.",
+                "The follow-up draft remains inactive until a human reviews the diff, adopts the asset, updates organization binding, and reruns rollout.",
+                "Runtime sync remains a later local dna action after adoption, organization binding, and rollout review.",
+            ],
+        }];
+}
+function gateMetadata(asset, assetName, assets, options) {
+    return {
+        assetVersion: asset?.version,
+        contentHash: asset?.contentHash,
+        evidencePosture: asset?.status.evidencePosture ?? "unknown",
+        reviewRefs: asset?.evidence.map((ref) => ({
+            label: ref.label,
+            path: ref.path,
+            kind: ref.kind,
+            description: ref.description,
+        })) ?? [],
+        reviewEvidence: [
+            ...predecessorReviewEvidence(assetName, assets),
+            ...(options?.includeSuccessorReviewEvidence ? successorReviewEvidence(assetName, assets) : []),
+        ],
+        reviewCommand: `dna assets inspect ${assetName} --evidence`,
+    };
+}
+function assetGate(params) {
+    const gate = evidenceGate(params.evidence);
+    const metadata = gateMetadata(params.asset, params.binding.asset, params.assets, {
+        includeSuccessorReviewEvidence: gate === "open",
+    });
+    const configured = params.asset?.status.configured === true;
+    const configurationPosture = params.asset ? params.asset.status.configurationPosture : "missing";
+    if (!params.asset) {
+        return {
+            asset: params.binding.asset,
+            ...metadata,
+            bindingStatus: params.binding.status,
+            configured: false,
+            configurationPosture,
+            syncTargets: params.syncTargets,
+            evidenceGate: gate,
+            syncReady: false,
+            nextCommand: `dna assets list`,
+            reason: "The organization profile references an asset that is not in the local asset catalog.",
+        };
+    }
+    if (gate === "open") {
+        const followup = activeEvidenceFollowupReviewRoute(params.binding.asset, params.assets, params.evidence);
+        return {
+            asset: params.binding.asset,
+            ...metadata,
+            bindingStatus: params.binding.status,
+            configured,
+            configurationPosture,
+            syncTargets: params.syncTargets,
+            evidenceGate: gate,
+            syncReady: false,
+            nextCommand: followup.currentCommand,
+            reason: `Dogfood evidence still has active work. ${followup.reason}`,
+        };
+    }
+    if (!configured) {
+        return {
+            asset: params.binding.asset,
+            ...metadata,
+            bindingStatus: params.binding.status,
+            configured,
+            configurationPosture,
+            syncTargets: params.syncTargets,
+            evidenceGate: gate,
+            syncReady: false,
+            nextCommand: `dna init --template ${params.binding.asset}`,
+            reason: "The asset is declared in the organization profile but has not been configured in this project.",
+        };
+    }
+    if (params.binding.status !== "active") {
+        return {
+            asset: params.binding.asset,
+            ...metadata,
+            bindingStatus: params.binding.status,
+            configured,
+            configurationPosture,
+            syncTargets: params.syncTargets,
+            evidenceGate: gate,
+            syncReady: false,
+            nextCommand: `dna org bind --asset ${params.binding.asset} --status active --sync-target codex`,
+            reason: "The asset is configured but the organization binding is not active.",
+        };
+    }
+    if (params.syncTargets.length === 0) {
+        return {
+            asset: params.binding.asset,
+            ...metadata,
+            bindingStatus: params.binding.status,
+            configured,
+            configurationPosture,
+            syncTargets: params.syncTargets,
+            evidenceGate: gate,
+            syncReady: false,
+            nextCommand: `dna org bind --asset ${params.binding.asset} --status active --sync-target codex`,
+            reason: "The asset is active but no sync target is declared for the project.",
+        };
+    }
+    return {
+        asset: params.binding.asset,
+        ...metadata,
+        bindingStatus: params.binding.status,
+        configured,
+        configurationPosture,
+        syncTargets: params.syncTargets,
+        evidenceGate: gate,
+        syncReady: true,
+        nextCommand: syncCommand(params.syncTargets),
+        reason: "The asset is configured, active, evidence is not blocking, and at least one sync target is declared.",
+    };
+}
+export async function reviewOrganization(options) {
+    const projectDir = options?.projectDir ?? process.cwd();
+    const { path, profile } = await readOrganizationProfile({ projectDir });
+    if (!profile)
+        return undefined;
+    const assets = await listWorkflowAssets({ projectDir });
+    const configured = configuredAssetNames(assets);
+    const assetsByName = new Map(assets.map((asset) => [asset.name, asset]));
+    const evidence = await Promise.all(assets
+        .filter((asset) => profile.projects.some((project) => project.assets.some((binding) => binding.asset === asset.name)))
+        .map((asset) => buildWorkflowAssetEvidenceIndex(asset.name, { projectDir })));
+    const evidenceIndexes = evidence.filter((entry) => entry !== undefined);
+    const evidenceByAsset = new Map(evidenceIndexes.map((entry) => [entry.asset, entry]));
+    const projects = profile.projects.map((project) => {
+        const declared = project.assets.map((asset) => asset.asset);
+        const configuredAssets = declared.filter((asset) => configured.has(asset));
+        return {
+            id: project.id,
+            name: project.name,
+            path: project.path,
+            configuredAssets,
+            plannedAssets: declared,
+            missingAssets: declared.filter((asset) => !configured.has(asset)),
+            syncTargets: project.syncTargets,
+            assetGates: project.assets.map((binding) => assetGate({
+                binding,
+                asset: assetsByName.get(binding.asset),
+                assets,
+                evidence: evidenceByAsset.get(binding.asset),
+                syncTargets: project.syncTargets,
+            })),
+        };
+    });
+    const nextActions = [];
+    for (const project of projects) {
+        for (const gate of project.assetGates)
+            nextActions.push(`${project.name}/${gate.asset}: ${gate.nextCommand}`);
+        if (project.syncTargets.length === 0) {
+            nextActions.push(`Declare at least one sync target for project ${project.name}.`);
+        }
+    }
+    return {
+        profilePath: path,
+        profile,
+        totals: {
+            projects: projects.length,
+            declaredAssets: projects.reduce((sum, project) => sum + project.plannedAssets.length, 0),
+            configuredAssets: projects.reduce((sum, project) => sum + project.configuredAssets.length, 0),
+            missingAssets: projects.reduce((sum, project) => sum + project.missingAssets.length, 0),
+            syncTargets: projects.reduce((sum, project) => sum + project.syncTargets.length, 0),
+            dogfoodEvidenceModules: evidenceIndexes.reduce((sum, index) => sum + index.totals.modules, 0),
+            dogfoodEvidencePass: evidenceIndexes.reduce((sum, index) => sum + index.totals.pass, 0),
+            dogfoodEvidenceRemaining: evidenceIndexes.reduce((sum, index) => sum + index.totals.remaining, 0),
+        },
+        projects,
+        nextActions,
+    };
+}

package/dist/runtime/claude-sync-target.d.ts

@@ -0,0 +1,49 @@
+import type { ConstraintIR, RoleDef } from "../schema/types.js";
+import type { SyncOutputArtifactId } from "./output-artifact-registry.js";
+import { type CompiledIRFile } from "./plugin-adapter.js";
+import { type DNASettings, type HookEventKey } from "./settings-adapter.js";
+import type { AdapterCapabilityReport, CapabilityReportEntry, PlannedArtifact, SyncTargetPlan } from "./sync-target-plan.js";
+export type ClaudeSyncMode = "plugin" | "bin";
+export interface ClaudeCorePlannedArtifact extends PlannedArtifact {
+    artifact: SyncOutputArtifactId;
+}
+export type ClaudeCoreCapabilityReportEntry = CapabilityReportEntry;
+export type ClaudeCoreAdapterCapabilityReport = AdapterCapabilityReport & {
+    adapter: "claude_code";
+    runtime: "claude_code";
+};
+export interface ClaudeSettingsHookRegistration {
+    path: string;
+    enabledEvents: HookEventKey[];
+    settings: DNASettings;
+}
+export interface ClaudeCoreSyncTargetPlanOptions {
+    projectDir: string;
+    ir: ConstraintIR;
+    roles?: Record<string, RoleDef>;
+    mode: ClaudeSyncMode;
+    settingsPath?: string;
+}
+export interface ClaudeCoreSyncTargetPlan extends SyncTargetPlan {
+    target: "claude_code";
+    compiledIR: CompiledIRFile;
+    compiledIRPath: string;
+    legacyHooksDir: string;
+    mcpConfigPath: string;
+    settingsHookRegistration?: ClaudeSettingsHookRegistration;
+    pluginSkipsSettings: boolean;
+    plannedArtifacts: ClaudeCorePlannedArtifact[];
+    capabilityReport: ClaudeCoreAdapterCapabilityReport;
+}
+export interface ExecuteClaudeCoreSyncTargetPlanResult {
+    messages: string[];
+    removedLegacyHooks: string[];
+}
+/**
+ * Remove legacy bash hook scripts written by previous Intent DNA versions.
+ * Only removes files that contain the sentinel comment.
+ */
+export declare function removeLegacyBashHooks(hooksDir: string): Promise<string[]>;
+export declare function createClaudeCoreSyncTargetPlan(options: ClaudeCoreSyncTargetPlanOptions): ClaudeCoreSyncTargetPlan;
+export declare function executeClaudeCoreSyncTargetPlan(plan: ClaudeCoreSyncTargetPlan, projectDir: string): Promise<ExecuteClaudeCoreSyncTargetPlanResult>;
+export declare function formatClaudeCoreSyncTargetPlanDryRun(plan: ClaudeCoreSyncTargetPlan): string;