spec-snake 0.0.1-beta.0

package/dist/cli.js

@@ -0,0 +1,783 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { defineCommand as defineCommand3, runMain } from "citty";
+
+// src/cli/commands/init.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { defineCommand } from "citty";
+import { consola } from "consola";
+var CONFIG_TEMPLATE = `// For more detailed configuration examples, see:
+// https://github.com/cut0/spec-snake/blob/main/examples/spec-snake.ts
+
+import { defineConfig, defineScenario } from '@cut0/spec-snake';
+
+export default defineConfig({
+  scenarios: [
+    defineScenario({
+      id: 'default',
+      name: 'Design Doc Generator',
+      steps: [
+        {
+          slug: 'overview',
+          title: 'Overview',
+          description: 'Basic information about the feature',
+          section: {
+            type: 'single',
+            name: 'overview',
+            fields: [
+              {
+                type: 'input',
+                id: 'title',
+                label: 'Title',
+                description: 'Feature title',
+                placeholder: 'Enter feature title',
+                required: true,
+              },
+              {
+                type: 'textarea',
+                id: 'description',
+                label: 'Description',
+                description: 'Detailed description of the feature',
+                placeholder: 'Describe the feature...',
+                rows: 4,
+              },
+              {
+                type: 'select',
+                id: 'priority',
+                label: 'Priority',
+                description: 'Feature priority level',
+                placeholder: 'Select priority',
+                options: [
+                  { value: 'high', label: 'High' },
+                  { value: 'medium', label: 'Medium' },
+                  { value: 'low', label: 'Low' },
+                ],
+              },
+            ],
+          },
+        },
+      ],
+      overrides: {
+        filename: (params) => {
+          return \`\${params.timestamp}.md\`;
+        },
+      },
+      prompt:
+        'Generate a design doc based on the following input: {{INPUT_JSON}}',
+    }),
+  ],
+  permissions: {
+    allowSave: true,
+  },
+});
+`;
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize a new spec-snake.config.ts file in the current directory"
+  },
+  args: {
+    output: {
+      type: "string",
+      description: "Output file path",
+      alias: "o",
+      default: "spec-snake.config.ts"
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite existing file",
+      alias: "f",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const outputPath = path.resolve(process.cwd(), args.output);
+    if (fs.existsSync(outputPath) && !args.force) {
+      consola.error(`File already exists: ${outputPath}`);
+      consola.info("Use --force (-f) to overwrite");
+      process.exit(1);
+    }
+    try {
+      fs.writeFileSync(outputPath, CONFIG_TEMPLATE, "utf-8");
+      consola.success(`Config file created: ${outputPath}`);
+    } catch (error) {
+      consola.error("Failed to create config file:", error);
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli/commands/start.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import * as url from "node:url";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { defineCommand as defineCommand2 } from "citty";
+import { consola as consola2 } from "consola";
+import { createJiti } from "jiti";
+
+// src/schema.ts
+import * as v from "valibot";
+var isLayoutField = (field) => {
+  return field.type === "grid";
+};
+var FieldBaseSchema = v.object({
+  id: v.string(),
+  label: v.string(),
+  description: v.string(),
+  placeholder: v.optional(v.string()),
+  required: v.optional(v.boolean())
+});
+var SelectOptionSchema = v.object({
+  value: v.string(),
+  label: v.string()
+});
+var InputFieldSchema = v.object({
+  ...FieldBaseSchema.entries,
+  type: v.literal("input"),
+  inputType: v.optional(v.picklist(["text", "date", "url"])),
+  suggestions: v.optional(v.array(v.string()))
+});
+var TextareaFieldSchema = v.object({
+  ...FieldBaseSchema.entries,
+  type: v.literal("textarea"),
+  rows: v.optional(v.number())
+});
+var SelectFieldSchema = v.object({
+  ...FieldBaseSchema.entries,
+  type: v.literal("select"),
+  options: v.array(SelectOptionSchema)
+});
+var CheckboxFieldSchema = v.object({
+  ...FieldBaseSchema.entries,
+  type: v.literal("checkbox")
+});
+var FormFieldSchema = v.union([
+  InputFieldSchema,
+  TextareaFieldSchema,
+  SelectFieldSchema,
+  CheckboxFieldSchema
+]);
+var GridLayoutSchema = v.object({
+  type: v.literal("grid"),
+  columns: v.number(),
+  fields: v.array(v.lazy(() => FieldSchema))
+});
+var FieldSchema = v.union([
+  FormFieldSchema,
+  GridLayoutSchema
+]);
+var SingleSectionSchema = v.object({
+  type: v.literal("single"),
+  name: v.string(),
+  fields: v.array(FieldSchema)
+});
+var ArraySectionSchema = v.object({
+  type: v.literal("array"),
+  name: v.string(),
+  fields: v.array(FieldSchema),
+  minFieldCount: v.optional(v.number())
+});
+var SectionSchema = v.union([SingleSectionSchema, ArraySectionSchema]);
+var StepSchema = v.object({
+  slug: v.string(),
+  title: v.string(),
+  description: v.string(),
+  section: SectionSchema
+});
+var McpServerConfigSchema = v.union([
+  v.object({
+    type: v.optional(v.literal("stdio")),
+    command: v.string(),
+    args: v.optional(v.array(v.string())),
+    env: v.optional(v.record(v.string(), v.string()))
+  }),
+  v.object({
+    type: v.literal("sse"),
+    url: v.string(),
+    headers: v.optional(v.record(v.string(), v.string()))
+  }),
+  v.object({
+    type: v.literal("http"),
+    url: v.string(),
+    headers: v.optional(v.record(v.string(), v.string()))
+  })
+]);
+var AiSettingsSchema = v.optional(
+  v.object({
+    model: v.optional(v.string()),
+    fallbackModel: v.optional(v.string()),
+    maxThinkingTokens: v.optional(v.number()),
+    maxTurns: v.optional(v.number()),
+    maxBudgetUsd: v.optional(v.number()),
+    allowedTools: v.optional(v.array(v.string())),
+    disallowedTools: v.optional(v.array(v.string())),
+    tools: v.optional(
+      v.union([
+        v.array(v.string()),
+        v.object({
+          type: v.literal("preset"),
+          preset: v.literal("claude_code")
+        })
+      ])
+    ),
+    permissionMode: v.optional(
+      v.picklist([
+        "default",
+        "acceptEdits",
+        "bypassPermissions",
+        "plan",
+        "delegate",
+        "dontAsk"
+      ])
+    ),
+    allowDangerouslySkipPermissions: v.optional(v.boolean()),
+    mcpServers: v.optional(v.record(v.string(), McpServerConfigSchema)),
+    strictMcpConfig: v.optional(v.boolean())
+  })
+);
+var ScenarioBaseSchema = v.object({
+  id: v.string(),
+  name: v.string(),
+  steps: v.array(StepSchema),
+  prompt: v.string(),
+  aiSettings: AiSettingsSchema
+});
+var ScenarioSchema = ScenarioBaseSchema;
+var PermissionsSchema = v.object({
+  allowSave: v.boolean()
+});
+var ConfigSchema = v.object({
+  scenarios: v.array(ScenarioSchema),
+  permissions: PermissionsSchema
+});
+var safeParseConfig = (data) => {
+  return v.safeParse(ConfigSchema, data);
+};
+
+// src/server/api.ts
+import { Hono as Hono3 } from "hono";
+
+// src/server/apps/docs.ts
+import { Hono } from "hono";
+import { createMiddleware } from "hono/factory";
+
+// src/server/helpers/docs/transform.ts
+var transformFormData = (body, sectionInfoMap) => {
+  const items = [];
+  for (const [sectionName, sectionValue] of Object.entries(body)) {
+    const sectionInfo = sectionInfoMap.get(sectionName);
+    if (sectionInfo == null) {
+      continue;
+    }
+    const fieldInfoMap = new Map(sectionInfo.fields.map((f) => [f.id, f]));
+    const values = (Array.isArray(sectionValue) ? sectionValue : [sectionValue]).map((item) => {
+      const itemValues = Object.entries(item).map(([fieldId, fieldValue]) => {
+        const fieldInfo = fieldInfoMap.get(fieldId);
+        if (fieldInfo) {
+          return {
+            label: fieldInfo.label,
+            description: fieldInfo.description,
+            value: fieldValue
+          };
+        }
+        return null;
+      }).filter((value) => value != null);
+      return itemValues;
+    });
+    items.push({
+      title: sectionInfo.title,
+      description: sectionInfo.description,
+      values
+    });
+  }
+  return { items };
+};
+
+// src/server/repositories/document.ts
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/server/helpers/docs/metadata.ts
+var METADATA_START = "<!-- design-docs-metadata";
+var METADATA_END = "-->";
+var serializeMetadata = (metadata) => {
+  return `${METADATA_START}
+${JSON.stringify(metadata, null, 2)}
+${METADATA_END}`;
+};
+var parseMetadata = (content) => {
+  const metadataStartIndex = content.lastIndexOf(METADATA_START);
+  if (metadataStartIndex === -1) {
+    return { metadata: null, content };
+  }
+  const metadataEndIndex = content.indexOf(METADATA_END, metadataStartIndex);
+  if (metadataEndIndex === -1) {
+    return { metadata: null, content };
+  }
+  try {
+    const metadataJson = content.slice(metadataStartIndex + METADATA_START.length, metadataEndIndex).trim();
+    const metadata = JSON.parse(metadataJson);
+    const cleanContent = content.slice(0, metadataStartIndex).trim();
+    return { metadata, content: cleanContent };
+  } catch {
+    return { metadata: null, content };
+  }
+};
+var addMetadataToContent = (content, metadata) => {
+  return `${content}
+
+${serializeMetadata(metadata)}`;
+};
+
+// src/server/repositories/document.ts
+var getOutputDir = (scenario) => {
+  return scenario.outputDir ?? join(process.cwd(), "output");
+};
+var readDocument = async (scenario, filename) => {
+  const outputDir = getOutputDir(scenario);
+  const filePath = join(outputDir, filename);
+  try {
+    const rawContent = await readFile(filePath, "utf-8");
+    const { metadata, content } = parseMetadata(rawContent);
+    if (metadata?.scenarioId !== scenario.id) {
+      return { success: false, error: "scenario_mismatch" };
+    }
+    return {
+      success: true,
+      doc: { filename, content, metadata }
+    };
+  } catch {
+    return { success: false, error: "not_found" };
+  }
+};
+var getDocumentsForScenario = async (scenario) => {
+  const outputDir = getOutputDir(scenario);
+  try {
+    const files = await readdir(outputDir);
+    const mdFiles = files.filter((file) => file.endsWith(".md"));
+    const docs = await Promise.all(
+      mdFiles.map(async (filename) => {
+        const result = await readDocument(scenario, filename);
+        return result.success ? result.doc : null;
+      })
+    );
+    return docs.filter((doc) => doc != null);
+  } catch {
+    return [];
+  }
+};
+var saveDocument = async ({
+  scenario,
+  scenarioId,
+  filename,
+  content,
+  formData
+}) => {
+  const outputDir = getOutputDir(scenario);
+  const outputPath = join(outputDir, filename);
+  const contentWithMetadata = addMetadataToContent(content, {
+    scenarioId,
+    formData
+  });
+  await mkdir(outputDir, { recursive: true });
+  await writeFile(outputPath, contentWithMetadata, "utf-8");
+  return { outputPath };
+};
+var getFilename = (scenario, scenarioId, content, formData, inputData) => {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filenameOverride = scenario.overrides?.filename;
+  if (filenameOverride != null) {
+    return typeof filenameOverride === "function" ? filenameOverride({
+      scenarioId,
+      timestamp,
+      content,
+      formData,
+      inputData
+    }) : filenameOverride;
+  }
+  return `design-doc-${scenarioId}-${timestamp}.md`;
+};
+
+// src/server/usecases/docs/generate-doc.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+var generateDesignDoc = async ({
+  scenario,
+  formData,
+  inputData
+}) => {
+  const promptTemplate = typeof scenario.prompt === "function" ? scenario.prompt({ formData, inputData }) : scenario.prompt;
+  const prompt = promptTemplate.replace(
+    "{{INPUT_JSON}}",
+    JSON.stringify(inputData, null, 2)
+  );
+  let message = null;
+  for await (const msg of query({
+    prompt,
+    options: scenario.aiSettings
+  })) {
+    if (msg.type === "result" && msg.subtype === "success") {
+      message = msg;
+    }
+  }
+  if (message == null) {
+    throw new Error("Query failed");
+  }
+  return message.result;
+};
+
+// src/server/apps/docs.ts
+var createScenarioMiddleware = (scenarioInfoMap) => createMiddleware(async (c, next) => {
+  const scenarioId = c.req.param("scenarioId");
+  if (scenarioId == null) {
+    return c.json({ error: "Scenario ID is required" }, 400);
+  }
+  const scenarioInfo = scenarioInfoMap.get(scenarioId);
+  if (scenarioInfo == null) {
+    return c.json({ error: "Scenario not found" }, 404);
+  }
+  c.set("scenarioInfo", scenarioInfo);
+  await next();
+});
+var createDocsApp = (config, scenarioInfoMap) => {
+  const app = new Hono();
+  app.use(
+    "/api/scenarios/:scenarioId/*",
+    createScenarioMiddleware(scenarioInfoMap)
+  );
+  app.get("/api/scenarios/:scenarioId/docs", async (c) => {
+    const { scenario } = c.get("scenarioInfo");
+    const docs = await getDocumentsForScenario(scenario);
+    return c.json({ docs });
+  });
+  app.post("/api/scenarios/:scenarioId/docs/preview", async (c) => {
+    const { scenario, sectionInfoMap } = c.get("scenarioInfo");
+    const formData = await c.req.json();
+    const inputData = transformFormData(formData, sectionInfoMap);
+    const content = await generateDesignDoc({ scenario, formData, inputData });
+    if (scenario.hooks?.onPreview != null) {
+      await scenario.hooks.onPreview({ formData, inputData, content });
+    }
+    return c.json({ success: true, content });
+  });
+  app.post("/api/scenarios/:scenarioId/docs", async (c) => {
+    const scenarioId = c.req.param("scenarioId");
+    const { scenario, sectionInfoMap } = c.get("scenarioInfo");
+    if (!config.permissions.allowSave) {
+      return c.json({ error: "Save is not allowed" }, 403);
+    }
+    const { content, formData } = await c.req.json();
+    const inputData = transformFormData(formData, sectionInfoMap);
+    const filename = getFilename(
+      scenario,
+      scenarioId,
+      content,
+      formData,
+      inputData
+    );
+    const { outputPath } = await saveDocument({
+      scenario,
+      scenarioId,
+      filename,
+      content,
+      formData
+    });
+    if (scenario.hooks?.onSave != null) {
+      await scenario.hooks.onSave({
+        content,
+        filename,
+        outputPath,
+        formData,
+        inputData
+      });
+    }
+    return c.json({ success: true, filename });
+  });
+  app.get("/api/scenarios/:scenarioId/docs/:filename", async (c) => {
+    const filename = c.req.param("filename");
+    const { scenario } = c.get("scenarioInfo");
+    const result = await readDocument(scenario, filename);
+    if (!result.success) {
+      return c.json({ error: "Document not found" }, 404);
+    }
+    return c.json({ doc: result.doc });
+  });
+  app.put("/api/scenarios/:scenarioId/docs/:filename", async (c) => {
+    const scenarioId = c.req.param("scenarioId");
+    const filename = c.req.param("filename");
+    const { scenario, sectionInfoMap } = c.get("scenarioInfo");
+    if (!config.permissions.allowSave) {
+      return c.json({ error: "Save is not allowed" }, 403);
+    }
+    const { content, formData } = await c.req.json();
+    const inputData = transformFormData(formData, sectionInfoMap);
+    const { outputPath } = await saveDocument({
+      scenario,
+      scenarioId,
+      filename,
+      content,
+      formData
+    });
+    if (scenario.hooks?.onSave != null) {
+      await scenario.hooks.onSave({
+        content,
+        filename,
+        outputPath,
+        formData,
+        inputData
+      });
+    }
+    return c.json({ success: true, filename });
+  });
+  return app;
+};
+
+// src/server/apps/scenarios.ts
+import { Hono as Hono2 } from "hono";
+
+// src/server/helpers/scenarios/build-form-defaults.ts
+var buildFieldDefaults = (fields) => {
+  const getFieldDefaultValue = (field) => {
+    if (isLayoutField(field)) {
+      return void 0;
+    }
+    switch (field.type) {
+      case "checkbox":
+        return false;
+      default:
+        return "";
+    }
+  };
+  const defaults = {};
+  for (const field of fields) {
+    if (isLayoutField(field)) {
+      Object.assign(defaults, buildFieldDefaults(field.fields));
+    } else {
+      defaults[field.id] = getFieldDefaultValue(field);
+    }
+  }
+  return defaults;
+};
+var buildFormDefaultValues = (steps) => {
+  const defaults = {};
+  for (const config of steps) {
+    if (config.section.type === "single") {
+      defaults[config.section.name] = buildFieldDefaults(config.section.fields);
+    } else {
+      const minCount = config.section.minFieldCount ?? 1;
+      defaults[config.section.name] = Array.from(
+        { length: minCount },
+        () => buildFieldDefaults(config.section.fields)
+      );
+    }
+  }
+  return defaults;
+};
+
+// src/server/apps/scenarios.ts
+var createScenariosApp = (config, scenarioInfoMap) => {
+  const app = new Hono2();
+  app.get("/api/scenarios", (c) => {
+    return c.json({
+      scenarios: config.scenarios
+    });
+  });
+  app.get("/api/scenarios/:scenarioId", (c) => {
+    const scenarioId = c.req.param("scenarioId");
+    const scenarioInfo = scenarioInfoMap.get(scenarioId);
+    if (scenarioInfo == null) {
+      return c.json({ error: "Scenario not found" }, 404);
+    }
+    const formDefaultValues = buildFormDefaultValues(
+      scenarioInfo.scenario.steps
+    );
+    return c.json({
+      scenario: scenarioInfo.scenario,
+      formDefaultValues,
+      permissions: config.permissions
+    });
+  });
+  return app;
+};
+
+// src/server/helpers/scenarios/build-section-info.ts
+var extractFieldInfos = (fields) => {
+  const result = [];
+  for (const field of fields) {
+    if (isLayoutField(field)) {
+      result.push(...extractFieldInfos(field.fields));
+    } else {
+      result.push({
+        id: field.id,
+        label: field.label,
+        description: field.description
+      });
+    }
+  }
+  return result;
+};
+var buildSectionInfoMap = (steps) => {
+  const sectionMap = new Map(
+    steps.map((step) => [
+      step.section.name,
+      {
+        name: step.section.name,
+        title: step.title,
+        description: step.description,
+        fields: extractFieldInfos(step.section.fields)
+      }
+    ])
+  );
+  return sectionMap;
+};
+
+// src/server/api.ts
+var createApiServer = (config) => {
+  const app = new Hono3();
+  const scenarioInfoMap = new Map(
+    config.scenarios.map((scenario) => [
+      scenario.id,
+      {
+        scenario,
+        sectionInfoMap: buildSectionInfoMap(scenario.steps)
+      }
+    ])
+  );
+  const scenariosApp = createScenariosApp(config, scenarioInfoMap);
+  const docsApp = createDocsApp(config, scenarioInfoMap);
+  app.route("/", scenariosApp);
+  app.route("/", docsApp);
+  return app;
+};
+
+// src/cli/commands/start.ts
+var getDistClientDir = () => {
+  const __filename = url.fileURLToPath(import.meta.url);
+  const __dirname = path2.dirname(__filename);
+  const isBuilt = __dirname.endsWith("/dist") || __dirname.includes("/dist/");
+  return isBuilt ? path2.resolve(__dirname, "client") : path2.resolve(__dirname, "../../../dist/client");
+};
+var loadConfig = async (configPath) => {
+  const absolutePath = path2.resolve(process.cwd(), configPath);
+  if (!fs2.existsSync(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+  const jiti = createJiti(import.meta.url);
+  const configModule = await jiti.import(absolutePath);
+  const config = configModule.default;
+  const result = safeParseConfig(config);
+  if (!result.success) {
+    const issues = result.issues.map((issue) => {
+      const pathStr = issue.path?.map((p) => p.key).join(".") ?? "";
+      return `  - ${pathStr}: ${issue.message}`;
+    });
+    throw new Error(`Invalid config:
+${issues.join("\n")}`);
+  }
+  return config;
+};
+var runServer = async (config, options) => {
+  consola2.start("Starting server...");
+  const app = createApiServer(config);
+  app.use(
+    "/*",
+    serveStatic({
+      root: options.distDir,
+      rewriteRequestPath: (requestPath) => {
+        const fullPath = path2.join(options.distDir, requestPath);
+        if (fs2.existsSync(fullPath) && fs2.statSync(fullPath).isFile()) {
+          return requestPath;
+        }
+        return "/index.html";
+      }
+    })
+  );
+  const server = serve(
+    {
+      fetch: app.fetch,
+      port: options.port,
+      hostname: options.host
+    },
+    (info) => {
+      const displayHost = info.address === "::1" || info.address === "127.0.0.1" ? "localhost" : info.address;
+      consola2.success("Server started");
+      consola2.info(`  \u279C  Local:   http://${displayHost}:${info.port}/`);
+    }
+  );
+  const cleanup = () => {
+    consola2.info("Shutting down server...");
+    server.close(() => {
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+};
+var startCommand = defineCommand2({
+  meta: {
+    name: "start",
+    description: "Start the server with the specified config"
+  },
+  args: {
+    config: {
+      type: "string",
+      description: "Path to config file",
+      alias: "c",
+      default: "spec-snake.config.ts"
+    },
+    port: {
+      type: "string",
+      description: "Port to run the server on",
+      alias: "p",
+      default: "3000"
+    },
+    host: {
+      type: "string",
+      description: "Host to bind the server to",
+      default: "localhost"
+    }
+  },
+  async run({ args }) {
+    const configPath = args.config;
+    const port = Number.parseInt(args.port, 10);
+    consola2.start(`Loading config from: ${configPath}`);
+    try {
+      const config = await loadConfig(configPath);
+      consola2.success(
+        `Config loaded successfully (${config.scenarios.length} scenarios)`
+      );
+      await runServer(config, {
+        distDir: getDistClientDir(),
+        port,
+        host: args.host
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        consola2.error(error.message);
+      } else {
+        consola2.error("Failed to start server:", error);
+      }
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli/index.ts
+var main = defineCommand3({
+  meta: {
+    name: "design-docs-generator",
+    version: "0.0.1",
+    description: "Design Docs Generator CLI"
+  },
+  subCommands: {
+    init: initCommand,
+    start: startCommand
+  }
+});
+runMain(main);
+//# sourceMappingURL=cli.js.map