intentdna 1.7.4 → 1.8.0

package/dist/templates/marketplace.js

@@ -0,0 +1,502 @@
+import { readFile } from "node:fs/promises";
+import { parseYAML } from "../schema/yaml-parser.js";
+import { getWorkflowAssetMetadata } from "../assets/metadata.js";
+import { listTemplateCatalog } from "./catalog.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function recordSize(value) {
+    return isRecord(value) ? Object.keys(value).length : 0;
+}
+function hasWorkflow(data) {
+    return recordSize(data.workflows) > 0 || isRecord(data.workflow);
+}
+function hasControllers(data) {
+    return recordSize(data.controllers) > 0;
+}
+function hasRoles(data) {
+    return recordSize(data.roles) > 0;
+}
+function templateLabel(template) {
+    return template.displayName ?? template.name
+        .split("-")
+        .map((part) => part.length <= 3 ? part.toUpperCase() : `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+        .join(" ");
+}
+function productPurpose(template, data) {
+    const text = `${template.name} ${template.displayName ?? ""} ${template.keywords.join(" ")}`.toLowerCase();
+    const label = templateLabel(template);
+    if (text.includes("flutter") && (text.includes("rewrite") || text.includes("migration"))) {
+        return "Govern high-risk Flutter rewrites with behavior truth, diagnosis review, bounded fixes, and verification evidence.";
+    }
+    if (text.includes("review")) {
+        return "Turn code, workflow, or evidence review into a repeatable route with explicit findings and follow-up gates.";
+    }
+    if (text.includes("release") || text.includes("deploy")) {
+        return "Gate public release work with deploy planning, verification commands, and reviewable release evidence.";
+    }
+    if (text.includes("debug") || text.includes("root-cause") || text.includes("incident")) {
+        return "Structure incident or debugging work around hypotheses, evidence, root cause, and regression checks.";
+    }
+    if (text.includes("cleanup") || text.includes("refactor")) {
+        return "Clean up or refactor code while preserving behavior, limiting scope, and recording verification.";
+    }
+    if (text.includes("tdd") || text.includes("test") || text.includes("qa")) {
+        return "Make test or QA work repeatable by defining evidence, verification commands, and acceptance gates.";
+    }
+    if (text.includes("security") || text.includes("secure") || text.includes("enterprise")) {
+        return "Apply security or enterprise guardrails to local AI work without moving runtime authority online.";
+    }
+    if (text.includes("research") || text.includes("brainstorm")) {
+        return "Coordinate research or ideation into evidence-backed options before implementation.";
+    }
+    if (text.includes("documentation") || text.includes("doc")) {
+        return "Produce maintainable documentation, handoff material, or project knowledge with reviewable outputs.";
+    }
+    if (hasWorkflow(data) || hasRoles(data)) {
+        return `Package ${label} as a governed workflow asset with roles, steps, boundaries, and local sync outputs.`;
+    }
+    return `Package ${label} as local DNA constraints and guidance for repeatable AI-assisted work.`;
+}
+function hasAnyTerm(text, terms) {
+    return terms.some((term) => new RegExp(`(^|[^a-z0-9])${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([^a-z0-9]|$)`).test(text));
+}
+function productFit(template, data) {
+    const yamlName = typeof data.name === "string" ? data.name : "";
+    const text = `${template.name} ${template.displayName ?? ""} ${yamlName} ${template.keywords.join(" ")}`.toLowerCase();
+    const fit = new Set();
+    if (hasAnyTerm(text, ["api", "backend"]))
+        fit.add("Backend/API teams that need consistent implementation and review boundaries");
+    if (hasAnyTerm(text, ["frontend", "ui", "visual"]))
+        fit.add("Frontend teams shipping user-facing changes with visual and accessibility checks");
+    if (hasAnyTerm(text, ["mobile", "ios", "android"]))
+        fit.add("Mobile teams coordinating app changes across platform-specific constraints");
+    if (hasAnyTerm(text, ["documentation", "doc", "docs", "readme", "wiki"]))
+        fit.add("Teams turning implementation knowledge into maintainable docs and handoff material");
+    if (hasAnyTerm(text, ["requirements"]))
+        fit.add("Teams that need requirements clarified before implementation begins");
+    if (hasAnyTerm(text, ["research", "brainstorm", "ideation"]))
+        fit.add("Teams exploring options before committing to an implementation path");
+    if (hasAnyTerm(text, ["performance", "profiling", "benchmark", "latency"]))
+        fit.add("Teams investigating latency, throughput, or resource-use regressions");
+    if (hasAnyTerm(text, ["debug", "debugging", "troubleshoot", "root-cause", "root cause", "bug fix"]))
+        fit.add("Teams debugging failures through reproduction, hypotheses, evidence, and regression checks");
+    if (hasAnyTerm(text, ["cleanup", "clean up"]))
+        fit.add("Teams cleaning code by smell type while preserving current behavior and tests");
+    if (hasAnyTerm(text, ["incident", "hotfix", "outage", "postmortem"]))
+        fit.add("Production support teams handling incidents, hotfixes, and follow-up evidence");
+    if (hasAnyTerm(text, ["monorepo", "workspace", "packages"]))
+        fit.add("Monorepo teams coordinating package boundaries, ownership, and workspace-wide changes");
+    if (hasAnyTerm(text, ["branch", "pr", "pull", "request"]))
+        fit.add("Teams preparing branch closure, pull requests, or review-ready handoffs");
+    if (hasAnyTerm(text, ["persistent", "yolo"]))
+        fit.add("Operators who need faster autonomous execution while preserving explicit guardrails");
+    if (text.includes("flutter"))
+        fit.add("Flutter or mobile migration teams");
+    if (text.includes("rewrite") || text.includes("migration") || text.includes("refactor"))
+        fit.add("High-risk behavior-preserving code changes");
+    if (text.includes("review"))
+        fit.add("Teams that need independent review before adoption or rollout");
+    if (text.includes("release") || text.includes("deploy"))
+        fit.add("Public web or release workflows that require deployment evidence");
+    if (text.includes("security") || text.includes("secure") || text.includes("enterprise"))
+        fit.add("Security-sensitive repositories with strict tool and secret boundaries");
+    if (text.includes("qa") || text.includes("test") || text.includes("verification"))
+        fit.add("Workflows where pass/fail evidence must be explicit");
+    if (text.includes("multi-agent") || text.includes("subagent") || text.includes("handoff"))
+        fit.add("Multi-agent work that needs owned handoff artifacts");
+    if (hasControllers(data))
+        fit.add("Long-running workflows with stop conditions and progress evidence");
+    if (fit.size === 0)
+        fit.add("Teams turning a repeated AI work method into a reusable local workflow asset");
+    return [...fit].slice(0, 4);
+}
+function productInputs(data) {
+    const variables = isRecord(data.variables) ? data.variables : {};
+    const inputs = Object.entries(variables).flatMap(([key, value]) => {
+        if (!isRecord(value))
+            return [`${key}: project-specific value`];
+        const description = typeof value.description === "string" ? value.description : "project-specific value";
+        const defaultValue = typeof value.default === "string" ? ` (default: ${value.default})` : "";
+        return [`${key}: ${description}${defaultValue}`];
+    });
+    if (inputs.length > 0)
+        return inputs.slice(0, 6);
+    return ["Project context and the selected local workflow goal"];
+}
+function collectProducedArtifacts(value, outputs) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectProducedArtifacts(item, outputs);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    if (typeof value.path === "string")
+        outputs.add(value.path);
+    for (const child of Object.values(value))
+        collectProducedArtifacts(child, outputs);
+}
+function productOutputs(data) {
+    const outputs = new Set();
+    if (hasWorkflow(data))
+        outputs.add("Workflow steps and handoff contracts for local harness execution");
+    if (hasRoles(data))
+        outputs.add("Role instructions and tool/scope boundaries");
+    if (hasControllers(data))
+        outputs.add("Controller stop conditions and progress evidence");
+    outputs.add("Compiled IR and local sync artifacts");
+    collectProducedArtifacts(data.workflows, outputs);
+    return [...outputs].slice(0, 8);
+}
+function evidencePosture(examples) {
+    if (examples.some((example) => example.kind === "dogfood"))
+        return "dogfood";
+    return examples.length > 0 ? "example" : "explicit_gap";
+}
+function templateEvidenceGap(templateName, examples) {
+    if (examples.length > 0) {
+        return {
+            status: "covered_by_examples",
+            summary: "This workflow asset has attached evidence examples for marketplace selection and local review.",
+            nextCommands: [
+                `dna assets inspect ${templateName} --evidence`,
+                `dna assets adoption ${templateName}`,
+            ],
+            acceptanceCriteria: [
+                "Evidence examples are inspectable from the local CLI.",
+                "Adoption review can explain whether the asset is ready for local bind, rollout, and sync.",
+            ],
+            notEvidence: [
+                "Attached examples do not prove this asset is installed in the user's project.",
+                "Attached examples do not grant runtime authority or org-private visibility.",
+            ],
+        };
+    }
+    return {
+        status: "needs_local_evidence",
+        summary: "No public example or dogfood evidence is attached yet; run the asset locally before using it as adoption proof.",
+        nextCommands: [
+            `dna templates show ${templateName}`,
+            `dna init --template ${templateName}`,
+            "dna sync --dry-run",
+            "dna sync",
+            "dna report package --json",
+            "dna report sign --package .dna/reports/latest-report-package.json --output .dna/reports/ingest/local-envelope.json --json",
+            "dna report verify .dna/reports/ingest/local-envelope.json --json",
+        ],
+        acceptanceCriteria: [
+            "A local report package exists for a real run of this asset.",
+            "The signed local envelope verifies with runtime_authority=false.",
+            "The evidence can be attached to a later template review or adoption packet without exposing secrets.",
+        ],
+        notEvidence: [
+            "Catalog metadata alone is not adoption evidence.",
+            "Browser-local selection is not trusted evidence.",
+            "A dry-run install plan is not workflow execution.",
+            "Online projection is not runtime approval or org-private publication.",
+        ],
+    };
+}
+function assetMaturity(visibility, posture, data) {
+    if (visibility === "internal_ready")
+        return "internal_ready";
+    if (posture === "dogfood")
+        return "dogfood";
+    if (hasWorkflow(data) || hasControllers(data) || hasRoles(data))
+        return "reviewed";
+    return "draft";
+}
+function lifecycleGuide(visibility, maturity, templateName) {
+    if (visibility === "personal") {
+        return {
+            state: "personal",
+            meaning: "Project-local workflow asset or draft visible from the local template catalog.",
+            availableNow: [
+                "Inspect with dna templates show/manage.",
+                "Adapt through a reviewable draft instead of mutating the original asset.",
+                "Install and sync locally after explicit review.",
+            ],
+            nextStep: `Run dna assets adoption ${templateName}, then bind it locally only if the review passes.`,
+            notAllowedToImply: [
+                "organization approval",
+                "durable cloud storage",
+                "team-wide visibility",
+                "runtime execution",
+                "runtime authority",
+            ],
+        };
+    }
+    if (visibility === "internal_ready") {
+        return {
+            state: "internal_ready",
+            meaning: "Adoption candidate that is structured enough for local organization review.",
+            availableNow: [
+                "Review evidence and maturity locally.",
+                "Bind to a local organization/project profile after manager review.",
+                "Prepare a SaaS org-private publication handoff only after auth, RLS, scoped token, storage, and audit gates pass.",
+            ],
+            nextStep: `Run dna org bind --asset ${templateName} --status active --sync-target codex, then dna org rollout.`,
+            notAllowedToImply: [
+                "org_private SaaS catalog visibility",
+                "authenticated organization membership",
+                "publish/unpublish audit",
+                "runtime authority",
+            ],
+        };
+    }
+    return {
+        state: "public",
+        meaning: maturity === "dogfood"
+            ? "Built-in public workflow asset with dogfood or example evidence for selection and local install."
+            : "Built-in public workflow asset available for browsing, comparison, and local install.",
+        availableNow: [
+            "Browse and compare in the marketplace catalog.",
+            "Initialize with dna init.",
+            "Preview sync before writing harness artifacts.",
+            "Run the workflow only in the local harness after sync.",
+        ],
+        nextStep: `Run dna templates show ${templateName}, then dna init --template ${templateName}.`,
+        notAllowedToImply: [
+            "automatic fit for every project",
+            "installed state",
+            "approval",
+            "workflow execution",
+            "runtime authority",
+        ],
+    };
+}
+function templateEvidenceExamples(templateName, data) {
+    const metadata = getWorkflowAssetMetadata(templateName);
+    const examples = [];
+    for (const link of metadata?.evidence ?? []) {
+        examples.push({
+            label: link.label,
+            path: link.path,
+            kind: link.kind,
+            description: link.description,
+        });
+    }
+    if (Array.isArray(data.evidence)) {
+        for (const entry of data.evidence) {
+            if (!isRecord(entry))
+                continue;
+            if (typeof entry.label !== "string" || typeof entry.path !== "string")
+                continue;
+            if (entry.kind !== "doc" && entry.kind !== "dogfood" && entry.kind !== "reference")
+                continue;
+            examples.push({
+                label: entry.label,
+                path: entry.path,
+                kind: entry.kind,
+                description: typeof entry.description === "string" ? entry.description : undefined,
+            });
+        }
+    }
+    const seen = new Set();
+    return examples.filter((example) => {
+        const key = `${example.kind}:${example.path}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    }).slice(0, 4);
+}
+function supportedHarnesses(data) {
+    const harnesses = ["claude_code"];
+    if (hasWorkflow(data) || hasControllers(data) || hasRoles(data))
+        harnesses.push("codex_cli");
+    return harnesses;
+}
+function syncSurfaces(data) {
+    const surfaces = ["markdown_injection", "compiled_ir", "claude_mcp"];
+    if (hasRoles(data))
+        surfaces.push("claude_agents");
+    if (hasWorkflow(data) || hasControllers(data)) {
+        surfaces.push("claude_skills", "workflow_scripts", "codex_adapter");
+    }
+    if (recordSize(data.genes) > 0 || hasWorkflow(data) || hasControllers(data))
+        surfaces.push("claude_settings_hooks");
+    return [...new Set(surfaces)];
+}
+function templateSyncCommands(data) {
+    const commands = ["dna sync --dry-run", "dna sync"];
+    if (supportedHarnesses(data).includes("codex_cli")) {
+        commands.push("dna sync --codex --dry-run", "dna sync --codex");
+    }
+    return [...new Set(commands)];
+}
+function templateReviewRoute(templateName) {
+    return {
+        inspectCommand: `dna assets inspect ${templateName} --evidence`,
+        adoptionCommand: `dna assets adoption ${templateName}`,
+        orgBindCommand: `dna org bind --asset ${templateName} --status active --sync-target codex`,
+        orgReviewCommand: "dna org review",
+        rolloutCommand: "dna org rollout",
+        boundary: "Review, adoption, org binding, and rollout are local dna routes; marketplace metadata does not create org_private visibility or runtime authority.",
+    };
+}
+function templateAssetRelations(templateName) {
+    if (templateName === "flutter-rewrite") {
+        return [
+            {
+                relatedTemplate: "flutter-rewrite-fix-review-loop",
+                relation: "reusable_loop",
+                purpose: "The fix loop is the reusable inner diagnosis-backed fix/review/verify loop inside the full Flutter rewrite workflow.",
+                preserves: [
+                    "flutter-rewrite remains the complete rewrite workflow asset.",
+                    "The fix loop remains a separate reusable asset for bounded fix rounds.",
+                    "Using the loop does not remove scanner, test writer, analyzer, diagnosis review, or PASS gates from flutter-rewrite.",
+                ],
+                nextCommands: [
+                    "dna templates show flutter-rewrite-fix-review-loop",
+                    "dna assets inspect flutter-rewrite --evidence",
+                ],
+                notAllowedToImply: [
+                    "source template deletion",
+                    "source template replacement",
+                    "automatic adoption",
+                    "workflow execution",
+                    "runtime authority",
+                ],
+            },
+            {
+                relatedTemplate: "flutter-rewrite-active-followup",
+                relation: "followup_draft",
+                purpose: "The active follow-up is a reviewable unfinished-work draft for dogfood evidence, not a replacement for the original workflow.",
+                preserves: [
+                    "flutter-rewrite remains the original workflow asset.",
+                    "flutter-rewrite-fix-review-loop remains the reusable fix loop asset.",
+                    "The follow-up draft requires diff, adoption, organization bind, and rollout review before local use.",
+                ],
+                nextCommands: [
+                    "dna assets diff flutter-rewrite flutter-rewrite-active-followup",
+                    "dna assets adoption flutter-rewrite-active-followup",
+                    "dna org bind --asset flutter-rewrite-active-followup --status active --sync-target codex",
+                ],
+                notAllowedToImply: [
+                    "source template deletion",
+                    "source template replacement",
+                    "automatic adoption",
+                    "org_private visibility",
+                    "workflow execution",
+                    "runtime authority",
+                ],
+            },
+        ];
+    }
+    if (templateName === "flutter-rewrite-fix-review-loop") {
+        return [
+            {
+                relatedTemplate: "flutter-rewrite",
+                relation: "main_workflow",
+                purpose: "This asset extracts the bounded fix/review/verify loop from the full Flutter rewrite workflow so teams can reuse the loop without starting the whole rewrite route.",
+                preserves: [
+                    "flutter-rewrite remains the full behavior-preserving rewrite workflow.",
+                    "This loop does not replace behavior documentation, diagnosis approval, or final PASS criteria.",
+                ],
+                nextCommands: [
+                    "dna templates show flutter-rewrite",
+                    "dna assets inspect flutter-rewrite-fix-review-loop --evidence",
+                ],
+                notAllowedToImply: [
+                    "full rewrite workflow deletion",
+                    "automatic PASS",
+                    "workflow execution",
+                    "runtime authority",
+                ],
+            },
+        ];
+    }
+    if (templateName === "flutter-rewrite-active-followup") {
+        return [
+            {
+                relatedTemplate: "flutter-rewrite",
+                relation: "followup_draft",
+                purpose: "This draft records unfinished dogfood follow-up work for review before a manager accepts, binds, or rolls it out locally.",
+                preserves: [
+                    "flutter-rewrite remains the original workflow asset.",
+                    "The reusable fix loop remains separate and available.",
+                    "This draft is not installed until local review and adoption gates pass.",
+                ],
+                nextCommands: [
+                    "dna assets diff flutter-rewrite flutter-rewrite-active-followup",
+                    "dna assets adoption flutter-rewrite-active-followup",
+                    "dna org rollout",
+                ],
+                notAllowedToImply: [
+                    "source template deletion",
+                    "source template replacement",
+                    "automatic adoption",
+                    "org_private visibility",
+                    "workflow execution",
+                    "runtime authority",
+                ],
+            },
+        ];
+    }
+    return [];
+}
+export async function getTemplateMarketplaceMetadata(template, options) {
+    const content = options?.content ?? await readFile(template.path, "utf-8");
+    const parsed = parseYAML(content);
+    const data = isRecord(parsed) ? parsed : {};
+    const visibility = template.source === "project" ? "personal" : "public";
+    const examples = templateEvidenceExamples(template.name, data);
+    const posture = evidencePosture(examples);
+    const maturity = assetMaturity(visibility, posture, data);
+    const syncCommands = templateSyncCommands(data);
+    return {
+        visibility,
+        purpose: productPurpose(template, data),
+        fit: productFit(template, data),
+        inputs: productInputs(data),
+        outputs: productOutputs(data),
+        assetRelations: templateAssetRelations(template.name),
+        evidencePosture: posture,
+        evidenceGap: templateEvidenceGap(template.name, examples),
+        maturity,
+        lifecycleGuide: lifecycleGuide(visibility, maturity, template.name),
+        supportedHarnesses: supportedHarnesses(data),
+        requiredDnaVersion: ">=1.7.5",
+        syncSurfaces: syncSurfaces(data),
+        evidenceExamples: examples,
+        install: {
+            command: `dna init --template ${template.name}`,
+            syncCommands,
+        },
+        review: templateReviewRoute(template.name),
+    };
+}
+export async function buildTemplateMarketplaceCatalog(options) {
+    const templates = await listTemplateCatalog({ projectDir: options?.projectDir });
+    const items = await Promise.all(templates.map(async (template) => ({
+        name: template.name,
+        displayName: template.displayName,
+        namespace: template.namespace,
+        version: template.version,
+        source: template.source,
+        contentHash: template.contentHash,
+        keywords: template.keywords,
+        marketplace: await getTemplateMarketplaceMetadata(template),
+    })));
+    return {
+        schema_version: "intentdna.template_marketplace_catalog.v1",
+        generated_at: options?.generatedAt ?? new Date().toISOString(),
+        totals: {
+            templates: items.length,
+            public: items.filter((item) => item.marketplace.visibility === "public").length,
+            personal: items.filter((item) => item.marketplace.visibility === "personal").length,
+            internal_ready: items.filter((item) => item.marketplace.visibility === "internal_ready").length,
+            claude_code: items.filter((item) => item.marketplace.supportedHarnesses.includes("claude_code")).length,
+            codex_cli: items.filter((item) => item.marketplace.supportedHarnesses.includes("codex_cli")).length,
+        },
+        items,
+        boundaries: [
+            "Template marketplace catalog is asset distribution metadata, not workflow runtime.",
+            "Templates install into local projects through dna init and dna sync; Claude Code/Codex execute the workflow after sync.",
+            "Public, personal, and internal_ready are asset lifecycle states; org_private requires SaaS auth, RLS, storage, permissions, and audit.",
+            "External workflow references may inform drafts, but this catalog contains IntentDNA templates only.",
+        ],
+    };
+}

package/dist/templates/metadata.d.ts

@@ -1,6 +1,31 @@
 export interface TemplateMatchMetadata {
     name: string;
     keywords: readonly string[];
+    intent_signals?: readonly TemplateIntentSignal[];
 }
+export interface TemplateIntentSignal {
+    keywords: readonly string[];
+    signal: string;
+    weight: number;
+}
+export declare const WORKFLOW_ASSET_IDS: {
+    readonly default: "flutter-rewrite";
+    readonly behaviorLock: "flutter-behavior-lock";
+    readonly refactoringRescue: "flutter-refactoring-rescue";
+    readonly rewriteDiagnosisReview: "flutter-rewrite-diagnosis-review";
+    readonly rewriteFixReviewLoop: "flutter-rewrite-fix-review-loop";
+    readonly rewriteActiveFollowup: "flutter-rewrite-active-followup";
+    readonly author: "workflow-author";
+    readonly blockedScopeTriage: "workflow-blocked-scope-triage";
+    readonly crossBoundaryResourceApproval: "workflow-cross-boundary-resource-approval";
+    readonly verificationCommandRouting: "workflow-verification-command-routing";
+};
+export declare const WORKFLOW_SUGGESTION_IDS: {
+    readonly activeFollowup: "template-active-followup";
+    readonly blockedTriage: "template-blocked-triage";
+    readonly c5CapturedRunFacts: "c5-captured-run-facts";
+    readonly crossBoundaryResourceApproval: "template-cross-boundary-resource-approval";
+    readonly modelVerifier: "template-model-verifier";
+};
 export declare const TEMPLATE_MATCH_METADATA: readonly TemplateMatchMetadata[];
 export declare function getTemplateMatchMetadata(name: string): TemplateMatchMetadata | undefined;