@t3lnet/sceneforge 1.0.9 → 1.0.10

package/dist/index.js

@@ -180,8 +180,8 @@ function formatValidationError(error) {
   }
   const issues = error.issues;
   return issues.map((issue) => {
-    const path5 = issue.path.length ? issue.path.join(".") : "root";
-    return `${path5}: ${issue.message}`;
+    const path7 = issue.path.length ? issue.path.join(".") : "root";
+    return `${path7}: ${issue.message}`;
   }).join("; ");
 }
 function parseDemoDefinition(input) {
@@ -311,7 +311,7 @@ function createEmptyStep(id) {
   };
 }
 var SECRET_PATTERN = /\$\{(ENV|SECRET):([A-Za-z0-9_]+)\}/g;
-function resolveSecrets(value, resolver, path5 = "root") {
+function resolveSecrets(value, resolver, path7 = "root") {
   if (typeof value === "string") {
     if (!SECRET_PATTERN.test(value)) {
       return value;
@@ -320,20 +320,20 @@ function resolveSecrets(value, resolver, path5 = "root") {
     return value.replace(SECRET_PATTERN, (_match, _type, key) => {
       const resolved = resolver(key);
       if (resolved === void 0) {
-        throw new Error(`Missing secret for ${key} at ${path5}`);
+        throw new Error(`Missing secret for ${key} at ${path7}`);
       }
       return resolved;
     });
   }
   if (Array.isArray(value)) {
     return value.map(
-      (entry, index) => resolveSecrets(entry, resolver, `${path5}[${index}]`)
+      (entry, index) => resolveSecrets(entry, resolver, `${path7}[${index}]`)
     );
   }
   if (value && typeof value === "object") {
     const result = {};
     for (const [key, entry] of Object.entries(value)) {
-      result[key] = resolveSecrets(entry, resolver, `${path5}.${key}`);
+      result[key] = resolveSecrets(entry, resolver, `${path7}.${key}`);
     }
     return result;
   }
@@ -412,10 +412,10 @@ function createTypeAction(selector, text) {
     text
   };
 }
-function createNavigateAction(path5) {
+function createNavigateAction(path7) {
   return {
     action: "navigate",
-    path: path5
+    path: path7
   };
 }
 function createWaitAction(duration) {
@@ -839,7 +839,7 @@ function runCommand(command, args, options = {}) {
     cwd,
     maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES
   } = options;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn(command, args, { stdio, cwd });
     let stdout = "";
     let stderr = "";
@@ -858,7 +858,7 @@ function runCommand(command, args, options = {}) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve2({ stdout, stderr });
+        resolve3({ stdout, stderr });
         return;
       }
       const error = new Error(`${command} exited with code ${code}`);
@@ -889,7 +889,7 @@ async function probeMediaDurationMs(filePath) {
   return null;
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function getStatusCode(error) {
   if (!error || typeof error !== "object") return void 0;
@@ -2385,10 +2385,369 @@ async function discoverDemos(demoDir) {
   const files = await fs4.readdir(demoDir);
   return files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => path4.join(demoDir, f));
 }
+
+// context/template-loader.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path5.dirname(__filename);
+function getTemplatesDir() {
+  return path5.join(__dirname, "templates");
+}
+async function loadTemplate(category, name) {
+  const templatesDir = getTemplatesDir();
+  const filePath = path5.join(templatesDir, category, `${name}.md`);
+  try {
+    const content = await fs5.readFile(filePath, "utf-8");
+    return { name, content, category };
+  } catch (error) {
+    throw new Error(`Failed to load template ${category}/${name}: ${error}`);
+  }
+}
+async function loadTemplatesByCategory(category) {
+  const templatesDir = getTemplatesDir();
+  const categoryDir = path5.join(templatesDir, category);
+  try {
+    const files = await fs5.readdir(categoryDir);
+    const templates = [];
+    for (const file of files) {
+      if (file.endsWith(".md")) {
+        const name = file.replace(/\.md$/, "");
+        const template = await loadTemplate(category, name);
+        templates.push(template);
+      }
+    }
+    return templates;
+  } catch (error) {
+    throw new Error(`Failed to load templates from ${category}: ${error}`);
+  }
+}
+function interpolateVariables(content, variables) {
+  return content.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = variables[key];
+    if (value === void 0) {
+      return match;
+    }
+    return String(value);
+  });
+}
+function composeTemplates(templates, options) {
+  const { separator = "\n\n---\n\n", includeHeaders = false } = options ?? {};
+  return templates.map((template) => {
+    if (includeHeaders) {
+      return `<!-- Template: ${template.category}/${template.name} -->
+
+${template.content}`;
+    }
+    return template.content;
+  }).join(separator);
+}
+async function listTemplates() {
+  const templatesDir = getTemplatesDir();
+  const result = {
+    base: [],
+    stages: [],
+    skills: []
+  };
+  for (const category of ["base", "stages", "skills"]) {
+    const categoryDir = path5.join(templatesDir, category);
+    try {
+      const files = await fs5.readdir(categoryDir);
+      result[category] = files.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+    } catch {
+      result[category] = [];
+    }
+  }
+  return result;
+}
+async function templateExists(category, name) {
+  const templatesDir = getTemplatesDir();
+  const filePath = path5.join(templatesDir, category, `${name}.md`);
+  try {
+    await fs5.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// context/tool-formatter.ts
+var TOOL_CONFIGS = {
+  cursor: {
+    name: "Cursor",
+    description: "Cursor AI IDE with .cursorrules support",
+    combinedFile: ".cursorrules",
+    splitDir: ".cursor/rules",
+    splitFilePrefix: "",
+    fileExtension: ".md",
+    supportsSkills: true
+  },
+  copilot: {
+    name: "GitHub Copilot",
+    description: "GitHub Copilot with instructions file",
+    combinedFile: ".github/copilot-instructions.md",
+    splitDir: ".github/copilot",
+    splitFilePrefix: "",
+    fileExtension: ".md",
+    supportsSkills: false
+  },
+  claude: {
+    name: "Claude Code",
+    description: "Claude Code CLI with CLAUDE.md support",
+    combinedFile: "CLAUDE.md",
+    splitDir: ".claude/rules",
+    splitFilePrefix: "",
+    fileExtension: ".md",
+    supportsSkills: true
+  },
+  codex: {
+    name: "Codex",
+    description: "OpenAI Codex with AGENTS.md support",
+    combinedFile: "AGENTS.md",
+    splitDir: ".codex",
+    splitFilePrefix: "",
+    fileExtension: ".md",
+    supportsSkills: false
+  }
+};
+function getSupportedTools() {
+  return Object.keys(TOOL_CONFIGS);
+}
+function getToolConfig(tool) {
+  return TOOL_CONFIGS[tool];
+}
+function formatForTool(tool, content, options) {
+  const config = TOOL_CONFIGS[tool];
+  const { stage, includeToolHeader = true } = options ?? {};
+  const lines = [];
+  if (includeToolHeader) {
+    lines.push(`# SceneForge LLM Context`);
+    lines.push(``);
+    lines.push(`> Generated for ${config.name}`);
+    if (stage) {
+      lines.push(`> Stage: ${stage}`);
+    }
+    lines.push(``);
+    lines.push(`---`);
+    lines.push(``);
+  }
+  lines.push(content);
+  return lines.join("\n");
+}
+function getOutputPath(tool, format, outputDir, stageName) {
+  const config = TOOL_CONFIGS[tool];
+  if (format === "combined") {
+    return `${outputDir}/${config.combinedFile}`;
+  }
+  const fileName = stageName ? `${config.splitFilePrefix}${stageName}${config.fileExtension}` : `${config.splitFilePrefix}main${config.fileExtension}`;
+  return `${outputDir}/${config.splitDir}/${fileName}`;
+}
+function getSplitOutputPaths(tool, outputDir, stageNames) {
+  return stageNames.map((stage) => getOutputPath(tool, "split", outputDir, stage));
+}
+function formatStageName(stage) {
+  const stageMap = {
+    actions: "Stage 1: Action Generation",
+    scripts: "Stage 2: Script Writing",
+    balance: "Stage 3: Step Balancing",
+    rebalance: "Stage 4: Rebalancing"
+  };
+  return stageMap[stage] ?? stage;
+}
+function getStageFileName(stage) {
+  const stageFileMap = {
+    actions: "stage1-actions",
+    scripts: "stage2-scripts",
+    balance: "stage3-balancing",
+    rebalance: "stage4-rebalancing"
+  };
+  return stageFileMap[stage] ?? stage;
+}
+function isValidTool(tool) {
+  return tool in TOOL_CONFIGS;
+}
+function isValidFormat(format) {
+  return format === "combined" || format === "split";
+}
+
+// context/context-builder.ts
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
+async function buildContext(tool, stage, variables) {
+  const templates = [];
+  const baseTemplates = await loadTemplatesByCategory("base");
+  templates.push(...baseTemplates);
+  if (stage === "all") {
+    const stageTemplates = await loadTemplatesByCategory("stages");
+    templates.push(...stageTemplates);
+  } else {
+    const stageFileName = getStageFileName(stage);
+    try {
+      const stageTemplate = await loadTemplate("stages", stageFileName);
+      templates.push(stageTemplate);
+    } catch {
+    }
+  }
+  let content = composeTemplates(templates, {
+    separator: "\n\n---\n\n",
+    includeHeaders: false
+  });
+  if (variables) {
+    content = interpolateVariables(content, variables);
+  }
+  const stageName = stage === "all" ? void 0 : formatStageName(stage);
+  return formatForTool(tool, content, { stage: stageName });
+}
+async function deployContext(options) {
+  const { target, stage, format, outputDir, variables } = options;
+  const results = [];
+  const tools = target === "all" ? getSupportedTools() : [target];
+  const stages = stage === "all" ? ["actions", "scripts", "balance", "rebalance"] : [stage];
+  for (const tool of tools) {
+    if (format === "combined") {
+      try {
+        const content = await buildContext(tool, "all", variables);
+        const filePath = getOutputPath(tool, format, outputDir);
+        const absolutePath = path6.resolve(filePath);
+        await fs6.mkdir(path6.dirname(absolutePath), { recursive: true });
+        await fs6.writeFile(absolutePath, content, "utf-8");
+        results.push({
+          tool,
+          filePath: absolutePath,
+          created: true
+        });
+      } catch (error) {
+        results.push({
+          tool,
+          filePath: getOutputPath(tool, format, outputDir),
+          created: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    } else {
+      for (const stg of stages) {
+        try {
+          const content = await buildContext(tool, stg, variables);
+          const stageName = getStageFileName(stg);
+          const filePath = getOutputPath(tool, format, outputDir, stageName);
+          const absolutePath = path6.resolve(filePath);
+          await fs6.mkdir(path6.dirname(absolutePath), { recursive: true });
+          await fs6.writeFile(absolutePath, content, "utf-8");
+          results.push({
+            tool,
+            filePath: absolutePath,
+            stage: stg,
+            created: true
+          });
+        } catch (error) {
+          results.push({
+            tool,
+            filePath: getOutputPath(tool, format, outputDir, stg),
+            stage: stg,
+            created: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+  }
+  return results;
+}
+async function previewContext(tool, stage, variables) {
+  const content = await buildContext(tool, stage, variables);
+  return {
+    tool,
+    stage: stage === "all" ? void 0 : stage,
+    content
+  };
+}
+async function listDeployedContext(outputDir) {
+  const tools = getSupportedTools();
+  const files = [];
+  for (const tool of tools) {
+    const config = getToolConfig(tool);
+    const combinedPath = path6.join(outputDir, config.combinedFile);
+    try {
+      await fs6.access(combinedPath);
+      files.push({ tool, path: combinedPath, exists: true });
+    } catch {
+      files.push({ tool, path: combinedPath, exists: false });
+    }
+    const splitDir = path6.join(outputDir, config.splitDir);
+    try {
+      const splitFiles = await fs6.readdir(splitDir);
+      for (const file of splitFiles) {
+        if (file.endsWith(config.fileExtension)) {
+          files.push({
+            tool,
+            path: path6.join(splitDir, file),
+            exists: true
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return { files };
+}
+async function removeContext(outputDir, target) {
+  const tools = target === "all" ? getSupportedTools() : [target];
+  const results = [];
+  for (const tool of tools) {
+    const config = getToolConfig(tool);
+    const combinedPath = path6.join(outputDir, config.combinedFile);
+    try {
+      await fs6.unlink(combinedPath);
+      results.push({ path: combinedPath, removed: true });
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        results.push({
+          path: combinedPath,
+          removed: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    const splitDir = path6.join(outputDir, config.splitDir);
+    try {
+      await fs6.rm(splitDir, { recursive: true });
+      results.push({ path: splitDir, removed: true });
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        results.push({
+          path: splitDir,
+          removed: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  return results;
+}
+async function getSkill(name) {
+  try {
+    const template = await loadTemplate("skills", name);
+    return { name: template.name, content: template.content };
+  } catch {
+    return null;
+  }
+}
+async function listSkills() {
+  const templates = await listTemplates();
+  return templates.skills;
+}
+async function hasTemplates() {
+  const templates = await listTemplates();
+  return templates.base.length > 0;
+}
 export {
   DEMO_SCHEMA_VERSION,
   ScriptGenerator,
+  TOOL_CONFIGS,
   VoiceSynthesizer,
+  buildContext,
+  composeTemplates,
   createClickAction,
   createDragAction,
   createEmptyDemo,
@@ -2407,15 +2766,35 @@ export {
   demoDefinitionSchema,
   demoHover,
   demoType,
+  deployContext,
   discoverDemos,
+  formatForTool,
+  formatStageName,
   formatValidationError,
   generateTimingManifest,
+  getOutputPath,
+  getSkill,
+  getSplitOutputPaths,
+  getStageFileName,
+  getSupportedTools,
+  getToolConfig,
+  hasTemplates,
   highlightElement,
   injectCursorOverlay,
+  interpolateVariables,
+  isValidFormat,
+  isValidTool,
+  listDeployedContext,
+  listSkills,
+  listTemplates,
   loadDemoDefinition,
+  loadTemplate,
+  loadTemplatesByCategory,
   moveCursorTo,
   parseDemoDefinition,
   parseFromYAML,
+  previewContext,
+  removeContext,
   removeCursorOverlay,
   resolvePath,
   resolveTarget,
@@ -2423,6 +2802,7 @@ export {
   runDemoFromFile,
   safeParseDemoDefinition,
   serializeToYAML,
+  templateExists,
   triggerClickRipple,
   validateDemoDefinition
 };