intentdna 1.7.4 → 1.8.0

package/dist/cli/commands/init.d.ts

@@ -10,9 +10,21 @@ export interface InitOptions {
     template?: string;
     register?: string;
     upgrade?: string | boolean;
+    projectDir?: string;
+    json?: boolean;
+}
+export interface CreateConfigFromTemplateResult {
+    path: string;
+    template: string;
+    namespace?: string;
 }
 /**
  * Calculate SHA256 hash of template content (truncated to 16 hex chars).
  */
 export declare function calculateTemplateHash(content: string): string;
+export declare function createConfigFromTemplate(input: {
+    template: string;
+    output?: string;
+    projectDir?: string;
+}): Promise<CreateConfigFromTemplateResult>;
 export declare function runInit(opts: InitOptions): Promise<number>;

package/dist/cli/commands/init.js

@@ -3,32 +3,24 @@
  *
  * Interactive wizard to generate a new DNA file.
  */
-import { writeFile, readFile, readdir, mkdir, copyFile, access } from "node:fs/promises";
-import { resolve, dirname, basename } from "node:path";
-import { fileURLToPath } from "node:url";
+import { writeFile, readFile, readdir, mkdir, copyFile } from "node:fs/promises";
+import { resolve, basename } from "node:path";
 import { parseYAML } from "../../schema/yaml-parser.js";
 import { listTemplateCatalog, calculateTemplateContentHash } from "../../templates/catalog.js";
 import { sanitizeTemplateName } from "../util/version.js";
 import { validateDNA } from "../../schema/validate.js";
 import { askString, askChoice, askNumber, askYesNo, closePrompt } from "../util/prompt.js";
-const TEMPLATES_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "templates");
 const PROJECT_TEMPLATES_DIR = ".dna/templates";
 const MULTI_CONFIG_DIR = ".dna/configs";
-async function dirExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function listTemplates() {
-    const entries = await listTemplateCatalog();
+async function listTemplates(projectDir = process.cwd()) {
+    const entries = await listTemplateCatalog({ projectDir });
     return entries.map((entry) => ({
         name: entry.name,
+        path: entry.path,
         namespace: entry.namespace,
         displayName: entry.displayName,
+        version: entry.version,
+        contentHash: entry.contentHash,
         source: entry.source,
     }));
 }
@@ -55,13 +47,14 @@ function injectSourceTemplate(content, templateName, templateVersion, templateHa
 /**
  * Check namespace collision against existing configs in .dna/configs/.
  */
-async function checkNamespaceAgainstExisting(namespace, templateName) {
+async function checkNamespaceAgainstExisting(namespace, templateName, projectDir = process.cwd()) {
     if (!namespace)
         return;
     try {
-        const files = await readdir(MULTI_CONFIG_DIR);
+        const configDir = resolve(projectDir, MULTI_CONFIG_DIR);
+        const files = await readdir(configDir);
         for (const f of files.filter(f => f.endsWith(".yaml") || f.endsWith(".yml"))) {
-            const content = await readFile(resolve(MULTI_CONFIG_DIR, f), "utf-8");
+            const content = await readFile(resolve(configDir, f), "utf-8");
             const data = parseYAML(content);
             const existingNs = typeof data.namespace === "string" ? data.namespace : undefined;
             if (existingNs === namespace && f !== `${templateName}.yaml`) {
@@ -77,7 +70,7 @@ async function checkNamespaceAgainstExisting(namespace, templateName) {
 }
 /**
  * Infer template name from a DNA config's id field.
- * "template_flutter_rewrite" → "flutter-rewrite"
+ * For example, a template id becomes its dashed template name.
  */
 function inferTemplateName(id) {
     if (!id.startsWith("template_"))
@@ -88,14 +81,14 @@ function inferTemplateName(id) {
  * Auto-detect DNA config file(s) for upgrade.
  * Priority: .dna/configs/*.yaml (multi-config) > legacy single-config
  */
-async function autoDetectConfigsForUpgrade() {
+async function autoDetectConfigsForUpgrade(projectDir = process.cwd()) {
     const { detectDNAConfigs } = await import("../../compiler/index.js");
-    return detectDNAConfigs(process.cwd());
+    return detectDNAConfigs(projectDir);
 }
 /**
  * Upgrade config from a newer template version while preserving user-filled variables.
  */
-async function upgradeConfig(configPath, templateName) {
+async function upgradeConfig(configPath, templateName, projectDir = process.cwd()) {
     // 1. Read current config
     const currentContent = await readFile(configPath, "utf-8");
     const current = parseYAML(currentContent);
@@ -110,16 +103,14 @@ async function upgradeConfig(configPath, templateName) {
         }
     }
     // 3. Load new template
-    const templates = await listTemplates();
+    const templates = await listTemplates(projectDir);
     const found = templates.find((t) => t.name === templateName);
     if (!found) {
         process.stderr.write(`Unknown template: ${templateName}\n`);
         process.stderr.write(`Available: ${templates.map((t) => t.name).join(", ")}\n`);
         return 2;
     }
-    const srcDir = found.source === "project" ? PROJECT_TEMPLATES_DIR : TEMPLATES_DIR;
-    const srcPath = resolve(srcDir, `${found.name}.dna.yaml`);
-    let newContent = await readFile(srcPath, "utf-8");
+    let newContent = await readFile(found.path, "utf-8");
     // 4. Inject _source_template, _template_version, and _template_content_hash
     const templateData = parseYAML(newContent);
     const templateVersion = typeof templateData.version === "string" ? templateData.version : undefined;
@@ -143,10 +134,37 @@ async function upgradeConfig(configPath, templateName) {
     process.stderr.write("\n");
     return 0;
 }
+export async function createConfigFromTemplate(input) {
+    const projectDir = input.projectDir ?? process.cwd();
+    const templates = await listTemplates(projectDir);
+    const found = templates.find((t) => t.name === input.template);
+    if (!found) {
+        throw new Error(`Unknown template: ${input.template}\nAvailable: ${templates.map((t) => t.name).join(", ")}`);
+    }
+    const content = await readFile(found.path, "utf-8");
+    const templateData = parseYAML(content);
+    const templateVersion = typeof templateData.version === "string" ? templateData.version : undefined;
+    const templateHash = calculateTemplateHash(content);
+    const contentWithSource = injectSourceTemplate(content, found.name, templateVersion, templateHash);
+    const srcNs = typeof templateData.namespace === "string" ? templateData.namespace : undefined;
+    await checkNamespaceAgainstExisting(srcNs, found.name, projectDir);
+    const safeName = sanitizeTemplateName(found.name);
+    const outPath = input.output
+        ? resolve(projectDir, input.output)
+        : resolve(projectDir, MULTI_CONFIG_DIR, `${safeName}.yaml`);
+    await mkdir(resolve(outPath, ".."), { recursive: true });
+    await writeFile(outPath, contentWithSource, "utf-8");
+    return {
+        path: outPath,
+        template: found.name,
+        namespace: found.namespace,
+    };
+}
 export async function runInit(opts) {
+    const projectDir = opts.projectDir ?? process.cwd();
     // Upgrade mode: update template(s) while preserving user variables
     if (opts.upgrade !== undefined) {
-        const configPaths = await autoDetectConfigsForUpgrade();
+        const configPaths = await autoDetectConfigsForUpgrade(projectDir);
         if (configPaths.length === 0) {
             process.stderr.write("No DNA config found. Run `dna init --template <name>` first.\n");
             return 2;
@@ -171,7 +189,7 @@ export async function runInit(opts) {
                 process.stderr.write(`Config for template "${opts.upgrade}" not found in: ${configPaths.map(p => basename(p)).join(", ")}\n`);
                 return 2;
             }
-            return upgradeConfig(targetPath, opts.upgrade);
+            return upgradeConfig(targetPath, opts.upgrade, projectDir);
         }
         // --upgrade (no arg): upgrade all configs
         let exitCode = 0;
@@ -185,7 +203,7 @@ export async function runInit(opts) {
                 process.stderr.write(`Cannot infer template for ${basename(configPath)}. Skipping.\n`);
                 continue;
             }
-            const code = await upgradeConfig(configPath, templateName);
+            const code = await upgradeConfig(configPath, templateName, projectDir);
             if (code !== 0)
                 exitCode = code;
         }
@@ -206,22 +224,22 @@ export async function runInit(opts) {
             return 2;
         }
         // Check namespace uniqueness against all existing templates
-        const existing = await listTemplates();
+        const existing = await listTemplates(projectDir);
         const conflict = existing.find((t) => t.namespace === srcNs);
         if (conflict) {
             process.stderr.write(`Namespace "${srcNs}" already used by template "${conflict.name}" (${conflict.source})\n`);
             return 2;
         }
-        await mkdir(PROJECT_TEMPLATES_DIR, { recursive: true });
+        await mkdir(resolve(projectDir, PROJECT_TEMPLATES_DIR), { recursive: true });
         const destFile = basename(srcPath).endsWith(".dna.yaml") ? basename(srcPath) : `${basename(srcPath, ".yaml")}.dna.yaml`;
-        const destPath = resolve(PROJECT_TEMPLATES_DIR, destFile);
+        const destPath = resolve(projectDir, PROJECT_TEMPLATES_DIR, destFile);
         await copyFile(srcPath, destPath);
         process.stderr.write(`Registered template: ${destPath} (namespace: ${srcNs})\n`);
         return 0;
     }
     // Template mode: copy a pre-built template
     if (opts.template) {
-        const templates = await listTemplates();
+        const templates = await listTemplates(projectDir);
         if (opts.template === "list") {
             process.stderr.write("Available templates:\n");
             // Calculate column widths
@@ -238,35 +256,52 @@ export async function runInit(opts) {
             }
             return 0;
         }
-        const found = templates.find((t) => t.name === opts.template);
-        if (!found) {
-            process.stderr.write(`Unknown template: ${opts.template}\n`);
-            process.stderr.write(`Available: ${templates.map((t) => t.name).join(", ")}\n`);
+        const result = await createConfigFromTemplate({
+            template: opts.template,
+            output: opts.output,
+            projectDir,
+        }).catch((err) => {
+            process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+            return undefined;
+        });
+        if (!result)
             return 2;
+        const packet = {
+            schema_version: "intentdna.init_result.v1",
+            mode: "template_init",
+            status: "created",
+            projectDir,
+            path: result.path,
+            template: result.template,
+            namespace: result.namespace,
+            commandEffects: {
+                mutation_performed: true,
+                network_performed: false,
+                runtime_authority: false,
+                online_required: false,
+                cloud_required: false,
+                syncs_harness: false,
+                executes_workflow: false,
+            },
+            boundaries: [
+                "dna init creates local DNA config only; it does not sync harness artifacts.",
+                "dna init does not execute workflows or make allow/warn/block/validate decisions.",
+                "Online and Supabase are not required for local template initialization.",
+                "Marketplace/template metadata distributes workflow assets; it is not runtime authority.",
+            ],
+            nextCommands: [
+                "dna sync --dry-run",
+                "dna sync",
+                "dna report package --json",
+            ],
+        };
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(packet, null, 2) + "\n");
+            return 0;
         }
-        const srcDir = found.source === "project" ? PROJECT_TEMPLATES_DIR : TEMPLATES_DIR;
-        const srcPath = resolve(srcDir, `${found.name}.dna.yaml`);
-        const content = await readFile(srcPath, "utf-8");
-        // Inject _source_template and _template_version metadata for upgrade tracking
-        // Inject _source_template, _template_version, and _template_content_hash for upgrade tracking
-        const templateData = parseYAML(content);
-        const templateVersion = typeof templateData.version === "string" ? templateData.version : undefined;
-        const templateHash = calculateTemplateHash(content);
-        const contentWithSource = injectSourceTemplate(content, found.name, templateVersion, templateHash);
-        // Check namespace collision against existing configs
-        const srcData = parseYAML(content);
-        const srcNs = typeof srcData.namespace === "string" ? srcData.namespace : undefined;
-        await checkNamespaceAgainstExisting(srcNs, found.name);
-        // Default output: .dna/configs/<template-name>.yaml (multi-config)
-        const safeName = sanitizeTemplateName(found.name);
-        const outPath = opts.output || resolve(MULTI_CONFIG_DIR, `${safeName}.yaml`);
-        // Ensure output directory exists
-        const outDir = resolve(outPath, "..");
-        await mkdir(outDir, { recursive: true });
-        await writeFile(outPath, contentWithSource, "utf-8");
-        process.stderr.write(`Created ${outPath} from template '${found.name}'`);
-        if (found.namespace)
-            process.stderr.write(` (namespace: ${found.namespace})`);
+        process.stderr.write(`Created ${result.path} from template '${result.template}'`);
+        if (result.namespace)
+            process.stderr.write(` (namespace: ${result.namespace})`);
         process.stderr.write("\n");
         return 0;
     }

package/dist/cli/commands/org.d.ts

@@ -0,0 +1,16 @@
+/**
+ * dna org — local organization/project asset management.
+ */
+export interface OrgOptions {
+    subcommand: string;
+    description?: string;
+    name?: string;
+    project?: string;
+    asset?: string;
+    status?: string;
+    syncTarget?: string;
+    projectDir?: string;
+    apply?: boolean;
+    json?: boolean;
+}
+export declare function runOrg(opts: OrgOptions): Promise<number>;