@impractical-ai/motion 0.1.16 → 0.1.18

package/dist/commands-Y723HSJI.js

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+import {
+  setup
+} from "./chunk-TETWFQPX.js";
+import "./chunk-XWCSIM4L.js";
+import {
+  invoke,
+  invokeAt,
+  jobStatus,
+  loadConfig,
+  requireConfig,
+  saveConfig,
+  studioLink,
+  waitForJobs
+} from "./chunk-FTSZCIMV.js";
+import "./chunk-2GCSX3YN.js";
+import "./chunk-77HVPD4G.js";
+
+// src/commands.ts
+import { writeFileSync } from "node:fs";
+
+// src/media.ts
+import { readFileSync, statSync } from "node:fs";
+import { basename, extname } from "node:path";
+var MAX_UPLOAD_BYTES = 3e8;
+var MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime"
+};
+function mediaType(filePath) {
+  const type = MIME_BY_EXT[extname(filePath).toLowerCase()];
+  if (!type) {
+    throw new Error(
+      `Unsupported media type for ${basename(filePath)} \u2014 use PNG, JPEG, GIF, WebP, SVG, MP4, WebM, or MOV`
+    );
+  }
+  return type;
+}
+async function uploadAsset(input) {
+  const { projectId, draftId, filePath, log } = input;
+  const bytes = statSync(filePath).size;
+  if (bytes > MAX_UPLOAD_BYTES) throw new Error("Media must be 300 MB or smaller");
+  const contentType = mediaType(filePath);
+  const fileName = basename(filePath);
+  const upload2 = await invoke("prepare-upload", {
+    projectId,
+    draftId,
+    fileName,
+    contentType,
+    bytes
+  });
+  const form = new FormData();
+  form.append("cacheControl", "3600");
+  form.append("", new File([new Uint8Array(readFileSync(filePath))], fileName, { type: contentType }));
+  const response = await fetch(upload2.signedUrl, {
+    method: "PUT",
+    headers: { "x-upsert": "false" },
+    body: form
+  });
+  if (!response.ok) {
+    throw new Error(`Upload failed (${response.status}): ${await response.text()}`);
+  }
+  log?.(`uploaded ${fileName} (${(bytes / 1e6).toFixed(1)} MB)`);
+  const registered = await invoke("register-asset", {
+    projectId,
+    draftId: null,
+    storagePath: upload2.storagePath,
+    fileName,
+    contentType,
+    bytes
+  });
+  return registered.assetId;
+}
+
+// ../src/shared/video-clone-command.ts
+var TOKEN = /^[A-Za-z0-9_-]{43}$/;
+var SHARE_HOSTS = /* @__PURE__ */ new Set(["impractical.ai", "www.impractical.ai", "impractical-video-shares.vercel.app"]);
+function videoShareToken(source) {
+  if (TOKEN.test(source)) return source;
+  try {
+    const url = new URL(source);
+    const token = url.pathname.match(/^\/v\/([A-Za-z0-9_-]{43})\/?$/)?.[1];
+    if (url.protocol === "https:" && SHARE_HOSTS.has(url.host) && !url.username && !url.password && !url.search && !url.hash && token) return token;
+  } catch {
+  }
+  throw new Error("Use an Impractical video share URL: https://impractical.ai/v/<token>");
+}
+
+// src/clone-video-project.ts
+async function cloneVideoProject(source, json = false) {
+  const token = videoShareToken(source);
+  const result = await invoke("video-shares", { action: "clone", token });
+  const url = studioLink(requireConfig().appUrl, result.projectId);
+  if (json) {
+    console.log(JSON.stringify({ ...result, url }, null, 2));
+    return;
+  }
+  console.log(result.alreadyForked ? "Your editable copy is ready." : "Copied the project into your workspace.");
+  console.log(`Open: ${url}`);
+  console.log(`Project: ${result.projectId}`);
+  console.log("After restarting your agent, paste:");
+  console.log(`Use Impractical to open project ${result.projectId} and help me iterate on this video.`);
+}
+
+// src/video-sharing.ts
+import { openAsBlob } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { basename as basename2, extname as extname2 } from "node:path";
+async function shareVideo(rest, flags) {
+  const config = requireConfig();
+  const request = async (body) => {
+    const response = await fetch(
+      `${config.supabaseUrl.replace(/\/$/, "")}/functions/v1/video-shares`,
+      {
+        method: body ? "POST" : "GET",
+        redirect: "error",
+        signal: AbortSignal.timeout(45e3),
+        headers: {
+          authorization: `Bearer ${config.apiKey}`,
+          ...config.workspace ? { "x-impractical-workspace": config.workspace } : {},
+          "content-type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0
+      }
+    );
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(data.error || `Video sharing failed (${response.status})`);
+    return data;
+  };
+  if (rest[0] === "list") {
+    console.log(JSON.stringify(await request(), null, 2));
+    return;
+  }
+  if (rest[0] === "revoke") {
+    if (!rest[1]) throw new Error("Usage: impractical share revoke <share-id>");
+    await request({ action: "revoke", id: rest[1] });
+    console.log("Share link revoked. Already-open videos may remain playable for up to 5 minutes.");
+    return;
+  }
+  const allowEditing = rest[0] === "allow-editing" || rest[0] === "attach";
+  const viewOnly = rest[0] === "view-only" || rest[0] === "detach";
+  if (allowEditing || viewOnly) {
+    if (!rest[1] || allowEditing && typeof flags.project !== "string") {
+      throw new Error("Usage: impractical share allow-editing <share-id> --project <id> | share view-only <share-id>");
+    }
+    await request({ action: "attach-project", id: rest[1], projectId: viewOnly ? null : flags.project });
+    console.log(allowEditing ? "Editing allowed for this link. Recipients can make their own editable copy." : "This link is now view only. Future project copies are disabled; existing recipient copies remain theirs.");
+    return;
+  }
+  const filePath = rest[0];
+  if (!filePath || extname2(filePath).toLowerCase() !== ".mp4") {
+    throw new Error(
+      'Usage: impractical share ./video.mp4 [--title "A video for Acme"] [--message "..."] [--references ./public-brand.json] [--project <id>] [--expires-in 7] [--json]'
+    );
+  }
+  const info = await stat(filePath);
+  if (!info.isFile() || info.size < 16 || info.size > 3e8) {
+    throw new Error("Choose an MP4 up to 300 MB");
+  }
+  const days = flags["expires-in"] === void 0 ? null : Number(flags["expires-in"]);
+  if (days !== null && (!Number.isFinite(days) || days <= 0 || days > 3650)) {
+    throw new Error("--expires-in must be a number of days between 0 and 3650");
+  }
+  const file = await openAsBlob(filePath, { type: "video/mp4" });
+  const header = new Uint8Array(await file.slice(0, 16).arrayBuffer());
+  if (String.fromCharCode(...header.slice(4, 8)) !== "ftyp") {
+    throw new Error("This file does not have an MP4 header");
+  }
+  let references;
+  if (typeof flags.references === "string") {
+    const metadataFile = await stat(flags.references);
+    if (!metadataFile.isFile() || metadataFile.size > 4e6) throw new Error("Public references must be a JSON file up to 4 MB");
+    references = JSON.parse(await readFile(flags.references, "utf8"));
+  }
+  const prepared = await request({
+    action: "prepare",
+    bytes: info.size,
+    title: typeof flags.title === "string" ? flags.title : basename2(filePath, extname2(filePath)).slice(0, 160),
+    message: typeof flags.message === "string" ? flags.message : "",
+    expiresAt: days === null ? null : new Date(Date.now() + days * 864e5).toISOString(),
+    ...references === void 0 ? {} : { references },
+    ...typeof flags.project === "string" ? { projectId: flags.project } : {}
+  });
+  try {
+    const form = new FormData();
+    form.append("cacheControl", "0");
+    form.append("", file, basename2(filePath));
+    const response = await fetch(prepared.upload.signedUrl, {
+      method: "PUT",
+      body: form,
+      headers: { "x-upsert": "false" },
+      redirect: "error",
+      signal: AbortSignal.timeout(15 * 6e4)
+    });
+    await response.body?.cancel();
+    if (!response.ok) throw new Error(`MP4 upload failed (${response.status}). Please try again`);
+    const share = await request({ action: "complete", id: prepared.id });
+    console.log(flags.json ? JSON.stringify(share, null, 2) : share.url);
+  } catch (error) {
+    await request({ action: "revoke", id: prepared.id }).catch(() => {
+    });
+    throw error;
+  }
+}
+
+// src/commands.ts
+var flagString = (flags, name) => {
+  const value = flags[name];
+  if (Array.isArray(value)) return value[value.length - 1];
+  return typeof value === "string" ? value : void 0;
+};
+var flagBool = (flags, name) => flags[name] === true;
+var out = (line) => console.log(line);
+async function setup2(flags) {
+  const source = flagString(flags, "from");
+  if (source !== void 0) videoShareToken(source);
+  const claude = flagBool(flags, "claude");
+  const agent = flagBool(flags, "agent");
+  await setup({
+    installAgentMcp: agent,
+    installAgentSkills: agent,
+    installClaudePlugin: claude,
+    openBrowser: !flagBool(flags, "no-open"),
+    log: out
+  });
+  if (source !== void 0) await cloneVideoProject(source);
+}
+async function clone(positional, flags) {
+  if (positional.length !== 1) throw new Error("Usage: impractical clone <video-share-url> [--json]");
+  await cloneVideoProject(positional[0], flagBool(flags, "json"));
+}
+async function login(flags) {
+  const patch = {};
+  const key = flagString(flags, "key");
+  const supabaseUrl = flagString(flags, "supabase-url");
+  const appUrl = flagString(flags, "app-url");
+  if (key) patch.apiKey = key;
+  if (supabaseUrl) patch.supabaseUrl = supabaseUrl;
+  if (appUrl) patch.appUrl = appUrl;
+  const config = { ...loadConfig(), ...patch };
+  if (!config.apiKey || !config.supabaseUrl) {
+    out("Missing API key. Run: npx --yes @impractical-ai/motion setup --agent");
+    process.exitCode = 1;
+    return;
+  }
+  const snapshot = await invokeAt(
+    config.supabaseUrl,
+    "workspace-bootstrap",
+    {},
+    config.apiKey,
+    void 0,
+    // IMPRACTICAL_WORKSPACE, for a multi-workspace key; unset sends nothing.
+    config.workspace
+  );
+  if (Object.keys(patch).length) saveConfig(patch);
+  out(`org: ${snapshot.orgId}`);
+  out(`plan: ${snapshot.plan} (access: ${snapshot.hasAccess ? "yes" : "no"})`);
+  if (snapshot.accessUntil) out(`access until: ${snapshot.accessUntil}`);
+  out("Logged in. Credentials stored in ~/.impractical/config.json");
+}
+async function whoami(_flags) {
+  const snapshot = await invoke("workspace-bootstrap");
+  out(`org: ${snapshot.orgId}`);
+  out(`plan: ${snapshot.plan} (access: ${snapshot.hasAccess ? "yes" : "no"})`);
+  if (snapshot.accessUntil) out(`access until: ${snapshot.accessUntil}`);
+}
+async function keys(positional, flags) {
+  const action = positional[0];
+  if (action === "list" || !action) {
+    const result = await invoke("create-api-key", {
+      action: "list"
+    });
+    for (const key of result.keys) {
+      out(
+        `${key.id}  ${key.keyPrefix}\u2026  "${key.name}"  created ${key.createdAt}` + (key.revokedAt ? "  REVOKED" : key.lastUsedAt ? `  last used ${key.lastUsedAt}` : "  never used")
+      );
+    }
+    if (!result.keys.length) out("No API keys. Create one from the studio web app.");
+    return;
+  }
+  if (action === "revoke") {
+    const id = positional[1] ?? flagString(flags, "id");
+    if (!id) throw new Error("Usage: impractical keys revoke <keyId>");
+    await invoke("create-api-key", { action: "revoke", id });
+    out(`Revoked ${id}`);
+    return;
+  }
+  throw new Error(`Unknown keys action "${action}" (use: list, revoke)`);
+}
+function reportJobs(rows, slugByDraft) {
+  for (const row of rows) {
+    const label = slugByDraft?.get(row.draft_id) ?? row.draft_id;
+    if (row.status === "completed") {
+      out(`${label}: completed (revision ${row.revision ?? "?"})`);
+      if (row.master?.url) out(`  master: ${row.master.url}`);
+    } else {
+      out(`${label}: ${row.status}${row.error ? ` \u2014 ${row.error}` : ""}`);
+    }
+  }
+}
+async function status(flags) {
+  const projectId = flagString(flags, "project");
+  const jobsFlag = flagString(flags, "jobs");
+  if (projectId) {
+    const result = await invoke("list-projects", { projectId });
+    out(`${result.project.name} (${result.project.id})`);
+    for (const draft of result.project.drafts) {
+      out(`  draft ${draft.id} (${draft.slug}) \u2014 ${draft.status}, revision ${draft.source_revision}`);
+    }
+    for (const job of result.project.jobs.slice(0, 10)) {
+      out(`  job ${job.id} [${job.draft_id}] \u2014 ${job.status}${job.stage ? ` (${job.stage})` : ""}${job.error ? ` \u2014 ${job.error}` : ""}`);
+    }
+    return;
+  }
+  if (!jobsFlag) throw new Error("Usage: impractical status --project <id> | --jobs <id,id> [--wait]");
+  const jobIds = jobsFlag.split(",").map((id) => id.trim());
+  if (flagBool(flags, "wait")) {
+    const seen = /* @__PURE__ */ new Map();
+    const rows = await waitForJobs(jobIds, (latest) => {
+      for (const row of latest) {
+        const line = `${row.id}: ${row.status}${row.stage ? ` \u2014 ${row.stage}` : ""}`;
+        if (seen.get(row.id) !== line) {
+          seen.set(row.id, line);
+          out(line);
+        }
+      }
+    });
+    reportJobs(rows);
+    if (rows.some((row) => row.status !== "completed")) process.exitCode = 1;
+    return;
+  }
+  reportJobs(await jobStatus(jobIds));
+}
+async function exportDraft(positional, flags) {
+  const draftId = positional[0];
+  if (!draftId) {
+    throw new Error("Usage: impractical export <draftId> [--wait] [--out video.mp4]");
+  }
+  const started = await invoke("start-export", { draftId });
+  out(`Export started (job ${started.jobId}).`);
+  if (!flagBool(flags, "wait") && !flagString(flags, "out")) {
+    out(`Follow with: impractical status --jobs ${started.jobId} --wait`);
+    return;
+  }
+  const rows = await waitForJobs([started.jobId], () => {
+  }, 36e5);
+  const row = rows[0];
+  if (row?.status !== "completed" || !row.master?.url) {
+    throw new Error(`Export ${row?.status ?? "failed"}${row?.error ? `: ${row.error}` : ""}`);
+  }
+  out(`master: ${row.master.url}`);
+  const outPath = flagString(flags, "out");
+  if (outPath) {
+    const response = await fetch(row.master.url);
+    if (!response.ok) throw new Error(`Download failed (${response.status})`);
+    writeFileSync(outPath, new Uint8Array(await response.arrayBuffer()));
+    out(`Saved ${(row.master.bytes / 1e6).toFixed(1)} MB to ${outPath}`);
+  }
+}
+async function upload(positional, flags) {
+  const filePath = positional[0];
+  const projectId = flagString(flags, "project");
+  const draftId = flagString(flags, "draft");
+  if (!filePath || !projectId || !draftId) {
+    throw new Error("Usage: impractical upload <file> --project <projectId> --draft <draftId>");
+  }
+  const assetId = await uploadAsset({ projectId, draftId, filePath, log: out });
+  out(`assetId: ${assetId}`);
+}
+async function link(positional, _flags) {
+  const config = requireConfig();
+  const [projectId, slug] = positional;
+  if (!projectId) throw new Error("Usage: impractical link <projectId> [draftSlug]");
+  out(studioLink(config.appUrl, projectId, slug));
+}
+async function brand(positional, flags) {
+  const action = positional[0];
+  if (action === "extract") {
+    const url = positional[1];
+    if (!url) throw new Error("Usage: impractical brand extract <url> [--wait]");
+    const started = await invoke("brand-extraction", {
+      action: "start",
+      url,
+      ...flagBool(flags, "reextract") ? { reextract: true } : {}
+    });
+    out(`Extraction started for "${started.slug}" (run ${started.job}).`);
+    if (!flagBool(flags, "wait")) return;
+    const deadline = Date.now() + 15e5;
+    let lastLine = "";
+    while (true) {
+      if (Date.now() >= deadline) throw new Error("Brand extraction timed out");
+      const statusResult = await invoke("brand-extraction", { action: "status", job: started.job });
+      const line = `${statusResult.status}${statusResult.pct != null ? ` ${statusResult.pct}%` : ""}${statusResult.stage ? ` \u2014 ${statusResult.stage}` : ""}`;
+      if (line !== lastLine) {
+        lastLine = line;
+        out(line);
+      }
+      if (statusResult.status === "done") {
+        out(`Brand kit saved as "${statusResult.slug ?? started.slug}". Use it with: impractical generate --brand ${statusResult.slug ?? started.slug} ...`);
+        return;
+      }
+      if (statusResult.status === "failed" || statusResult.error) {
+        throw new Error(`Brand extraction failed${statusResult.error ? `: ${statusResult.error}` : ""}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+    }
+  }
+  if (action === "list" || !action) {
+    const result = await invoke("brand-kits", {
+      action: "list"
+    });
+    for (const kit of result.brands) out(`${kit.slug}${kit.name ? `  (${kit.name})` : ""}`);
+    if (!result.brands.length) out("No brand kits yet. Extract one with: impractical brand extract <url> --wait");
+    return;
+  }
+  if (action === "get") {
+    const slug = positional[1];
+    if (!slug) throw new Error("Usage: impractical brand get <slug>");
+    const result = await invoke("brand-kits", { action: "get", slug });
+    out(JSON.stringify(result.brand, null, 2));
+    return;
+  }
+  throw new Error(`Unknown brand action "${action}" (use: extract, list, get)`);
+}
+function validateMeteredCommand(command, positional, flags) {
+  if (command === "status" && !flagString(flags, "project") && !flagString(flags, "jobs")) {
+    throw new Error("Usage: impractical status --project <id> | --jobs <id,id> [--wait]");
+  }
+  if (command === "export" && !positional[0]) {
+    throw new Error("Usage: impractical export <draftId> [--wait] [--out video.mp4]");
+  }
+  if (command === "upload" && (!positional[0] || !flagString(flags, "project") || !flagString(flags, "draft"))) {
+    throw new Error("Usage: impractical upload <file> --project <projectId> --draft <draftId>");
+  }
+  if (command === "brand") {
+    const action = positional[0];
+    if (action === "extract" && !positional[1]) {
+      throw new Error("Usage: impractical brand extract <url> [--wait]");
+    }
+    if (action === "get" && !positional[1]) {
+      throw new Error("Usage: impractical brand get <slug>");
+    }
+    if (action && !["extract", "list", "get"].includes(action)) {
+      throw new Error(`Unknown brand action "${action}" (use: extract, list, get)`);
+    }
+  }
+}
+export {
+  brand,
+  clone,
+  exportDraft,
+  keys,
+  link,
+  login,
+  setup2 as setup,
+  shareVideo,
+  status,
+  upload,
+  validateMeteredCommand,
+  whoami
+};

package/dist/draft-check-BRVH77WB.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import {
+  saveChecks
+} from "./chunk-JSEDAJHM.js";
+import "./chunk-QQ6NYC74.js";
+import "./chunk-XWCSIM4L.js";
+import {
+  invoke
+} from "./chunk-FTSZCIMV.js";
+import "./chunk-2GCSX3YN.js";
+import "./chunk-77HVPD4G.js";
+
+// src/mcp/draft-check.ts
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+var DRAFT_FILE = /\.(tsx?|jsx?|css|json|html)$/;
+var MAX_FILE = 2e6;
+function readDraft(root) {
+  const files = {};
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && DRAFT_FILE.test(entry.name) && statSync(full).size <= MAX_FILE) {
+        files[relative(root, full).split(sep).join("/")] = readFileSync(full, "utf8");
+      }
+    }
+  };
+  walk(root);
+  return files;
+}
+async function draftCheck(dir, changed) {
+  if (!dir) throw new Error("Usage: impractical draft-check --dir <draft folder> [--changed <path> ...]");
+  const root = resolve(dir);
+  const merged = readDraft(root);
+  const written = {};
+  for (const path of changed.length ? changed : Object.keys(merged)) {
+    const rel = relative(root, resolve(root, path)).split(sep).join("/");
+    if (rel in merged) written[rel] = merged[rel];
+  }
+  if (!Object.keys(written).length) return "";
+  const checks = await saveChecks({ invoke }, merged, written);
+  return [
+    checks.preflightError ? `BUILD PREFLIGHT FAILED: this version of the draft won't build. Fix it and save again:
+${checks.preflightError}` : "",
+    ...checks.notes,
+    checks.advisory
+  ].filter(Boolean).join("\n\n");
+}
+export {
+  draftCheck
+};

package/dist/guidance-SMXXX463.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import {
+  buildServerInstructions
+} from "./chunk-ZEVR6SM6.js";
+import "./chunk-M6427SHW.js";
+import {
+  VIDEO_UI_GUIDE,
+  applyLocalMotionLibraryOverride,
+  craftLabEnabled,
+  gateReformEnabled,
+  motionLabEnabled,
+  phasedFlowEnabled,
+  qualityLoopEnabled
+} from "./chunk-JSEDAJHM.js";
+import "./chunk-QQ6NYC74.js";
+import "./chunk-TETWFQPX.js";
+import "./chunk-XWCSIM4L.js";
+import {
+  invoke,
+  withMeteredCall
+} from "./chunk-FTSZCIMV.js";
+import "./chunk-2GCSX3YN.js";
+import "./chunk-77HVPD4G.js";
+
+// src/mcp/guidance.ts
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var assetsDir = () => {
+  const here = dirname(fileURLToPath(import.meta.url));
+  for (const candidate of [resolve(here, "../assets"), resolve(here, "../../assets")]) {
+    try {
+      readFileSync(join(candidate, "impractical/SKILL.md"));
+      return candidate;
+    } catch {
+    }
+  }
+  throw new Error("the CLI ships no assets folder");
+};
+var fileFor = (key) => `${key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase()}.md`;
+async function collectGuidance(call = (name, body) => withMeteredCall("motion_context", () => invoke(name, body))) {
+  const assets = assetsDir();
+  const files = [
+    {
+      file: "mcp-instructions.md",
+      title: "The MCP's instructions",
+      source: "cli/src/mcp/stdio.ts buildServerInstructions (what every MCP agent gets when it connects)",
+      text: buildServerInstructions({
+        qualityLoop: qualityLoopEnabled(),
+        motionLab: motionLabEnabled(),
+        craftLab: craftLabEnabled(),
+        gateReform: gateReformEnabled(),
+        phasedFlow: phasedFlowEnabled()
+      })
+    },
+    {
+      file: "impractical-skill.md",
+      title: "The impractical skill (the workflow)",
+      source: "cli/assets/impractical/SKILL.md",
+      text: readFileSync(join(assets, "impractical/SKILL.md"), "utf8")
+    },
+    {
+      file: "motion-standard.md",
+      title: "The motion standard (arrive, hold, exit)",
+      source: "docs/motion-standard.md (shipped as cli/assets/motion-standard.md)",
+      text: readFileSync(join(assets, "motion-standard.md"), "utf8")
+    },
+    {
+      file: "video-ui-guide.md",
+      title: "The video UI guide",
+      source: "cli/src/mcp/video-ui-guidelines.ts VIDEO_UI_GUIDE (motion_context leads with it)",
+      text: VIDEO_UI_GUIDE
+    }
+  ];
+  const library = await applyLocalMotionLibraryOverride(
+    await call("motion-library", { brief: "the house guidance", detail: "focused", limit: 1 }),
+    "focused"
+  );
+  const guidance = library.guidance ?? {};
+  for (const [key, value] of Object.entries(guidance)) {
+    if (typeof value !== "string" || !value.trim()) continue;
+    files.push({
+      file: fileFor(key),
+      title: `motion_context guidance: ${key}`,
+      source: `motion_context guidance.${key} (the motion-library function; built from the repo by scripts/build-motion-library.mjs)`,
+      text: value
+    });
+  }
+  return files;
+}
+async function guidanceCommand(dir, call) {
+  if (!dir) throw new Error("Usage: impractical guidance --dir <folder>");
+  const root = resolve(dir);
+  const files = await collectGuidance(call);
+  rmSync(root, { recursive: true, force: true });
+  mkdirSync(root, { recursive: true });
+  for (const { file, text } of files) writeFileSync(join(root, file), text.trimEnd() + "\n");
+  const index = [
+    "# Impractical guidance",
+    "",
+    "Everything an agent working through the Impractical MCP is told, one file each. Read every file before you",
+    "write a film. Where each comes from (to change one, change its source): docs/agent-guidance.md.",
+    "",
+    ...files.map(({ file, title, source }) => `- ${file}: ${title}. Source: ${source}.`),
+    ""
+  ].join("\n");
+  writeFileSync(join(root, "README.md"), index);
+  return files.map(({ file }) => file).join("\n");
+}
+export {
+  collectGuidance,
+  guidanceCommand
+};