@aicopycoders/exodus 2026.6.2400

package/dist/commands/idea.js

@@ -0,0 +1,333 @@
+import { apiGet, apiPost } from "../lib/client.js";
+import { formatError } from "../lib/format.js";
+import { formatCcCommand } from "../lib/cc-command.js";
+import { captureReelAndWrite } from "../lib/reel-write.js";
+export const helpText = `
+exodus idea — capture, curate, and write from your brand-agnostic Idea Bank
+
+The Idea Bank holds formed ideas (a hook + a short concept) you can curate and
+escalate to the Genesis writer. Capture ideas three ways, add one directly, or
+write from the ones you like.
+
+Usage:
+  exodus idea gambit "<brain-dump>"       Split a freeform dump into discrete ideas
+  exodus idea organic "<url> ..." [--write]   Pull one idea from each reel (--write: bank AND write now)
+  exodus idea swipe [--limit n]           Extract concepts from your saved swipe library
+  exodus idea add "<hook>" [--desc "<concept>"] [--source gambit|organic|swipe] [--ref "<x>"] [--notes "<x>"]
+  exodus idea list [--source ..] [--since YYYY-MM-DD] [--status raw|writing|written|archived] [--limit n]
+  exodus idea note <KEY> "<notes>"        Attach persistent steering to an idea
+  exodus idea edit <KEY> "<new concept>"  Edit an idea's description
+  exodus idea write <KEYS> [--awareness <level>] [--passes n]   Fire-and-forget; one run per key (default 1 pass = 2 variants)
+  exodus idea rm <KEY> [--hard]           Archive (or hard-delete with --hard)
+
+Examples:
+  exodus idea gambit "joint pain at 40, sleep angle, grounding vs pills"
+  exodus idea organic "https://www.instagram.com/reel/abc https://www.tiktok.com/@x/video/123"
+  exodus idea organic "https://www.instagram.com/reel/abc" --write --awareness solution-aware
+  exodus idea swipe --limit 10
+  exodus idea list --source gambit --status raw
+  exodus idea write G1,S4 --awareness solution-aware
+`.trim();
+const SOURCES = ["gambit", "organic", "swipe"];
+const KEY_RE = /^[GOSgos]\d+$/;
+export function parseKeys(raw) {
+    const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    if (parts.length === 0)
+        return null;
+    for (const p of parts)
+        if (!KEY_RE.test(p))
+            return null;
+    return parts.map((p) => p.toUpperCase());
+}
+function str(flag) {
+    return typeof flag === "string" && flag.trim() ? flag.trim() : undefined;
+}
+function resolveVariantCount(flags) {
+    const variantsRaw = str(flags["variants"]);
+    if (variantsRaw) {
+        const n = parseInt(variantsRaw, 10);
+        return Number.isNaN(n) ? 2 : Math.max(1, Math.min(10, n));
+    }
+    const passesRaw = str(flags["passes"]);
+    let passes = 1;
+    if (passesRaw) {
+        const p = parseInt(passesRaw, 10);
+        passes = Number.isNaN(p) ? 1 : Math.max(1, Math.min(5, p));
+    }
+    return passes * 2;
+}
+export function resolveIdeaAction(positionals, flags) {
+    const sub = positionals[0];
+    if (sub === "add") {
+        const hook = positionals[1];
+        if (!hook)
+            return { kind: "error", message: 'add needs a hook: exodus idea add "<hook>"' };
+        const sourceRaw = str(flags["source"]) ?? "gambit";
+        if (!SOURCES.includes(sourceRaw)) {
+            return { kind: "error", message: `--source must be one of: ${SOURCES.join(", ")}` };
+        }
+        return {
+            kind: "add",
+            hook,
+            description: str(flags["desc"]) ?? hook,
+            source: sourceRaw,
+            sourceRef: str(flags["ref"]),
+            notes: str(flags["notes"]),
+        };
+    }
+    if (sub === "list") {
+        const sourceRaw = str(flags["source"]);
+        if (sourceRaw && !SOURCES.includes(sourceRaw)) {
+            return { kind: "error", message: `--source must be one of: ${SOURCES.join(", ")}` };
+        }
+        const limitRaw = str(flags["limit"]);
+        return {
+            kind: "list",
+            source: sourceRaw,
+            since: str(flags["since"]),
+            status: str(flags["status"]),
+            limit: limitRaw ? Math.max(1, parseInt(limitRaw, 10) || 50) : undefined,
+        };
+    }
+    if (sub === "note") {
+        const key = positionals[1];
+        const notes = positionals[2];
+        if (!key || !notes)
+            return { kind: "error", message: 'note needs a key + text: exodus idea note G1 "..."' };
+        if (!KEY_RE.test(key))
+            return { kind: "error", message: `Bad key "${key}"` };
+        return { kind: "note", key: key.toUpperCase(), notes };
+    }
+    if (sub === "edit") {
+        const key = positionals[1];
+        const description = positionals[2];
+        if (!key || !description)
+            return { kind: "error", message: 'edit needs a key + concept: exodus idea edit G1 "..."' };
+        if (!KEY_RE.test(key))
+            return { kind: "error", message: `Bad key "${key}"` };
+        return { kind: "edit", key: key.toUpperCase(), description };
+    }
+    if (sub === "write") {
+        const keys = positionals[1] ? parseKeys(positionals[1]) : null;
+        if (!keys)
+            return { kind: "error", message: 'write needs keys: exodus idea write G1,S4' };
+        return {
+            kind: "write",
+            keys,
+            awarenessLevel: str(flags["awareness"]) ?? "problem-aware",
+            variantCount: resolveVariantCount(flags),
+        };
+    }
+    if (sub === "rm") {
+        const key = positionals[1];
+        if (!key || !KEY_RE.test(key))
+            return { kind: "error", message: 'rm needs a key: exodus idea rm G1' };
+        return { kind: "rm", key: key.toUpperCase(), hard: flags["hard"] === true };
+    }
+    if (sub === "gambit") {
+        const dump = positionals.slice(1).join(" ").trim();
+        if (!dump)
+            return { kind: "error", message: 'gambit needs a brain-dump: exodus idea gambit "<text>"' };
+        return { kind: "gambit", dump };
+    }
+    if (sub === "organic") {
+        const urls = positionals.slice(1).join(" ").split(/\s+/).map((u) => u.trim()).filter(Boolean);
+        if (urls.length === 0)
+            return { kind: "error", message: 'organic needs at least one URL: exodus idea organic "<url> <url>"' };
+        return {
+            kind: "organic",
+            urls,
+            write: flags["write"] === true,
+            awarenessLevel: str(flags["awareness"]) ?? "problem-aware",
+            variantCount: resolveVariantCount(flags),
+        };
+    }
+    if (sub === "swipe") {
+        const limitRaw = str(flags["limit"]);
+        if (limitRaw !== undefined) {
+            const n = parseInt(limitRaw, 10);
+            if (!Number.isInteger(n) || n < 1) {
+                return { kind: "error", message: "--limit must be a positive integer" };
+            }
+            return { kind: "swipe", limit: n };
+        }
+        return { kind: "swipe", limit: undefined };
+    }
+    return {
+        kind: "error",
+        message: 'Unknown subcommand. Use: gambit | organic | swipe | add | list | note | edit | write | rm.',
+    };
+}
+function parsePositional() {
+    const args = process.argv.slice(3);
+    const out = [];
+    let i = 0;
+    while (i < args.length) {
+        const a = args[i];
+        if (a.startsWith("--")) {
+            const next = args[i + 1];
+            i += next !== undefined && !next.startsWith("--") ? 2 : 1;
+            continue;
+        }
+        out.push(a);
+        i++;
+    }
+    return out;
+}
+function renderList(ideas) {
+    if (ideas.length === 0) {
+        console.log("Idea Bank is empty.");
+        console.log('Add one:  exodus idea add "<hook>" --desc "<concept>"');
+        return;
+    }
+    console.log(`## Idea Bank (${ideas.length})`);
+    console.log("");
+    for (const i of ideas) {
+        const date = i.createdAt ? i.createdAt.slice(0, 10) : "";
+        console.log(`  ${i.key ?? "?"}  [${i.source ?? "?"}] ${i.hook ?? ""}`);
+        if (i.description)
+            console.log(`      ${i.description}`);
+        const meta = [i.status ?? "raw", date].filter(Boolean).join(" · ");
+        console.log(`      (${meta})`);
+        if (i.notes)
+            console.log(`      notes: ${i.notes}`);
+        if (i.outputDocUrl)
+            console.log(`      doc: ${i.outputDocUrl}`);
+    }
+    console.log("");
+    console.log("Write from some:  exodus idea write G1,S4");
+}
+export async function run(flags) {
+    const cc = formatCcCommand(process.argv.slice(2));
+    const action = resolveIdeaAction(parsePositional(), flags);
+    switch (action.kind) {
+        case "error":
+            console.error(`Error: ${action.message}`);
+            process.exit(1);
+            return;
+        case "gambit": {
+            const res = await apiPost("/api/v2/idea-bank/ideate", { source: "gambit", input: action.dump }, { ccCommand: cc });
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            console.log("Splitting your dump into ideas — fire-and-forget.");
+            console.log("They'll appear in the bank as the run completes:  exodus idea list --source gambit");
+            return;
+        }
+        case "organic": {
+            if (action.write) {
+                console.log(`Transcribing ${action.urls.length} reel(s) → ideas → Genesis…`);
+                const result = await captureReelAndWrite(action.urls, { awarenessLevel: action.awarenessLevel, variantCount: action.variantCount }, { cc });
+                for (const f of result.bankedFailed) {
+                    console.error(`  ✗ couldn't pull an idea from ${f} (private, region-locked, or no transcript?)`);
+                }
+                if (result.dispatched.length === 0) {
+                    console.error("No reel produced a usable idea — nothing written.");
+                    process.exit(1);
+                }
+                for (const d of result.dispatched)
+                    console.log(`  ✓ banked ${d.key} → Genesis run ${d.runId}`);
+                console.log("");
+                console.log("Track them:  exodus idea list   (status flips to 'written' with a doc link)");
+                return;
+            }
+            const res = await apiPost("/api/v2/idea-bank/ideate", { source: "organic", urls: action.urls }, { ccCommand: cc });
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            console.log(`Pulling ideas from ${action.urls.length} link(s) — fire-and-forget.`);
+            console.log("They'll appear in the bank as the run completes:  exodus idea list --source organic");
+            return;
+        }
+        case "swipe": {
+            const res = await apiPost("/api/v2/idea-bank/ideate", { source: "swipe", limit: action.limit }, { ccCommand: cc });
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            console.log("Extracting concepts from your saved swipes — fire-and-forget.");
+            console.log("They'll appear in the bank as the run completes:  exodus idea list --source swipe");
+            return;
+        }
+        case "add": {
+            const res = await apiPost("/api/v2/idea-bank", {
+                source: action.source,
+                hook: action.hook,
+                description: action.description,
+                sourceRef: action.sourceRef,
+                notes: action.notes,
+            }, { ccCommand: cc });
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            console.log(`Banked ${res.data.key ?? "(idea)"}: ${action.hook}`);
+            return;
+        }
+        case "list": {
+            const params = new URLSearchParams();
+            if (action.source)
+                params.set("source", action.source);
+            if (action.since)
+                params.set("since", action.since);
+            if (action.status)
+                params.set("status", action.status);
+            if (action.limit)
+                params.set("limit", String(action.limit));
+            const qs = params.toString();
+            const res = await apiGet(`/api/v2/idea-bank${qs ? `?${qs}` : ""}`);
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            renderList(Array.isArray(res.data.ideas) ? res.data.ideas : []);
+            return;
+        }
+        case "note": {
+            const res = await apiPost("/api/v2/idea-bank/notes", { key: action.key, notes: action.notes }, { ccCommand: cc });
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            console.log(`Notes set on ${action.key}.`);
+            return;
+        }
+        case "edit": {
+            const res = await apiPost("/api/v2/idea-bank/update", { key: action.key, description: action.description }, { ccCommand: cc });
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            console.log(`Updated ${action.key}.`);
+            return;
+        }
+        case "write": {
+            const res = await apiPost("/api/v2/idea-bank/dispatch", { keys: action.keys, awarenessLevel: action.awarenessLevel, variantCount: action.variantCount }, { ccCommand: cc });
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            const dispatched = res.data.dispatched ?? [];
+            const skipped = res.data.skipped ?? [];
+            console.log(`Dispatched ${dispatched.length} run(s) — fire-and-forget.`);
+            for (const d of dispatched)
+                console.log(`  ${d.key} → run ${d.runId}`);
+            for (const s of skipped)
+                console.log(`  skipped ${s.key}: ${s.reason}`);
+            console.log("");
+            console.log("Track them:  exodus idea list   (status flips to 'written' with a doc link)");
+            return;
+        }
+        case "rm": {
+            const res = await apiPost("/api/v2/idea-bank/delete", { key: action.key, hard: action.hard }, { ccCommand: cc });
+            if (!res.ok) {
+                console.log(formatError(res));
+                process.exit(1);
+            }
+            console.log(`${action.hard ? "Deleted" : "Archived"} ${action.key}.`);
+            return;
+        }
+    }
+}

package/dist/commands/image.d.ts

@@ -0,0 +1,2 @@
+export declare const helpText: string;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/image.js

@@ -0,0 +1,249 @@
+import { apiGet, apiPost, getDashboardUrl } from "../lib/client.js";
+import { formatError } from "../lib/format.js";
+export const helpText = `
+exodus image — Front door for static image ads (routes to creative / template)
+
+Usage:
+  exodus image --ad "<finished copy>"                    Infer + run (default: native)
+  exodus image --type native --ad "<copy>"               Literal render from copy
+  exodus image --type copy-derived --ad "<copy>"         Variations derived off copy
+  exodus image --type template --input "<copy or 1. … 2. …>"   Spread across ad-type formats
+
+Options:
+  --type <engine>           native | copy-derived | template
+                            (omit to infer: numbered --input → template; else native)
+  --ad "<text>"             Finished ad copy (alias: --input)
+  --input "<text>"          Finished ad copy, or a numbered list of ads ("1. … 2. …")
+  --variations N            Renders to generate (creative engines; maps to render target for template)
+  --aspect 1:1|4:5|9:16     Image aspect ratio (default: 1:1; template supports 1:1|9:16)
+  --name "<label>"          Custom run name (creative engines)
+  --from copy|idea          Source signal (default: copy). --from idea has no copy yet → write first.
+  --steer "<direction>"     Steer every image in the batch (alias: --direction).
+                            Native: a --steer with no --ad runs a no-copy native render.
+  --realistic               Template only: add the realistic-enhancer guardrail
+
+Examples:
+  exodus image --ad "grounding sheets reduce inflammation"
+  exodus image --type copy-derived --ad "..." --variations 10 --aspect 9:16
+  exodus image --type template --input "1. first ad ... 2. second ad ..."
+  exodus image --type template --input "1. first ad ... 2. second ad ..." --steer "dramatic, moody" --realistic
+
+Engines underneath:
+  This command picks one engine and runs it. To drive a specific engine yourself,
+  use \`exodus creative <native|copy-derived>\` or \`exodus template run\`.
+  For meme formats use \`exodus meme\`.
+`.trim();
+function flagString(flags, name) {
+    const v = flags[name];
+    return typeof v === "string" ? v : undefined;
+}
+function flagInt(flags, name) {
+    const v = flags[name];
+    if (typeof v !== "string")
+        return undefined;
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) ? n : undefined;
+}
+function looksLikeNumberedList(text) {
+    const matches = text.match(/(^|\n)\s*\d+[.)]\s+\S/g);
+    return (matches?.length ?? 0) >= 2;
+}
+async function resolveWhoami() {
+    const who = await apiGet("/api/v2/whoami");
+    if (!who.ok || !who.data.workspaceId) {
+        console.error("Error: whoami failed. Check EXODUS_API_KEY and EXODUS_API_URL/CONVEX_SITE_URL.");
+        console.error(formatError(who));
+        process.exit(1);
+        throw new Error("unreachable");
+    }
+    return who.data;
+}
+function resolveEngine(flags, refs, text) {
+    const typeRaw = flagString(flags, "type");
+    if (typeRaw) {
+        if (typeRaw === "native" ||
+            typeRaw === "copy-derived" ||
+            typeRaw === "template" ||
+            typeRaw === "ref-match") {
+            return typeRaw;
+        }
+        console.error(`Error: --type must be native | copy-derived | template | ref-match (got "${typeRaw}").`);
+        process.exit(1);
+        throw new Error("unreachable");
+    }
+    if (refs)
+        return "ref-match";
+    if (text && looksLikeNumberedList(text))
+        return "template";
+    return "native";
+}
+function validateAspect(value, allowed) {
+    const aspect = value ?? "1:1";
+    if (!allowed.includes(aspect)) {
+        console.error(`Error: --aspect must be ${allowed.join(" | ")} (got "${aspect}").`);
+        process.exit(1);
+        throw new Error("unreachable");
+    }
+    return aspect;
+}
+async function runCreativeText(engine, text, flags, who) {
+    const aspect = validateAspect(flagString(flags, "aspect"), ["1:1", "4:5", "9:16"]);
+    const variations = flagInt(flags, "variations");
+    const name = flagString(flags, "name");
+    const steering = flagString(flags, "steer") ?? flagString(flags, "direction");
+    const slug = who.workspaceSlug ?? who.workspaceId;
+    const hasCopy = !!text && text.trim().length >= 3;
+    const body = {
+        workspaceId: who.workspaceId,
+        engine,
+        ...(hasCopy ? { adText: text } : {}),
+        ...(steering ? { steering } : {}),
+        aspectRatio: aspect,
+        ...(variations !== undefined ? { variations } : {}),
+        ...(name ? { name } : {}),
+    };
+    console.log(`Read: ${hasCopy ? "finished copy" : "steering-only"} → creative ${engine} (aspect ${aspect}) for ${slug}.`);
+    const res = await apiPost("/api/creative-suite/run", body, {
+        ccCommand: `exodus image --type ${engine}`,
+    });
+    if (!res.ok) {
+        console.error(formatError(res));
+        process.exit(1);
+        return;
+    }
+    console.log("");
+    console.log(`✓ image run started (creative ${engine})`);
+    console.log(`  runId:        ${res.data.runId}`);
+    if (res.data.triggerRunId)
+        console.log(`  triggerRunId: ${res.data.triggerRunId}`);
+    console.log(`  dashboard:    ${getDashboardUrl()}/creative-suite/runs/${res.data.runId}`);
+    console.log("");
+    console.log(`Poll: exodus creative status --id ${res.data.runId}`);
+}
+async function runRefMatch(flags, who) {
+    const refsRaw = flagString(flags, "refs");
+    if (!refsRaw) {
+        console.error("Error: ref-match requires --refs <id,id,...> (creativeSuiteImages ids from the library).");
+        process.exit(1);
+        return;
+    }
+    const referenceImageIds = refsRaw.split(",").map((s) => s.trim()).filter(Boolean);
+    if (referenceImageIds.length === 0) {
+        console.error("Error: --refs must contain at least one non-empty id.");
+        process.exit(1);
+        return;
+    }
+    const aspect = validateAspect(flagString(flags, "aspect"), ["1:1", "4:5", "9:16"]);
+    const variations = flagInt(flags, "variations");
+    const subject = flagString(flags, "subject");
+    const name = flagString(flags, "name");
+    const slug = who.workspaceSlug ?? who.workspaceId;
+    const body = {
+        workspaceId: who.workspaceId,
+        engine: "ref-match",
+        referenceImageIds,
+        aspectRatio: aspect,
+        ...(variations !== undefined ? { variations } : {}),
+        ...(subject ? { subject } : {}),
+        ...(name ? { name } : {}),
+    };
+    console.log(`Read: reference match → creative ref-match (${referenceImageIds.length} refs, aspect ${aspect}) for ${slug}.`);
+    const res = await apiPost("/api/creative-suite/run", body, {
+        ccCommand: "exodus image --type ref-match",
+    });
+    if (!res.ok) {
+        console.error(formatError(res));
+        process.exit(1);
+        return;
+    }
+    console.log("");
+    console.log(`✓ image run started (creative ref-match)`);
+    console.log(`  runId:        ${res.data.runId}`);
+    if (res.data.triggerRunId)
+        console.log(`  triggerRunId: ${res.data.triggerRunId}`);
+    console.log(`  dashboard:    ${getDashboardUrl()}/creative-suite/runs/${res.data.runId}`);
+    console.log("");
+    console.log(`Poll: exodus creative status --id ${res.data.runId}`);
+}
+async function runTemplate(text, flags, who) {
+    if (!who.userId) {
+        console.error("Error: whoami did not return a userId (required for template runs).");
+        process.exit(1);
+        return;
+    }
+    const aspect = validateAspect(flagString(flags, "aspect"), ["1:1", "9:16"]);
+    const requestedImageCount = flagInt(flags, "variations");
+    const slug = who.workspaceSlug ?? who.workspaceId;
+    const steering = flagString(flags, "steer") ?? flagString(flags, "direction");
+    const realisticFlag = flags["realistic"] === true
+        || flagString(flags, "realism") === "realistic";
+    const body = {
+        workspaceId: who.workspaceId,
+        submittedBy: who.userId,
+        mode: "auto",
+        renderMode: "images",
+        inputAds: text,
+        aspectRatio: aspect,
+        model: "gpt-image-2",
+        realismMode: realisticFlag ? "realistic" : "off",
+        ...(steering ? { steering } : {}),
+        ...(requestedImageCount !== undefined ? { requestedImageCount } : {}),
+    };
+    console.log(`Read: finished copy → template (auto mode, aspect ${aspect}) for ${slug}.`);
+    const res = await apiPost("/api/creative-suite-template/run", body, {
+        ccCommand: "exodus image --type template",
+    });
+    if (!res.ok) {
+        console.error(formatError(res));
+        process.exit(1);
+        return;
+    }
+    console.log("");
+    console.log(`✓ image run started (template)`);
+    console.log(`  runId:        ${res.data.runId}`);
+    if (res.data.triggerRunId)
+        console.log(`  triggerRunId: ${res.data.triggerRunId}`);
+    console.log(`  dashboard:    ${getDashboardUrl()}/creative-suite/template/sessions/${res.data.runId}`);
+    console.log("");
+    console.log("Status updates render live in the dashboard (no CLI status endpoint for template yet).");
+}
+export async function run(flags) {
+    const from = flagString(flags, "from");
+    if (from === "idea") {
+        console.error("image needs finished copy to render. You only have an idea — write copy first:");
+        console.error('  exodus genesis run --brief "<your idea>"');
+        console.error("Then come back and run image on the resulting copy.");
+        process.exit(1);
+        return;
+    }
+    const text = flagString(flags, "ad") ?? flagString(flags, "input");
+    const steering = flagString(flags, "steer") ?? flagString(flags, "direction");
+    const refs = flagString(flags, "refs");
+    const engine = resolveEngine(flags, refs, text);
+    if (engine === "ref-match") {
+        if (!refs || refs.split(",").map((s) => s.trim()).filter(Boolean).length === 0) {
+            console.error("Error: ref-match requires --refs <id,id,...> (creativeSuiteImages ids from the library).");
+            process.exit(1);
+            return;
+        }
+    }
+    else if (!text || text.trim().length < 3) {
+        const hasSteering = !!steering && steering.trim().length > 0;
+        if (!(engine === "native" && hasSteering)) {
+            console.error(`Error: ${engine} needs ad copy — pass --ad "<text>" (or --input "<text>", min 3 chars).`);
+            console.error('  (For a no-copy native render, pass --steer "<direction>". For a reference-image match, use --type ref-match --refs <id,id,...>.)');
+            process.exit(1);
+            return;
+        }
+    }
+    const who = await resolveWhoami();
+    if (engine === "ref-match") {
+        await runRefMatch(flags, who);
+        return;
+    }
+    if (engine === "template") {
+        await runTemplate(text, flags, who);
+        return;
+    }
+    await runCreativeText(engine, (text ?? ""), flags, who);
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,13 @@
+export declare const helpText: string;
+export interface InitResult {
+    existing: boolean;
+    envCreated: boolean;
+    skills: string[];
+}
+export declare function scaffoldInit(root: string): InitResult;
+export declare function syncBrands(root: string): Promise<{
+    synced: string[];
+} | {
+    skipped: "no-key" | "api-error";
+}>;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import path from "node:path";
+import { writeEnvScaffold, ensureGitignore, writeSkills, writeReferences, ensureBaseDirs, } from "../lib/scaffold.js";
+import { loadWorkspaceEnv } from "../lib/load-env.js";
+import { ensureBrandDir } from "../lib/layout.js";
+export const helpText = `
+exodus init — Set up (or refresh) an Exodus workspace in the current folder
+
+Usage:
+  npx @aicopycoders/exodus init        Scaffold the workspace + install skills
+  npx @aicopycoders/exodus init --root <dir>   Target a specific folder
+
+Run this in a fresh, empty folder. It creates the workspace layout, writes the
+Exodus + Genesis skills into .claude/skills/, scaffolds a comment-only .env, and
+prints the dashboard paste step. Safe to re-run: it never overwrites your .env
+or brand folders — re-running refreshes the skills and catches up new brands.
+`.trim();
+export function scaffoldInit(root) {
+    const existing = fs.existsSync(path.join(root, ".env"));
+    ensureBaseDirs(root);
+    const { created: envCreated } = writeEnvScaffold(root);
+    ensureGitignore(root);
+    const skills = writeSkills(root);
+    writeReferences(root);
+    return { existing, envCreated, skills };
+}
+export async function syncBrands(root) {
+    loadWorkspaceEnv(root);
+    if (!process.env.EXODUS_API_KEY)
+        return { skipped: "no-key" };
+    try {
+        const { fetchMineOrThrow, refreshBrandProfileMd } = await import("./brand.js");
+        const mine = await fetchMineOrThrow();
+        const synced = [];
+        for (const brand of mine.brands ?? []) {
+            ensureBrandDir(root, { slug: brand.slug, name: brand.name });
+            await refreshBrandProfileMd({ slug: brand.slug });
+            synced.push(brand.slug);
+        }
+        return { synced };
+    }
+    catch {
+        return { skipped: "api-error" };
+    }
+}
+export async function run(flags) {
+    const root = typeof flags.root === "string" ? path.resolve(flags.root) : process.cwd();
+    const r = scaffoldInit(root);
+    console.log(`${r.existing ? "Refreshed" : "Initialized"} Exodus workspace at ${root}`);
+    console.log(`  Installed ${r.skills.length} skills into .claude/skills/`);
+    const brands = await syncBrands(root);
+    if ("synced" in brands && brands.synced.length) {
+        console.log(`  Synced ${brands.synced.length} brand folder(s): ${brands.synced.join(", ")}`);
+    }
+    else if ("skipped" in brands && brands.skipped === "api-error") {
+        console.log("  (Skipped brand sync — couldn't reach the API; check your key/URL, then re-run.)");
+    }
+    if (r.envCreated) {
+        console.log("");
+        console.log("NEXT STEP — add your keys:");
+        console.log("  1. Open your Exodus dashboard -> Settings -> Claude Code.");
+        console.log('  2. Click "Copy .env block".');
+        console.log(`  3. Paste it into ${path.join(root, ".env")} below the comment, save.`);
+        console.log("  4. Restart this Claude Code session (or /clear) so the skills load.");
+    }
+    else {
+        console.log("  .env already present — left untouched.");
+        console.log("  Restart the session (or /clear) to pick up refreshed skills.");
+    }
+}

package/dist/commands/keys.d.ts

@@ -0,0 +1,2 @@
+export declare const helpText: string;
+export declare function run(): Promise<void>;