@t3lnet/sceneforge 1.0.12 → 1.0.14

package/dist/index.js

@@ -2387,13 +2387,27 @@ async function discoverDemos(demoDir) {
 }
 
 // context/template-loader.ts
+import { existsSync } from "fs";
 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");
+  const candidates = [
+    // Standard dist layout: dist/templates/{base,stages,skills}
+    path5.join(__dirname, "templates"),
+    // Nested layout if templates were copied into an existing dist/templates
+    path5.join(__dirname, "templates", "templates"),
+    // Source layout when templates are shipped under context/templates
+    path5.join(__dirname, "..", "context", "templates")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(path5.join(candidate, "base"))) {
+      return candidate;
+    }
+  }
+  return candidates[0];
 }
 async function loadTemplate(category, name) {
   const templatesDir = getTemplatesDir();
@@ -2420,7 +2434,9 @@ async function loadTemplatesByCategory(category) {
     }
     return templates;
   } catch (error) {
-    throw new Error(`Failed to load templates from ${category}: ${error}`);
+    throw new Error(
+      `Failed to load templates from ${category} in ${templatesDir}: ${error}`
+    );
   }
 }
 function interpolateVariables(content, variables) {
@@ -2574,6 +2590,42 @@ function isValidFormat(format) {
 // context/context-builder.ts
 import * as fs6 from "fs/promises";
 import * as path6 from "path";
+var SCENEFORGE_START_MARKER = "<!-- SCENEFORGE_CONTEXT_START -->";
+var SCENEFORGE_END_MARKER = "<!-- SCENEFORGE_CONTEXT_END -->";
+function wrapWithMarkers(content) {
+  return `${SCENEFORGE_START_MARKER}
+${content}
+${SCENEFORGE_END_MARKER}`;
+}
+async function mergeWithExisting(filePath, newContent) {
+  const wrappedContent = wrapWithMarkers(newContent);
+  try {
+    const existingContent = await fs6.readFile(filePath, "utf-8");
+    const startIndex = existingContent.indexOf(SCENEFORGE_START_MARKER);
+    const endIndex = existingContent.indexOf(SCENEFORGE_END_MARKER);
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+      const beforeSection = existingContent.slice(0, startIndex);
+      const afterSection = existingContent.slice(
+        endIndex + SCENEFORGE_END_MARKER.length
+      );
+      return {
+        content: beforeSection + wrappedContent + afterSection,
+        merged: true
+      };
+    } else {
+      const separator = existingContent.trim().endsWith("-->") ? "\n\n" : "\n\n---\n\n";
+      return {
+        content: existingContent.trimEnd() + separator + wrappedContent + "\n",
+        merged: true
+      };
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { content: wrappedContent, merged: false };
+    }
+    throw error;
+  }
+}
 async function buildContext(tool, stage, variables) {
   const templates = [];
   const baseTemplates = await loadTemplatesByCategory("base");
@@ -2611,12 +2663,20 @@ async function deployContext(options) {
         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");
+        const { content: finalContent, merged } = await mergeWithExisting(
+          absolutePath,
+          content
+        );
+        await fs6.writeFile(absolutePath, finalContent, "utf-8");
         results.push({
           tool,
           filePath: absolutePath,
-          created: true
+          created: true,
+          skipped: false
         });
+        if (merged) {
+          console.log(`  [merged] ${path6.relative(outputDir, absolutePath)}`);
+        }
       } catch (error) {
         results.push({
           tool,
@@ -2633,13 +2693,21 @@ async function deployContext(options) {
           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");
+          const { content: finalContent, merged } = await mergeWithExisting(
+            absolutePath,
+            content
+          );
+          await fs6.writeFile(absolutePath, finalContent, "utf-8");
           results.push({
             tool,
             filePath: absolutePath,
             stage: stg,
-            created: true
+            created: true,
+            skipped: false
           });
+          if (merged) {
+            console.log(`  [merged] ${path6.relative(outputDir, absolutePath)}`);
+          }
         } catch (error) {
           results.push({
             tool,