hyper-animator-codex 0.6.0 → 0.7.1

package/skills/hyper-animator-codex/scripts/detect_project_files.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+import { readdir, readFile, stat } from "node:fs/promises";
+import { resolve, join } from "node:path";
+
+const OUTLINE_NAMES = new Set(["outline.md", "outline.json", "outline.txt"]);
+const NARRATION_NAMES = new Set(["narration.json", "narration.md", "narration.txt"]);
+const TEXT_EXTENSIONS = new Set([".md", ".txt"]);
+
+function requireValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+
+function parseArgs(args) {
+  const parsed = { dir: process.cwd(), pretty: false };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--dir") {
+      parsed.dir = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--pretty") {
+      parsed.pretty = true;
+    } else if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function extensionOf(name) {
+  const dot = name.lastIndexOf(".");
+  return dot === -1 ? "" : name.slice(dot).toLowerCase();
+}
+
+async function readTopLevelFiles(root) {
+  const entries = await readdir(root, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isFile())
+    .map((entry) => ({
+      name: entry.name,
+      lowerName: entry.name.toLowerCase(),
+      path: join(root, entry.name),
+      extension: extensionOf(entry.name),
+    }));
+}
+
+async function classifyJson(file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(file.path, "utf8"));
+  } catch {
+    return null;
+  }
+
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed.scenes)) {
+    const hasNarration = parsed.scenes.some((scene) => typeof scene?.narration === "string" && scene.narration.trim());
+    if (hasNarration) {
+      return { type: "narration", reason: "json-scenes-narration" };
+    }
+  }
+
+  return null;
+}
+
+async function classifyText(file) {
+  if (!TEXT_EXTENSIONS.has(file.extension)) {
+    return null;
+  }
+
+  const text = await readFile(file.path, "utf8");
+  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const outlineLines = lines.filter((line) => /^#{1,4}\s+\S/.test(line) || /^[-*]\s+\S/.test(line) || /^\d+[.)]\s+\S/.test(line));
+
+  if (outlineLines.length >= 2 || (lines.length >= 3 && outlineLines.length >= 1)) {
+    return { type: "outline", reason: "outline-text-structure" };
+  }
+
+  return null;
+}
+
+function pickSingle(candidates) {
+  return candidates.length === 1 ? candidates[0] : null;
+}
+
+async function detectProjectFiles(rootDir) {
+  const root = resolve(rootDir);
+  const rootStat = await stat(root);
+  if (!rootStat.isDirectory()) {
+    throw new Error(`--dir must be a directory: ${root}`);
+  }
+
+  const files = await readTopLevelFiles(root);
+  const fixedOutlines = files
+    .filter((file) => OUTLINE_NAMES.has(file.lowerName))
+    .map((file) => ({ path: file.path, name: file.name, reason: "fixed-name" }));
+  const fixedNarrations = files
+    .filter((file) => NARRATION_NAMES.has(file.lowerName))
+    .map((file) => ({ path: file.path, name: file.name, reason: "fixed-name" }));
+
+  const candidates = {
+    outline: [...fixedOutlines],
+    narration: [...fixedNarrations],
+  };
+
+  if (fixedOutlines.length === 0 || fixedNarrations.length === 0) {
+    for (const file of files) {
+      if (OUTLINE_NAMES.has(file.lowerName) || NARRATION_NAMES.has(file.lowerName)) {
+        continue;
+      }
+
+      const classification = file.extension === ".json"
+        ? await classifyJson(file)
+        : await classifyText(file);
+
+      if (!classification) {
+        continue;
+      }
+
+      if (classification.type === "outline" && fixedOutlines.length === 0) {
+        candidates.outline.push({ path: file.path, name: file.name, reason: classification.reason });
+      } else if (classification.type === "narration" && fixedNarrations.length === 0) {
+        candidates.narration.push({ path: file.path, name: file.name, reason: classification.reason });
+      }
+    }
+  }
+
+  const outline = pickSingle(candidates.outline);
+  const narration = pickSingle(candidates.narration);
+
+  return {
+    ok: true,
+    root,
+    outline,
+    narration,
+    candidates,
+    ambiguous: candidates.outline.length > 1 || candidates.narration.length > 1,
+  };
+}
+
+function printHelp() {
+  console.log(`Usage:
+  node scripts/detect_project_files.mjs [--dir <path>] [--pretty]
+
+Options:
+  --dir <path>   Project directory to scan, default cwd
+  --pretty       Pretty-print JSON output
+`);
+}
+
+async function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.help) {
+      printHelp();
+      return;
+    }
+
+    const result = await detectProjectFiles(options.dir);
+    console.log(JSON.stringify(result, null, options.pretty ? 2 : 0));
+  } catch (error) {
+    console.log(JSON.stringify({
+      ok: false,
+      error: {
+        message: error.message,
+      },
+    }, null, 2));
+    process.exitCode = 1;
+  }
+}
+
+main();