@mevdragon/vidfarm-devcli 0.2.7 → 0.2.9

package/dist/src/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { execFile } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import { parseArgs } from "node:util";
 import { promisify } from "node:util";
 import dotenv from "dotenv";
-import { STARTER_TEMPLATE_FONT_OPTIONS, STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS } from "./lib/template-style-options.js";
+import { CAPTION_STANDARD_VERSION, STARTER_TEMPLATE_FONT_OPTIONS, STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS, TIKTOK_CAPTION_STYLE_PRESETS } from "./lib/template-style-options.js";
 import { analyzeTemplateDna, hasTemplatePreviewMedia, stageTemplateDnaInputs, syncTemplateDnaModule } from "./lib/template-dna.js";
 import { assertTemplateFolderNameHasPrefix, defaultSkillPathForTemplateModule, deriveTemplateRootDirFromModulePath } from "./lib/template-paths.js";
 const execFileAsync = promisify(execFile);
@@ -41,6 +41,10 @@ async function main() {
         await runRegisterSourceHostedCommand(process.argv.slice(3));
         return;
     }
+    if (command === "publish-update-hosted") {
+        await runPublishUpdateHostedCommand(process.argv.slice(3));
+        return;
+    }
     if (command === "register-source-prod") {
         await runRegisterSourceProdCommand(process.argv.slice(3));
         return;
@@ -53,6 +57,10 @@ async function main() {
         await runGenerateTemplateCommand(process.argv.slice(3));
         return;
     }
+    if (command === "autocreate-template" || command === "autocreate") {
+        await runAutocreateTemplateCommand(process.argv.slice(3));
+        return;
+    }
     if (command === "copy-reference-template") {
         await runCopyReferenceTemplateCommand(process.argv.slice(3));
         return;
@@ -124,7 +132,8 @@ async function runDevCommand(argv) {
         email: parsed.values.email,
         name: parsed.values.name,
         isDeveloper: true,
-        isPaidPlan: true
+        isPaidPlan: true,
+        planTier: "standard"
     });
     const rawApiKey = parsed.values["api-key"] ?? `vf_local_${Math.random().toString(36).slice(2, 12)}`;
     database.insertApiKey({
@@ -294,9 +303,28 @@ async function runGenerateTemplateCommand(argv) {
             force: { type: "boolean", default: false }
         }
     });
-    const templateId = parsed.values["template-id"] ?? randomUUID();
-    const slugId = parsed.values["slug-id"];
-    const templateDir = parsed.values["template-dir"];
+    const result = await generateTemplateFromStarter({
+        templateId: parsed.values["template-id"],
+        slugId: parsed.values["slug-id"],
+        templateDir: parsed.values["template-dir"],
+        projectName: parsed.values["project-name"],
+        githubRepo: parsed.values["github-repo"],
+        siteName: parsed.values["site-name"],
+        linkToOriginal: parsed.values["link-to-original"],
+        sourceNotesPath: parsed.values["source-notes-path"],
+        sourcePreviewDir: parsed.values["source-preview-dir"],
+        dnaEnvFile: parsed.values["dna-env-file"],
+        dnaModel: parsed.values["dna-model"],
+        skipDnaAnalysis: parsed.values["skip-dna-analysis"],
+        branch: parsed.values.branch,
+        force: parsed.values.force
+    });
+    console.log(JSON.stringify(result, null, 2));
+}
+async function generateTemplateFromStarter(input) {
+    const templateId = input.templateId ?? randomUUID();
+    const slugId = input.slugId;
+    const templateDir = input.templateDir;
     if (!slugId || !templateDir) {
         throw new Error("generate-template requires --slug-id and --template-dir. --template-id is optional and defaults to a new UUIDv4.");
     }
@@ -309,7 +337,7 @@ async function runGenerateTemplateCommand(argv) {
         throw new Error(`Starter template not found: ${starterDir}`);
     }
     if (existsSync(destinationDir)) {
-        if (!parsed.values.force) {
+        if (!input.force) {
             throw new Error(`Destination already exists: ${destinationDir}`);
         }
         rmSync(destinationDir, { recursive: true, force: true });
@@ -321,9 +349,9 @@ async function runGenerateTemplateCommand(argv) {
             return ![".git", "node_modules", "dist", "package-lock.json"].includes(name);
         }
     });
-    const projectName = parsed.values["project-name"] ?? toProjectName(destinationFolderName);
-    const siteName = parsed.values["site-name"] ?? projectName.replace(/_/g, "-");
-    const githubRepo = parsed.values["github-repo"] ?? `mevdragon/${projectName}`;
+    const projectName = input.projectName ?? toProjectName(destinationFolderName);
+    const siteName = input.siteName ?? projectName.replace(/_/g, "-");
+    const githubRepo = input.githubRepo ?? `mevdragon/${projectName}`;
     rewriteTemplateStarter(destinationDir, [
         ["mevdragon/vidfarm_template_0000", githubRepo],
         ["vidfarm_template_0000", projectName],
@@ -331,35 +359,35 @@ async function runGenerateTemplateCommand(argv) {
         ["template_0000", slugId],
         ["template-0000", slugId.replace(/_/g, "-")],
         ["4c7a7e1a-7f35-4f30-9f86-9c8a63c7f2db", templateId],
-        ['"production"', JSON.stringify(parsed.values.branch)]
+        ['"production"', JSON.stringify(input.branch ?? "production")]
     ]);
     const stagedInputs = stageTemplateDnaInputs({
         templateDir: destinationDir,
-        sourceNotesPath: parsed.values["source-notes-path"],
-        sourcePreviewDir: parsed.values["source-preview-dir"]
+        sourceNotesPath: input.sourceNotesPath,
+        sourcePreviewDir: input.sourcePreviewDir
     });
     const moduleSync = syncTemplateDnaModule({
         templateDir: destinationDir,
-        linkToOriginal: parsed.values["link-to-original"]
+        linkToOriginal: input.linkToOriginal
     });
     const dnaRuns = [];
-    if (!parsed.values["skip-dna-analysis"] && hasTemplatePreviewMedia(destinationDir)) {
+    if (!input.skipDnaAnalysis && hasTemplatePreviewMedia(destinationDir)) {
         dnaRuns.push(await analyzeTemplateDna({
             mode: "viral",
             templateDir: destinationDir,
-            envFile: parsed.values["dna-env-file"],
-            model: parsed.values["dna-model"],
-            linkToOriginal: parsed.values["link-to-original"]
+            envFile: input.dnaEnvFile ?? ".env",
+            model: input.dnaModel,
+            linkToOriginal: input.linkToOriginal
         }));
         dnaRuns.push(await analyzeTemplateDna({
             mode: "visual",
             templateDir: destinationDir,
-            envFile: parsed.values["dna-env-file"],
-            model: parsed.values["dna-model"],
-            linkToOriginal: parsed.values["link-to-original"]
+            envFile: input.dnaEnvFile ?? ".env",
+            model: input.dnaModel,
+            linkToOriginal: input.linkToOriginal
         }));
     }
-    console.log(JSON.stringify({
+    return {
         template_id: templateId,
         slug_id: slugId,
         template_dir: destinationDir,
@@ -368,7 +396,152 @@ async function runGenerateTemplateCommand(argv) {
         site_name: siteName,
         research: stagedInputs,
         template_dna_module: moduleSync,
-        dna_analysis_runs: dnaRuns
+        dna_analysis_runs: dnaRuns,
+        required_template_contract: {
+            template_fields: [
+                "id",
+                "slugId",
+                "version",
+                "about.title",
+                "about.description",
+                "about.viral_dna",
+                "about.visual_dna",
+                "about.preview_media",
+                "about.link_to_original",
+                "about.proposal_generator",
+                "about.skeleton_prompt",
+                "about.sample_prompts",
+                "configSchema",
+            ],
+            operation_fields: [
+                "operations.<name>.workflow",
+                "operations.<name>.smokeTestPayload",
+                "jobs.<workflow>",
+            ],
+            files: [
+                "src/template.ts",
+                "SKILL.md",
+            ],
+        },
+        next_steps: [
+            "Review src/template.ts and replace the starter proposal_generator with template-specific proposal instructions.",
+            "Review src/template.ts and replace the starter skeleton_prompt with a fill-in-the-blanks prompt that fits the real format.",
+            "Review src/template.ts and replace the starter sample_prompts with prompts that fit the new format.",
+            "If DNA analysis was skipped or the source research changed, run analyze-viral-dna and analyze-visual-dna.",
+            "Update SKILL.md so the usage examples match the template's real operations and payloads.",
+            `Run validate-template against ${slugId} and launch at least one real local job before treating the template as ready.`,
+        ],
+    };
+}
+async function runAutocreateTemplateCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            "input-path": { type: "string" },
+            "output-path": { type: "string" },
+            "run-id": { type: "string" },
+            "runs-dir": { type: "string", default: "auto-create-templates/runs" },
+            "harness-dir": { type: "string" },
+            "slug-id": { type: "string" },
+            "template-id": { type: "string" },
+            "project-name": { type: "string" },
+            "github-repo": { type: "string" },
+            "site-name": { type: "string" },
+            "link-to-original": { type: "string" },
+            "dna-env-file": { type: "string", default: ".env" },
+            "dna-model": { type: "string" },
+            "skip-dna-analysis": { type: "boolean", default: false },
+            "skip-scaffold": { type: "boolean", default: false },
+            "skip-media-probes": { type: "boolean", default: false },
+            "skip-harness-snapshot": { type: "boolean", default: false },
+            branch: { type: "string", default: "production" },
+            force: { type: "boolean", default: false }
+        }
+    });
+    const positionalInput = parsed.positionals[0];
+    const positionalOutput = parsed.positionals[1];
+    const inputPathRaw = parsed.values["input-path"] ?? positionalInput;
+    const outputPathRaw = parsed.values["output-path"] ?? positionalOutput;
+    if (!inputPathRaw || !outputPathRaw) {
+        throw new Error("autocreate-template requires --input-path and --output-path, or positional args: autocreate-template <input_path> <output_path>.");
+    }
+    const root = process.cwd();
+    const inputPath = path.resolve(root, inputPathRaw);
+    const outputPath = path.resolve(root, outputPathRaw);
+    if (!existsSync(inputPath)) {
+        throw new Error(`Input path not found: ${inputPath}`);
+    }
+    const outputFolderName = path.basename(outputPath);
+    assertTemplateFolderNameHasPrefix(outputFolderName);
+    const slugId = parsed.values["slug-id"] ?? toSlugId(outputFolderName);
+    const runId = parsed.values["run-id"] ?? `${toProjectName(slugId)}-${formatUtcTimestamp(new Date())}`;
+    const runsDir = path.resolve(root, parsed.values["runs-dir"]);
+    const runDir = path.join(runsDir, runId);
+    const sourceDir = path.join(runDir, "source");
+    const previewDir = path.join(sourceDir, "preview");
+    const harnessDir = parsed.values["harness-dir"]
+        ? path.resolve(root, parsed.values["harness-dir"])
+        : resolveAutoCreateHarnessDir();
+    createAutoCreateRunFolders(runDir);
+    stageAutocreateSource({
+        inputPath,
+        sourceDir,
+        previewDir,
+        linkToOriginal: parsed.values["link-to-original"]
+    });
+    const mediaProbe = parsed.values["skip-media-probes"]
+        ? { skipped: true, reason: "skip-media-probes was set" }
+        : await prepareAutocreateMediaArtifacts({ runDir, previewDir });
+    const harnessSnapshot = parsed.values["skip-harness-snapshot"]
+        ? null
+        : snapshotAutoCreateHarness({ harnessDir, runDir });
+    const sourceNotesPath = path.join(sourceDir, "source.md");
+    const scaffold = parsed.values["skip-scaffold"]
+        ? null
+        : await generateTemplateFromStarter({
+            templateId: parsed.values["template-id"],
+            slugId,
+            templateDir: path.relative(root, outputPath),
+            projectName: parsed.values["project-name"],
+            githubRepo: parsed.values["github-repo"],
+            siteName: parsed.values["site-name"],
+            linkToOriginal: parsed.values["link-to-original"],
+            sourceNotesPath,
+            sourcePreviewDir: previewDir,
+            dnaEnvFile: parsed.values["dna-env-file"],
+            dnaModel: parsed.values["dna-model"],
+            skipDnaAnalysis: parsed.values["skip-dna-analysis"],
+            branch: parsed.values.branch,
+            force: parsed.values.force
+        });
+    const agentPromptPath = path.join(runDir, "agent_prompt.md");
+    const manifest = {
+        mode: "autocreate-template",
+        harness_entry: path.join(harnessDir, "AUTO_CREATE_TEMPLATES.md"),
+        harness_snapshot: harnessSnapshot,
+        input_path: inputPath,
+        output_path: outputPath,
+        run_id: runId,
+        run_dir: runDir,
+        source_dir: sourceDir,
+        source_notes_path: sourceNotesPath,
+        source_preview_dir: previewDir,
+        slug_id: slugId,
+        scaffold,
+        media_probe: mediaProbe,
+        required_artifacts: {
+            viral_steering_and_visual_preservation: path.join(runDir, "dna", "preservation_decision.json"),
+            production_graph: path.join(runDir, "extraction", "production_graph.json"),
+            template_plan: path.join(runDir, "plan", "template_plan.json")
+        }
+    };
+    writeFileSync(path.join(runDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+    writeFileSync(agentPromptPath, renderAutocreateAgentPrompt(manifest), "utf8");
+    console.log(JSON.stringify({
+        ...manifest,
+        agent_prompt_path: agentPromptPath,
+        next_command_for_agent: `Use ${manifest.harness_entry} as the harness. Analyze ${sourceDir} as the source format, use run artifacts in ${runDir}, generate the production graph and template plan, then scaffold and implement a runnable Vidfarm template to ${outputPath}.`
     }, null, 2));
 }
 async function runRegisterSourceProdCommand(argv) {
@@ -402,6 +575,45 @@ async function runRegisterSourceHostedCommand(argv) {
         next_step: "Platform admin reviews the source, imports a release, approves it, and activates it."
     }, null, 2));
 }
+async function runPublishUpdateHostedCommand(argv) {
+    const input = parseProdTemplateCommandArgs(argv, {
+        envFile: ".env",
+        baseUrl: process.env.VIDFARM_BASE_URL ?? "https://vidfarm.cloud.zoomgtm.com",
+        activate: false
+    });
+    if (!input.commitSha) {
+        throw new Error("publish-update-hosted requires --commit-sha.");
+    }
+    const registration = await registerSourceViaApi(input);
+    const artifact = await packageTemplateArtifact(input.repoDir, input.commitSha);
+    const presign = await postProdTemplateApi(input, `/api/v1/templates/sources/${registration.source.id}/artifacts/presign`, {
+        method: "POST",
+        body: JSON.stringify({
+            commit_sha: input.commitSha
+        })
+    });
+    await uploadArtifactArchive(presign, artifact.buffer);
+    const payload = await postProdTemplateApi(input, `/api/v1/templates/sources/${registration.source.id}/publish`, {
+        method: "POST",
+        body: JSON.stringify({
+            commit_sha: input.commitSha,
+            artifact_sha256: artifact.sha256
+        })
+    });
+    console.log(JSON.stringify({
+        mode: "hosted-publish-update",
+        base_url: input.baseUrl,
+        source: payload.source,
+        release: payload.release,
+        artifact: {
+            artifact_key: presign.artifact_key,
+            artifact_manifest_key: presign.artifact_manifest_key,
+            sha256: artifact.sha256
+        },
+        publish_action: payload.publish_action,
+        developer_handoff: payload.developer_handoff ?? null
+    }, null, 2));
+}
 async function runImportSourceProdCommand(argv) {
     const input = parseProdTemplateCommandArgs(argv, {
         envFile: ".env.production",
@@ -486,7 +698,38 @@ async function runCopyReferenceTemplateCommand(argv) {
         template_dir: destinationDir,
         template_id: "4c7a7e1a-7f35-4f30-9f86-9c8a63c7f2db",
         slug_id: "template_0000",
-        rewritten: false
+        rewritten: false,
+        required_template_contract: {
+            template_fields: [
+                "id",
+                "slugId",
+                "version",
+                "about.title",
+                "about.description",
+                "about.viral_dna",
+                "about.visual_dna",
+                "about.preview_media",
+                "about.link_to_original",
+                "about.proposal_generator",
+                "about.skeleton_prompt",
+                "about.sample_prompts",
+                "configSchema",
+            ],
+            operation_fields: [
+                "operations.<name>.workflow",
+                "operations.<name>.smokeTestPayload",
+                "jobs.<workflow>",
+            ],
+            files: [
+                "src/template.ts",
+                "SKILL.md",
+            ],
+        },
+        next_steps: [
+            "Treat src/template.ts as the canonical entrypoint and review the required about metadata before copying patterns into a new template.",
+            "Use the starter proposal_generator, skeleton_prompt, and sample_prompts as placeholders only; rewrite them for the real format you are building.",
+            "Keep the template-local SKILL.md aligned with the operations and payloads in code.",
+        ],
     }, null, 2));
 }
 async function runAnalyzeTemplateDnaCommand(mode, argv) {
@@ -611,9 +854,18 @@ async function runSessionCommand(argv) {
         base_url: session.baseUrl,
         email: session.email,
         starter_style_options: {
+            caption_standard_version: CAPTION_STANDARD_VERSION,
             fonts: STARTER_TEMPLATE_FONT_OPTIONS,
             text_background_colors: STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS,
-            starter_template_file: "templates/template_0000/src/style-options.ts"
+            presets: TIKTOK_CAPTION_STYLE_PRESETS,
+            package_dependencies: [
+                "@fontsource/tiktok-sans",
+                "@fontsource/montserrat",
+                "@fontsource/source-code-pro",
+                "@fontsource/libre-baskerville"
+            ],
+            standard_file: "src/lib/template-style-options.ts",
+            starter_template_file: "demos/vidfarm_template_0000/src/style-options.ts"
         },
         headers: {
             "vidfarm-api-key": session.apiKey,
@@ -649,8 +901,7 @@ function seedEnvProviderKeys(input) {
             customerId: input.customerId,
             provider: entry.provider,
             label: "Local CLI env key",
-            encryptedSecret: input.encryptString(secret, input.encryptionSecret),
-            weight: 1
+            encryptedSecret: input.encryptString(secret, input.encryptionSecret)
         });
     }
 }
@@ -700,8 +951,10 @@ function toProjectName(folderName) {
 }
 function resolveStarterTemplateDir() {
     const candidates = [
-        path.resolve(import.meta.dirname, "..", "templates", "template_0000"),
-        path.resolve(import.meta.dirname, "..", "..", "templates", "template_0000")
+        path.resolve(import.meta.dirname, "..", "templates", "vidfarm_template_0000"),
+        path.resolve(import.meta.dirname, "..", "..", "templates", "vidfarm_template_0000"),
+        path.resolve(import.meta.dirname, "..", "demos", "vidfarm_template_0000"),
+        path.resolve(import.meta.dirname, "..", "..", "demos", "vidfarm_template_0000")
     ];
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
@@ -710,6 +963,218 @@ function resolveStarterTemplateDir() {
     }
     return candidates[0];
 }
+function resolveAutoCreateHarnessDir() {
+    const candidates = [
+        path.resolve(process.cwd(), "auto-create-templates"),
+        path.resolve(import.meta.dirname, "..", "auto-create-templates"),
+        path.resolve(import.meta.dirname, "..", "..", "auto-create-templates")
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(path.join(candidate, "AUTO_CREATE_TEMPLATES.md"))) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function createAutoCreateRunFolders(runDir) {
+    for (const name of ["source", "frames", "audio", "transcripts", "ocr", "motion", "dna", "extraction", "plan"]) {
+        mkdirSync(path.join(runDir, name), { recursive: true });
+    }
+}
+function stageAutocreateSource(input) {
+    mkdirSync(input.sourceDir, { recursive: true });
+    mkdirSync(input.previewDir, { recursive: true });
+    const stats = statSync(input.inputPath);
+    if (stats.isDirectory()) {
+        const inputHadPreviewDir = existsSync(path.join(input.inputPath, "preview"));
+        copyDirectoryContentsShallow(input.inputPath, input.sourceDir);
+        const existingPreviewDir = path.join(input.sourceDir, "preview");
+        if (!inputHadPreviewDir) {
+            mkdirSync(existingPreviewDir, { recursive: true });
+            for (const mediaFile of listMediaFiles(input.sourceDir)) {
+                cpSync(mediaFile, path.join(existingPreviewDir, path.basename(mediaFile)));
+            }
+        }
+    }
+    else {
+        cpSync(input.inputPath, path.join(input.previewDir, path.basename(input.inputPath)));
+    }
+    const notesPath = path.join(input.sourceDir, "source.md");
+    if (!existsSync(notesPath)) {
+        writeFileSync(notesPath, [
+            "# Source Notes",
+            "",
+            `- input path: ${input.inputPath}`,
+            `- original format URL: ${input.linkToOriginal ?? ""}`,
+            "- creator/account:",
+            "- product/category being adapted:",
+            "- what appears repeatable:",
+            "- constraints:",
+            ""
+        ].join("\n"), "utf8");
+    }
+}
+async function prepareAutocreateMediaArtifacts(input) {
+    const videoFile = listMediaFiles(input.previewDir).find((filePath) => isVideoFile(filePath));
+    if (!videoFile) {
+        return {
+            skipped: true,
+            reason: "No video file found in source preview media.",
+            preview_files: listMediaFiles(input.previewDir)
+        };
+    }
+    const ffprobePath = path.join(input.runDir, "source", "ffprobe.json");
+    const contactSheetPath = path.join(input.runDir, "frames", "contact-sheet.jpg");
+    const audioPath = path.join(input.runDir, "audio", "source.wav");
+    const steps = [];
+    steps.push(await runOptionalLocalCommand("ffprobe", [
+        "-v", "error",
+        "-show_entries", "format=duration:stream=codec_type,width,height,avg_frame_rate",
+        "-of", "json",
+        videoFile
+    ], ffprobePath));
+    steps.push(await runOptionalLocalCommand("ffmpeg", [
+        "-y",
+        "-i", videoFile,
+        "-vf", "fps=1/2,scale=240:-1,tile=3x4",
+        "-frames:v", "1",
+        contactSheetPath
+    ]));
+    steps.push(await runOptionalLocalCommand("ffmpeg", [
+        "-y",
+        "-i", videoFile,
+        "-vn",
+        "-ac", "1",
+        "-ar", "16000",
+        audioPath
+    ]));
+    const result = {
+        skipped: false,
+        video_file: videoFile,
+        ffprobe_path: existsSync(ffprobePath) ? ffprobePath : null,
+        contact_sheet_path: existsSync(contactSheetPath) ? contactSheetPath : null,
+        audio_path: existsSync(audioPath) ? audioPath : null,
+        steps
+    };
+    writeFileSync(path.join(input.runDir, "source", "media_artifacts.json"), JSON.stringify(result, null, 2) + "\n", "utf8");
+    return result;
+}
+function snapshotAutoCreateHarness(input) {
+    if (!existsSync(path.join(input.harnessDir, "AUTO_CREATE_TEMPLATES.md"))) {
+        throw new Error(`Auto-create harness not found: ${input.harnessDir}`);
+    }
+    const destinationDir = path.join(input.runDir, "harness");
+    mkdirSync(destinationDir, { recursive: true });
+    for (const fileName of [
+        "AUTO_CREATE_TEMPLATES.md",
+        "runbook.md",
+        "extractor-system-prompt.md",
+        "production-graph.schema.json",
+        "template-planner-prompt.md",
+        "template-plan.schema.json"
+    ]) {
+        const source = path.join(input.harnessDir, fileName);
+        if (existsSync(source)) {
+            cpSync(source, path.join(destinationDir, fileName));
+        }
+    }
+    return {
+        harness_dir: destinationDir,
+        entry: path.join(destinationDir, "AUTO_CREATE_TEMPLATES.md")
+    };
+}
+function renderAutocreateAgentPrompt(manifest) {
+    return [
+        "# Vidfarm Autocreate Template Handoff",
+        "",
+        `Use ${manifest.harness_entry} as the harness.`,
+        `Analyze ${manifest.source_dir} as the source format.`,
+        `Use the run artifacts in ${manifest.run_dir}.`,
+        `Output the runnable Vidfarm template to ${manifest.output_path}.`,
+        "",
+        "Required work:",
+        "",
+        "1. Inspect source notes and preview media.",
+        "2. Use or create analyzer artifacts in the run folder.",
+        "3. Run or consume viral and visual DNA analysis.",
+        "4. Create `dna/preservation_decision.json`.",
+        "5. Create `extraction/production_graph.json` matching the production graph schema.",
+        "6. Create `plan/template_plan.json` matching the template plan schema.",
+        "7. Implement the template operations, jobs, metadata, prompts, storage outputs, and template-local `SKILL.md`.",
+        "8. Run `vidfarm-devcli validate-template` and at least one real local job before calling it done.",
+        "",
+        "Manifest:",
+        "",
+        "```json",
+        JSON.stringify(manifest, null, 2),
+        "```",
+        ""
+    ].join("\n");
+}
+async function runOptionalLocalCommand(command, args, outputPath) {
+    try {
+        const result = await execFileAsync(command, args, {
+            maxBuffer: 20 * 1024 * 1024
+        });
+        if (outputPath) {
+            writeFileSync(outputPath, result.stdout, "utf8");
+        }
+        return {
+            command,
+            ok: true,
+            output_path: outputPath ?? null,
+            stderr: result.stderr.trim() || null
+        };
+    }
+    catch (error) {
+        return {
+            command,
+            ok: false,
+            output_path: outputPath ?? null,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function copyDirectoryContentsShallow(sourceDir, destinationDir) {
+    mkdirSync(destinationDir, { recursive: true });
+    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+        if (!entry.name.startsWith(".")) {
+            cpSync(path.join(sourceDir, entry.name), path.join(destinationDir, entry.name), { recursive: true });
+        }
+    }
+}
+function listMediaFiles(dir) {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    const files = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const filePath = path.join(dir, entry.name);
+        if (entry.name.startsWith(".")) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...listMediaFiles(filePath));
+            continue;
+        }
+        if (entry.isFile() && isMediaFile(filePath)) {
+            files.push(filePath);
+        }
+    }
+    return files.sort((a, b) => a.localeCompare(b));
+}
+function isMediaFile(filePath) {
+    return [".png", ".jpg", ".jpeg", ".webp", ".mp4", ".mov", ".webm", ".m4v"].includes(path.extname(filePath).toLowerCase());
+}
+function isVideoFile(filePath) {
+    return [".mp4", ".mov", ".webm", ".m4v"].includes(path.extname(filePath).toLowerCase());
+}
+function toSlugId(folderName) {
+    return toProjectName(folderName).replace(/^vidfarm_template_/, "template_");
+}
+function formatUtcTimestamp(date) {
+    return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
 function parseProdTemplateCommandArgs(argv, defaults) {
     const parsed = parseArgs({
         args: argv,
@@ -723,6 +1188,7 @@ function parseProdTemplateCommandArgs(argv, defaults) {
             "install-command": { type: "string", default: "npm install" },
             "build-command": { type: "string", default: "npm run build" },
             "commit-sha": { type: "string" },
+            "repo-dir": { type: "string", default: "." },
             "env-file": { type: "string", default: defaults.envFile },
             "base-url": { type: "string", default: defaults.baseUrl },
             "api-key": { type: "string" },
@@ -752,6 +1218,7 @@ function parseProdTemplateCommandArgs(argv, defaults) {
         installCommand: parsed.values["install-command"],
         buildCommand: parsed.values["build-command"],
         commitSha: parsed.values["commit-sha"] ?? undefined,
+        repoDir: path.resolve(process.cwd(), parsed.values["repo-dir"]),
         envFile: parsed.values["env-file"],
         baseUrl: normalizeBaseUrl(parsed.values["base-url"]),
         apiKey,
@@ -810,6 +1277,35 @@ async function postProdTemplateApi(input, pathname, init) {
     }
     return payload;
 }
+async function packageTemplateArtifact(repoDir, commitSha) {
+    const tempDir = mkdtempSync(path.join(os.tmpdir(), "vidfarm-template-artifact-"));
+    const repoRoot = (await execFileAsync("git", ["-C", repoDir, "rev-parse", "--show-toplevel"])).stdout.trim();
+    const artifactPath = path.join(tempDir, "template-source.tar.gz");
+    try {
+        await execFileAsync("git", ["-C", repoRoot, "archive", "--format=tar.gz", `--output=${artifactPath}`, commitSha], {
+            cwd: repoRoot
+        });
+        const buffer = readFileSync(artifactPath);
+        return {
+            buffer,
+            sha256: createHash("sha256").update(buffer).digest("hex")
+        };
+    }
+    finally {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+}
+async function uploadArtifactArchive(presign, buffer) {
+    const response = await fetch(presign.upload.url, {
+        method: presign.upload.method,
+        headers: presign.upload.headers,
+        body: new Uint8Array(buffer)
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(body || `Artifact upload failed with ${response.status}.`);
+    }
+}
 function loadEnvFile(envFile) {
     const resolved = path.resolve(process.cwd(), envFile);
     if (!existsSync(resolved)) {