@t3lnet/sceneforge 1.0.8 → 1.0.10

package/context/tests/template-loader.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import {
+  loadTemplate,
+  loadTemplatesByCategory,
+  interpolateVariables,
+  composeTemplates,
+  listTemplates,
+  templateExists,
+  type LoadedTemplate,
+} from "../template-loader";
+
+describe("template-loader", () => {
+  describe("interpolateVariables", () => {
+    it("replaces variables with values", () => {
+      const content = "Hello {{name}}, welcome to {{project}}!";
+      const result = interpolateVariables(content, {
+        name: "World",
+        project: "SceneForge",
+      });
+      expect(result).toBe("Hello World, welcome to SceneForge!");
+    });
+
+    it("leaves unmatched variables as-is", () => {
+      const content = "Hello {{name}}, your {{unknown}} is ready";
+      const result = interpolateVariables(content, { name: "User" });
+      expect(result).toBe("Hello User, your {{unknown}} is ready");
+    });
+
+    it("handles empty variables object", () => {
+      const content = "No {{variables}} here";
+      const result = interpolateVariables(content, {});
+      expect(result).toBe("No {{variables}} here");
+    });
+
+    it("converts numbers to strings", () => {
+      const content = "Version {{version}}";
+      const result = interpolateVariables(content, { version: 1 });
+      expect(result).toBe("Version 1");
+    });
+
+    it("handles boolean values", () => {
+      const content = "Feature enabled: {{enabled}}";
+      const result = interpolateVariables(content, { enabled: true });
+      expect(result).toBe("Feature enabled: true");
+    });
+
+    it("skips undefined values", () => {
+      const content = "Value: {{value}}";
+      const result = interpolateVariables(content, { value: undefined });
+      expect(result).toBe("Value: {{value}}");
+    });
+  });
+
+  describe("composeTemplates", () => {
+    const templates: LoadedTemplate[] = [
+      { name: "first", content: "First template", category: "base" },
+      { name: "second", content: "Second template", category: "base" },
+    ];
+
+    it("joins templates with default separator", () => {
+      const result = composeTemplates(templates);
+      expect(result).toContain("First template");
+      expect(result).toContain("Second template");
+      expect(result).toContain("---");
+    });
+
+    it("uses custom separator", () => {
+      const result = composeTemplates(templates, { separator: "\n\n" });
+      expect(result).toBe("First template\n\nSecond template");
+    });
+
+    it("includes headers when requested", () => {
+      const result = composeTemplates(templates, { includeHeaders: true });
+      expect(result).toContain("<!-- Template: base/first -->");
+      expect(result).toContain("<!-- Template: base/second -->");
+    });
+  });
+
+  describe("listTemplates", () => {
+    it("returns object with all categories", async () => {
+      const templates = await listTemplates();
+      expect(templates).toHaveProperty("base");
+      expect(templates).toHaveProperty("stages");
+      expect(templates).toHaveProperty("skills");
+      expect(Array.isArray(templates.base)).toBe(true);
+      expect(Array.isArray(templates.stages)).toBe(true);
+      expect(Array.isArray(templates.skills)).toBe(true);
+    });
+
+    it("lists base templates", async () => {
+      const templates = await listTemplates();
+      expect(templates.base).toContain("project-overview");
+      expect(templates.base).toContain("yaml-schema");
+      expect(templates.base).toContain("actions-reference");
+      expect(templates.base).toContain("selectors-guide");
+      expect(templates.base).toContain("cli-reference");
+    });
+
+    it("lists stage templates", async () => {
+      const templates = await listTemplates();
+      expect(templates.stages).toContain("stage1-actions");
+      expect(templates.stages).toContain("stage2-scripts");
+      expect(templates.stages).toContain("stage3-balancing");
+      expect(templates.stages).toContain("stage4-rebalancing");
+    });
+
+    it("lists skill templates", async () => {
+      const templates = await listTemplates();
+      expect(templates.skills).toContain("generate-actions");
+      expect(templates.skills).toContain("write-step-script");
+      expect(templates.skills).toContain("balance-timing");
+      expect(templates.skills).toContain("review-demo-yaml");
+      expect(templates.skills).toContain("debug-selector");
+      expect(templates.skills).toContain("optimize-demo");
+    });
+  });
+
+  describe("templateExists", () => {
+    it("returns true for existing template", async () => {
+      const exists = await templateExists("base", "project-overview");
+      expect(exists).toBe(true);
+    });
+
+    it("returns false for non-existent template", async () => {
+      const exists = await templateExists("base", "non-existent-template");
+      expect(exists).toBe(false);
+    });
+
+    it("returns true for skill template", async () => {
+      const exists = await templateExists("skills", "generate-actions");
+      expect(exists).toBe(true);
+    });
+  });
+
+  describe("loadTemplate", () => {
+    it("loads a base template", async () => {
+      const template = await loadTemplate("base", "project-overview");
+      expect(template.name).toBe("project-overview");
+      expect(template.category).toBe("base");
+      expect(template.content).toContain("SceneForge");
+    });
+
+    it("loads a stage template", async () => {
+      const template = await loadTemplate("stages", "stage1-actions");
+      expect(template.name).toBe("stage1-actions");
+      expect(template.category).toBe("stages");
+      expect(template.content).toContain("Action");
+    });
+
+    it("loads a skill template", async () => {
+      const template = await loadTemplate("skills", "generate-actions");
+      expect(template.name).toBe("generate-actions");
+      expect(template.category).toBe("skills");
+      expect(template.content.length).toBeGreaterThan(100);
+    });
+
+    it("throws for non-existent template", async () => {
+      await expect(loadTemplate("base", "non-existent")).rejects.toThrow();
+    });
+  });
+
+  describe("loadTemplatesByCategory", () => {
+    it("loads all base templates", async () => {
+      const templates = await loadTemplatesByCategory("base");
+      expect(templates.length).toBeGreaterThanOrEqual(5);
+      expect(templates.every((t) => t.category === "base")).toBe(true);
+    });
+
+    it("loads all stage templates", async () => {
+      const templates = await loadTemplatesByCategory("stages");
+      expect(templates.length).toBe(4);
+      expect(templates.every((t) => t.category === "stages")).toBe(true);
+    });
+
+    it("loads all skill templates", async () => {
+      const templates = await loadTemplatesByCategory("skills");
+      expect(templates.length).toBe(6);
+      expect(templates.every((t) => t.category === "skills")).toBe(true);
+    });
+  });
+});

package/context/tests/tool-formatter.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect } from "vitest";
+import {
+  getSupportedTools,
+  getToolConfig,
+  formatForTool,
+  getOutputPath,
+  getSplitOutputPaths,
+  formatStageName,
+  getStageFileName,
+  isValidTool,
+  isValidFormat,
+  TOOL_CONFIGS,
+} from "../tool-formatter";
+
+describe("tool-formatter", () => {
+  describe("getSupportedTools", () => {
+    it("returns all supported tools", () => {
+      const tools = getSupportedTools();
+      expect(tools).toContain("cursor");
+      expect(tools).toContain("copilot");
+      expect(tools).toContain("claude");
+      expect(tools).toContain("codex");
+      expect(tools.length).toBe(4);
+    });
+  });
+
+  describe("getToolConfig", () => {
+    it("returns config for cursor", () => {
+      const config = getToolConfig("cursor");
+      expect(config.name).toBe("Cursor");
+      expect(config.combinedFile).toBe(".cursorrules");
+      expect(config.splitDir).toBe(".cursor/rules");
+    });
+
+    it("returns config for copilot", () => {
+      const config = getToolConfig("copilot");
+      expect(config.name).toBe("GitHub Copilot");
+      expect(config.combinedFile).toBe(".github/copilot-instructions.md");
+    });
+
+    it("returns config for claude", () => {
+      const config = getToolConfig("claude");
+      expect(config.name).toBe("Claude Code");
+      expect(config.combinedFile).toBe("CLAUDE.md");
+    });
+
+    it("returns config for codex", () => {
+      const config = getToolConfig("codex");
+      expect(config.name).toBe("Codex");
+      expect(config.combinedFile).toBe("AGENTS.md");
+    });
+  });
+
+  describe("TOOL_CONFIGS", () => {
+    it("has configs for all tools", () => {
+      expect(TOOL_CONFIGS.cursor).toBeDefined();
+      expect(TOOL_CONFIGS.copilot).toBeDefined();
+      expect(TOOL_CONFIGS.claude).toBeDefined();
+      expect(TOOL_CONFIGS.codex).toBeDefined();
+    });
+
+    it("all configs have required properties", () => {
+      for (const [key, config] of Object.entries(TOOL_CONFIGS)) {
+        expect(config.name).toBeDefined();
+        expect(config.combinedFile).toBeDefined();
+        expect(config.splitDir).toBeDefined();
+        expect(config.fileExtension).toBeDefined();
+        expect(typeof config.supportsSkills).toBe("boolean");
+      }
+    });
+  });
+
+  describe("formatForTool", () => {
+    it("adds header by default", () => {
+      const result = formatForTool("claude", "Content here");
+      expect(result).toContain("# SceneForge LLM Context");
+      expect(result).toContain("Claude Code");
+      expect(result).toContain("Content here");
+    });
+
+    it("includes stage when provided", () => {
+      const result = formatForTool("cursor", "Content", { stage: "Stage 1" });
+      expect(result).toContain("Stage: Stage 1");
+    });
+
+    it("can skip header", () => {
+      const result = formatForTool("claude", "Content", { includeToolHeader: false });
+      expect(result).toBe("Content");
+    });
+  });
+
+  describe("getOutputPath", () => {
+    it("returns combined path for combined format", () => {
+      const path = getOutputPath("claude", "combined", "/project");
+      expect(path).toBe("/project/CLAUDE.md");
+    });
+
+    it("returns split path with stage", () => {
+      const path = getOutputPath("claude", "split", "/project", "stage1-actions");
+      expect(path).toBe("/project/.claude/rules/stage1-actions.md");
+    });
+
+    it("returns main path when no stage for split format", () => {
+      const path = getOutputPath("cursor", "split", "/project");
+      expect(path).toBe("/project/.cursor/rules/main.md");
+    });
+
+    it("handles cursor combined path", () => {
+      const path = getOutputPath("cursor", "combined", "/project");
+      expect(path).toBe("/project/.cursorrules");
+    });
+
+    it("handles copilot path", () => {
+      const path = getOutputPath("copilot", "combined", "/project");
+      expect(path).toBe("/project/.github/copilot-instructions.md");
+    });
+  });
+
+  describe("getSplitOutputPaths", () => {
+    it("returns paths for all stages", () => {
+      const paths = getSplitOutputPaths("claude", "/project", ["stage1", "stage2"]);
+      expect(paths).toHaveLength(2);
+      expect(paths[0]).toContain("stage1");
+      expect(paths[1]).toContain("stage2");
+    });
+  });
+
+  describe("formatStageName", () => {
+    it("formats action stage", () => {
+      expect(formatStageName("actions")).toBe("Stage 1: Action Generation");
+    });
+
+    it("formats scripts stage", () => {
+      expect(formatStageName("scripts")).toBe("Stage 2: Script Writing");
+    });
+
+    it("formats balance stage", () => {
+      expect(formatStageName("balance")).toBe("Stage 3: Step Balancing");
+    });
+
+    it("formats rebalance stage", () => {
+      expect(formatStageName("rebalance")).toBe("Stage 4: Rebalancing");
+    });
+
+    it("returns input for unknown stage", () => {
+      expect(formatStageName("unknown")).toBe("unknown");
+    });
+  });
+
+  describe("getStageFileName", () => {
+    it("converts actions to file name", () => {
+      expect(getStageFileName("actions")).toBe("stage1-actions");
+    });
+
+    it("converts scripts to file name", () => {
+      expect(getStageFileName("scripts")).toBe("stage2-scripts");
+    });
+
+    it("converts balance to file name", () => {
+      expect(getStageFileName("balance")).toBe("stage3-balancing");
+    });
+
+    it("converts rebalance to file name", () => {
+      expect(getStageFileName("rebalance")).toBe("stage4-rebalancing");
+    });
+
+    it("returns input for unknown stage", () => {
+      expect(getStageFileName("custom")).toBe("custom");
+    });
+  });
+
+  describe("isValidTool", () => {
+    it("returns true for valid tools", () => {
+      expect(isValidTool("cursor")).toBe(true);
+      expect(isValidTool("copilot")).toBe(true);
+      expect(isValidTool("claude")).toBe(true);
+      expect(isValidTool("codex")).toBe(true);
+    });
+
+    it("returns false for invalid tools", () => {
+      expect(isValidTool("invalid")).toBe(false);
+      expect(isValidTool("")).toBe(false);
+      expect(isValidTool("all")).toBe(false);
+    });
+  });
+
+  describe("isValidFormat", () => {
+    it("returns true for valid formats", () => {
+      expect(isValidFormat("combined")).toBe(true);
+      expect(isValidFormat("split")).toBe(true);
+    });
+
+    it("returns false for invalid formats", () => {
+      expect(isValidFormat("invalid")).toBe(false);
+      expect(isValidFormat("")).toBe(false);
+    });
+  });
+});

package/context/tool-formatter.ts

@@ -0,0 +1,189 @@
+/**
+ * Tool-specific formatting for LLM context files.
+ * Formats content and determines file locations for each target tool.
+ */
+
+export type TargetTool = "cursor" | "copilot" | "claude" | "codex";
+export type DeployFormat = "combined" | "split";
+
+export interface ToolConfig {
+  name: string;
+  description: string;
+  combinedFile: string;
+  splitDir: string;
+  splitFilePrefix: string;
+  fileExtension: string;
+  supportsSkills: boolean;
+}
+
+export interface FormattedOutput {
+  tool: TargetTool;
+  filePath: string;
+  content: string;
+}
+
+/**
+ * Configuration for each supported LLM tool.
+ */
+export const TOOL_CONFIGS: Record<TargetTool, ToolConfig> = {
+  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,
+  },
+};
+
+/**
+ * Get the list of all supported tools.
+ */
+export function getSupportedTools(): TargetTool[] {
+  return Object.keys(TOOL_CONFIGS) as TargetTool[];
+}
+
+/**
+ * Get configuration for a specific tool.
+ */
+export function getToolConfig(tool: TargetTool): ToolConfig {
+  return TOOL_CONFIGS[tool];
+}
+
+/**
+ * Format content for a specific tool with appropriate headers and structure.
+ */
+export function formatForTool(
+  tool: TargetTool,
+  content: string,
+  options?: {
+    stage?: string;
+    includeToolHeader?: boolean;
+  }
+): string {
+  const config = TOOL_CONFIGS[tool];
+  const { stage, includeToolHeader = true } = options ?? {};
+
+  const lines: string[] = [];
+
+  // Add tool-specific header
+  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");
+}
+
+/**
+ * Get the output file path for a tool.
+ */
+export function getOutputPath(
+  tool: TargetTool,
+  format: DeployFormat,
+  outputDir: string,
+  stageName?: string
+): string {
+  const config = TOOL_CONFIGS[tool];
+
+  if (format === "combined") {
+    return `${outputDir}/${config.combinedFile}`;
+  }
+
+  // Split format
+  const fileName = stageName
+    ? `${config.splitFilePrefix}${stageName}${config.fileExtension}`
+    : `${config.splitFilePrefix}main${config.fileExtension}`;
+
+  return `${outputDir}/${config.splitDir}/${fileName}`;
+}
+
+/**
+ * Get all output paths for a tool in split format.
+ */
+export function getSplitOutputPaths(
+  tool: TargetTool,
+  outputDir: string,
+  stageNames: string[]
+): string[] {
+  return stageNames.map((stage) => getOutputPath(tool, "split", outputDir, stage));
+}
+
+/**
+ * Format stage name for display.
+ */
+export function formatStageName(stage: string): string {
+  const stageMap: Record<string, string> = {
+    actions: "Stage 1: Action Generation",
+    scripts: "Stage 2: Script Writing",
+    balance: "Stage 3: Step Balancing",
+    rebalance: "Stage 4: Rebalancing",
+  };
+
+  return stageMap[stage] ?? stage;
+}
+
+/**
+ * Get stage file name from stage identifier.
+ */
+export function getStageFileName(stage: string): string {
+  const stageFileMap: Record<string, string> = {
+    actions: "stage1-actions",
+    scripts: "stage2-scripts",
+    balance: "stage3-balancing",
+    rebalance: "stage4-rebalancing",
+  };
+
+  return stageFileMap[stage] ?? stage;
+}
+
+/**
+ * Validate a tool name.
+ */
+export function isValidTool(tool: string): tool is TargetTool {
+  return tool in TOOL_CONFIGS;
+}
+
+/**
+ * Validate a deploy format.
+ */
+export function isValidFormat(format: string): format is DeployFormat {
+  return format === "combined" || format === "split";
+}