promptopskit 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,785 @@
+#!/usr/bin/env node
+
+// src/cli/commands/validate.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { join, extname } from "path";
+
+// src/parser/parser.ts
+import matter from "gray-matter";
+
+// src/schema/schema.ts
+import { z } from "zod";
+var InlineToolDefSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  input_schema: z.record(z.unknown()).optional()
+});
+var ToolRefSchema = z.union([z.string(), InlineToolDefSchema]);
+var MCPServerRefSchema = z.union([
+  z.string(),
+  z.object({
+    name: z.string(),
+    config: z.record(z.unknown()).optional()
+  })
+]);
+var ReasoningSchema = z.object({
+  effort: z.enum(["low", "medium", "high"]).optional(),
+  budget_tokens: z.number().int().positive().optional()
+});
+var SamplingSchema = z.object({
+  temperature: z.number().min(0).max(2).optional(),
+  top_p: z.number().min(0).max(1).optional(),
+  frequency_penalty: z.number().optional(),
+  presence_penalty: z.number().optional(),
+  stop: z.array(z.string()).optional(),
+  max_output_tokens: z.number().int().positive().optional()
+});
+var ResponseSchema = z.object({
+  format: z.enum(["text", "json", "markdown"]).optional(),
+  stream: z.boolean().optional()
+});
+var HistorySchema = z.object({
+  max_items: z.number().int().positive().optional()
+});
+var ContextSchema = z.object({
+  inputs: z.array(z.string()).optional(),
+  history: HistorySchema.optional()
+});
+var MetadataSchema = z.object({
+  owner: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  review_required: z.boolean().optional(),
+  stable: z.boolean().optional()
+});
+var MCPSchema = z.object({
+  servers: z.array(MCPServerRefSchema).optional()
+});
+var PromptAssetOverridesSchema = z.object({
+  model: z.string().optional(),
+  fallback_models: z.array(z.string()).optional(),
+  reasoning: ReasoningSchema.optional(),
+  sampling: SamplingSchema.optional(),
+  response: ResponseSchema.optional(),
+  tools: z.array(ToolRefSchema).optional()
+});
+var SourceSchema = z.object({
+  file_path: z.string().optional(),
+  checksum: z.string().optional()
+});
+var SectionsSchema = z.object({
+  system_instructions: z.string().optional(),
+  prompt_template: z.string().optional(),
+  notes: z.string().optional()
+});
+var PromptAssetSchema = z.object({
+  id: z.string(),
+  schema_version: z.number().int().positive().default(1),
+  description: z.string().optional(),
+  provider: z.enum(["openai", "anthropic", "google", "openrouter", "any"]).optional(),
+  model: z.string().optional(),
+  fallback_models: z.array(z.string()).optional(),
+  reasoning: ReasoningSchema.optional(),
+  sampling: SamplingSchema.optional(),
+  response: ResponseSchema.optional(),
+  tools: z.array(ToolRefSchema).optional(),
+  mcp: MCPSchema.optional(),
+  context: ContextSchema.optional(),
+  includes: z.array(z.string()).optional(),
+  environments: z.record(PromptAssetOverridesSchema).optional(),
+  tiers: z.record(PromptAssetOverridesSchema).optional(),
+  metadata: MetadataSchema.optional(),
+  // Populated by parser, not authored in YAML
+  sections: SectionsSchema.optional(),
+  source: SourceSchema.optional()
+});
+
+// src/parser/sections.ts
+var SECTION_MAP = {
+  "system instructions": "system_instructions",
+  "prompt template": "prompt_template",
+  "notes": "notes"
+};
+function extractSections(body) {
+  const lines = body.split("\n");
+  const sections = {};
+  let currentKey = null;
+  let currentLines = [];
+  let foundAnyH1 = false;
+  for (const line of lines) {
+    const h1Match = line.match(/^#\s+(.+)$/);
+    if (h1Match) {
+      if (currentKey) {
+        sections[currentKey] = currentLines.join("\n").trim();
+      }
+      foundAnyH1 = true;
+      const heading = h1Match[1].trim().toLowerCase();
+      currentKey = SECTION_MAP[heading] ?? null;
+      currentLines = [];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  if (currentKey) {
+    sections[currentKey] = currentLines.join("\n").trim();
+  }
+  if (!foundAnyH1) {
+    const trimmed = body.trim();
+    if (trimmed) {
+      sections.prompt_template = trimmed;
+    }
+  }
+  return sections;
+}
+
+// src/parser/parser.ts
+function parsePrompt(content, filePath) {
+  const { data: frontMatter, content: body } = matter(content);
+  const sections = extractSections(body);
+  const raw = {
+    ...frontMatter,
+    sections,
+    source: filePath ? { file_path: filePath } : void 0
+  };
+  const asset = PromptAssetSchema.parse(raw);
+  return {
+    asset,
+    raw: {
+      frontMatter,
+      body
+    }
+  };
+}
+
+// src/parser/loader.ts
+import { readFile } from "fs/promises";
+
+// src/renderer/interpolate.ts
+var VARIABLE_RE = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g;
+var ESCAPED_OPEN = /\\\{\\\{/g;
+var ESCAPE_PLACEHOLDER = "\0ESCAPED_OPEN\0";
+function interpolate(template, variables, options = {}) {
+  const { strict = false } = options;
+  let result = template.replace(ESCAPED_OPEN, ESCAPE_PLACEHOLDER);
+  result = result.replace(VARIABLE_RE, (match, name) => {
+    if (name in variables) {
+      return variables[name];
+    }
+    if (strict) {
+      throw new Error(`Missing required variable: "${name}"`);
+    }
+    return match;
+  });
+  result = result.replaceAll(ESCAPE_PLACEHOLDER, "{{");
+  return result;
+}
+function extractVariables(template) {
+  const vars = /* @__PURE__ */ new Set();
+  let match;
+  const re = new RegExp(VARIABLE_RE.source, "g");
+  while ((match = re.exec(template)) !== null) {
+    vars.add(match[1]);
+  }
+  return [...vars];
+}
+
+// src/validation/levenshtein.ts
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+
+// src/validation/validate.ts
+var KNOWN_FRONT_MATTER_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "schema_version",
+  "description",
+  "provider",
+  "model",
+  "fallback_models",
+  "reasoning",
+  "sampling",
+  "response",
+  "tools",
+  "mcp",
+  "context",
+  "includes",
+  "environments",
+  "tiers",
+  "metadata"
+]);
+function validateAsset(asset, frontMatterKeys, filePath) {
+  const errors = [];
+  const warnings = [];
+  const result = PromptAssetSchema.safeParse(asset);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      errors.push({
+        code: "POK001",
+        message: `Schema error at ${issue.path.join(".")}: ${issue.message}`,
+        filePath
+      });
+    }
+  }
+  if (!asset.id) {
+    errors.push({
+      code: "POK002",
+      message: 'Missing required field: "id"',
+      filePath
+    });
+  }
+  if (!asset.sections?.system_instructions && !asset.sections?.prompt_template) {
+    errors.push({
+      code: "POK003",
+      message: "Prompt must have at least one body section (System instructions or Prompt template)",
+      filePath
+    });
+  }
+  if (frontMatterKeys) {
+    for (const key of frontMatterKeys) {
+      if (!KNOWN_FRONT_MATTER_KEYS.has(key)) {
+        const suggestion = findClosestMatch(key, KNOWN_FRONT_MATTER_KEYS);
+        warnings.push({
+          code: "POK010",
+          message: `Unknown front matter field: "${key}"`,
+          filePath,
+          suggestion: suggestion ? `Did you mean "${suggestion}"?` : void 0
+        });
+      }
+    }
+  }
+  const declaredInputs = new Set(asset.context?.inputs ?? []);
+  const usedVars = /* @__PURE__ */ new Set();
+  if (asset.sections?.system_instructions) {
+    for (const v of extractVariables(asset.sections.system_instructions)) {
+      usedVars.add(v);
+    }
+  }
+  if (asset.sections?.prompt_template) {
+    for (const v of extractVariables(asset.sections.prompt_template)) {
+      usedVars.add(v);
+    }
+  }
+  for (const v of usedVars) {
+    if (declaredInputs.size > 0 && !declaredInputs.has(v)) {
+      warnings.push({
+        code: "POK011",
+        message: `Variable "{{ ${v} }}" is used but not declared in context.inputs`,
+        filePath
+      });
+    }
+  }
+  for (const v of declaredInputs) {
+    if (!usedVars.has(v)) {
+      warnings.push({
+        code: "POK012",
+        message: `Variable "${v}" is declared in context.inputs but never used`,
+        filePath
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function findClosestMatch(input, candidates) {
+  let best;
+  let bestDist = Infinity;
+  for (const candidate of candidates) {
+    const dist = levenshtein(input.toLowerCase(), candidate.toLowerCase());
+    if (dist < bestDist && dist <= 3) {
+      bestDist = dist;
+      best = candidate;
+    }
+  }
+  return best;
+}
+
+// src/cli/commands/validate.ts
+var HELP = `
+promptopskit validate <dir>
+
+Validate all prompt .md files in a directory.
+
+Options:
+  --strict       Treat warnings as errors
+  --help, -h     Show this help
+`.trim();
+async function validate(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(HELP);
+    return;
+  }
+  const dir = args.find((a) => !a.startsWith("--"));
+  if (!dir) {
+    console.error("Error: Please provide a directory to validate.");
+    process.exit(1);
+  }
+  const strict = args.includes("--strict");
+  const files = await collectPromptFiles(dir);
+  if (files.length === 0) {
+    console.log(`No .md prompt files found in ${dir}`);
+    return;
+  }
+  let errorCount = 0;
+  let warnCount = 0;
+  for (const file of files) {
+    try {
+      const content = await readFile2(file, "utf-8");
+      const { asset, raw } = parsePrompt(content, file);
+      const result = validateAsset(asset, Object.keys(raw.frontMatter), file);
+      if (result.errors.length > 0) {
+        errorCount += result.errors.length;
+        console.error(`  \u2717 ${file}`);
+        for (const err of result.errors) {
+          console.error(`    ${err.code}: ${err.message}`);
+        }
+      } else {
+        console.log(`  \u2713 ${file}`);
+      }
+      if (result.warnings.length > 0) {
+        warnCount += result.warnings.length;
+        for (const warn of result.warnings) {
+          const suggestion = warn.suggestion ? ` (${warn.suggestion})` : "";
+          console.warn(`    \u26A0 ${warn.code}: ${warn.message}${suggestion}`);
+        }
+      }
+    } catch (err) {
+      errorCount++;
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`  \u2717 ${file}`);
+      console.error(`    ${message}`);
+    }
+  }
+  console.log();
+  console.log(`Validated ${files.length} file(s): ${errorCount} error(s), ${warnCount} warning(s)`);
+  if (errorCount > 0 || strict && warnCount > 0) {
+    process.exit(1);
+  }
+}
+async function collectPromptFiles(dir) {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true, recursive: true });
+  for (const entry of entries) {
+    if (entry.isFile() && extname(entry.name) === ".md" && !entry.name.endsWith(".test.md")) {
+      results.push(join(entry.parentPath ?? dir, entry.name));
+    }
+  }
+  return results.sort();
+}
+
+// src/cli/commands/compile.ts
+import { readdir as readdir2, readFile as readFile3, writeFile, mkdir, rm } from "fs/promises";
+import { join as join2, extname as extname2, relative, dirname } from "path";
+var HELP2 = `
+promptopskit compile <sourceDir> <outputDir> [options]
+
+Compile .md prompt files to JSON artifacts.
+
+Options:
+  --no-clean     Don't clear the output directory before compiling
+  --dry-run      Show what would be compiled without writing files
+  --format       Output format: json (default) or esm
+  --help, -h     Show this help
+`.trim();
+async function compile(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(HELP2);
+    return;
+  }
+  const positional = args.filter((a) => !a.startsWith("--"));
+  const sourceDir = positional[0];
+  const outputDir = positional[1];
+  if (!sourceDir || !outputDir) {
+    console.error("Error: Please provide source and output directories.");
+    console.error("Usage: promptopskit compile <sourceDir> <outputDir>");
+    process.exit(1);
+  }
+  const dryRun = args.includes("--dry-run");
+  const noClean = args.includes("--no-clean");
+  const format = getFlag(args, "--format") ?? "json";
+  if (format !== "json" && format !== "esm") {
+    console.error(`Error: Unknown format "${format}". Use "json" or "esm".`);
+    process.exit(1);
+  }
+  const files = await collectPromptFiles2(sourceDir);
+  if (files.length === 0) {
+    console.log(`No .md prompt files found in ${sourceDir}`);
+    return;
+  }
+  if (!noClean && !dryRun) {
+    await rm(outputDir, { recursive: true, force: true });
+  }
+  let compiled = 0;
+  let errors = 0;
+  for (const file of files) {
+    const rel = relative(sourceDir, file).replace(/\.md$/, "");
+    const outExt = format === "esm" ? ".mjs" : ".json";
+    const outPath = join2(outputDir, rel + outExt);
+    try {
+      const content = await readFile3(file, "utf-8");
+      const { asset } = parsePrompt(content, file);
+      if (dryRun) {
+        console.log(`  Would create: ${outPath}`);
+      } else {
+        await mkdir(dirname(outPath), { recursive: true });
+        if (format === "esm") {
+          const esmContent = `export default ${JSON.stringify(asset, null, 2)};
+`;
+          await writeFile(outPath, esmContent, "utf-8");
+        } else {
+          await writeFile(outPath, JSON.stringify(asset, null, 2) + "\n", "utf-8");
+        }
+        console.log(`  \u2713 ${outPath}`);
+      }
+      compiled++;
+    } catch (err) {
+      errors++;
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`  \u2717 ${file}`);
+      console.error(`    ${message}`);
+    }
+  }
+  console.log();
+  if (dryRun) {
+    console.log(`Dry run: ${compiled} file(s) would be compiled, ${errors} error(s)`);
+  } else {
+    console.log(`Compiled ${compiled} file(s), ${errors} error(s)`);
+  }
+  if (errors > 0) {
+    process.exit(1);
+  }
+}
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx >= 0 && idx + 1 < args.length) {
+    return args[idx + 1];
+  }
+  return void 0;
+}
+async function collectPromptFiles2(dir) {
+  const results = [];
+  const entries = await readdir2(dir, { withFileTypes: true, recursive: true });
+  for (const entry of entries) {
+    if (entry.isFile() && extname2(entry.name) === ".md" && !entry.name.endsWith(".test.md")) {
+      results.push(join2(entry.parentPath ?? dir, entry.name));
+    }
+  }
+  return results.sort();
+}
+
+// src/cli/commands/render.ts
+import { readFile as readFile4 } from "fs/promises";
+import { existsSync } from "fs";
+
+// src/overrides/apply-overrides.ts
+function applyOverrides(asset, options = {}) {
+  let result = { ...asset };
+  if (options.environment && result.environments?.[options.environment]) {
+    result = mergeOverride(result, result.environments[options.environment]);
+  }
+  if (options.tier && result.tiers?.[options.tier]) {
+    result = mergeOverride(result, result.tiers[options.tier]);
+  }
+  if (options.runtime) {
+    result = mergeOverride(result, options.runtime);
+  }
+  return result;
+}
+function mergeOverride(base, override) {
+  const result = { ...base };
+  if (override.model !== void 0) result.model = override.model;
+  if (override.fallback_models !== void 0) result.fallback_models = override.fallback_models;
+  if (override.tools !== void 0) result.tools = override.tools;
+  if (override.reasoning !== void 0) {
+    result.reasoning = { ...result.reasoning, ...override.reasoning };
+  }
+  if (override.sampling !== void 0) {
+    result.sampling = { ...result.sampling, ...override.sampling };
+  }
+  if (override.response !== void 0) {
+    result.response = { ...result.response, ...override.response };
+  }
+  return result;
+}
+
+// src/cli/commands/render.ts
+var HELP3 = `
+promptopskit render <file> [options]
+
+Render a prompt preview with variables.
+
+Options:
+  --env <name>       Environment override
+  --tier <name>      Tier override
+  --vars <file>      JSON file with variables
+  --json             Output raw JSON instead of readable format
+  --help, -h         Show this help
+`.trim();
+async function render(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(HELP3);
+    return;
+  }
+  const file = args.find((a) => !a.startsWith("--"));
+  if (!file) {
+    console.error("Error: Please provide a prompt file to render.");
+    process.exit(1);
+  }
+  const env = getFlag2(args, "--env");
+  const tier = getFlag2(args, "--tier");
+  const varsFile = getFlag2(args, "--vars");
+  const jsonOutput = args.includes("--json");
+  let variables = {};
+  if (varsFile) {
+    const varsContent = await readFile4(varsFile, "utf-8");
+    variables = JSON.parse(varsContent);
+  } else {
+    const sidecarPath = file.replace(/\.md$/, ".test.yaml");
+    if (existsSync(sidecarPath)) {
+      const { default: yaml } = await import("gray-matter");
+      const sidecarContent = await readFile4(sidecarPath, "utf-8");
+      const parsed = yaml(`---
+${sidecarContent}---
+`);
+      const data = parsed.data;
+      if (data.cases?.[0]?.variables) {
+        variables = data.cases[0].variables;
+      }
+    }
+  }
+  const content = await readFile4(file, "utf-8");
+  const { asset } = parsePrompt(content, file);
+  const overridden = applyOverrides(asset, {
+    environment: env,
+    tier
+  });
+  const renderedSystem = overridden.sections?.system_instructions ? interpolate(overridden.sections.system_instructions, variables) : void 0;
+  const renderedPrompt = overridden.sections?.prompt_template ? interpolate(overridden.sections.prompt_template, variables) : void 0;
+  if (jsonOutput) {
+    console.log(JSON.stringify({
+      id: overridden.id,
+      provider: overridden.provider,
+      model: overridden.model,
+      system_instructions: renderedSystem,
+      prompt_template: renderedPrompt,
+      tools: overridden.tools
+    }, null, 2));
+    return;
+  }
+  const label = [
+    overridden.provider,
+    overridden.model,
+    [env, tier].filter(Boolean).join("/")
+  ].filter(Boolean).join(", ");
+  console.log(`\u2500\u2500 ${overridden.id} (${label}) ${"\u2500".repeat(Math.max(0, 50 - overridden.id.length - label.length))}`);
+  if (renderedSystem) {
+    console.log(`System: ${renderedSystem.split("\n")[0]}${renderedSystem.includes("\n") ? "..." : ""}`);
+  }
+  if (renderedPrompt) {
+    console.log(`User:   ${renderedPrompt.split("\n")[0]}${renderedPrompt.includes("\n") ? "..." : ""}`);
+  }
+  if (overridden.tools?.length) {
+    const toolNames = overridden.tools.map((t) => typeof t === "string" ? t : t.name);
+    console.log(`Tools:  ${toolNames.join(", ")}`);
+  }
+  console.log(`Model:  ${overridden.model ?? "not set"}`);
+  console.log("\u2500".repeat(60));
+}
+function getFlag2(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx >= 0 && idx + 1 < args.length) {
+    return args[idx + 1];
+  }
+  return void 0;
+}
+
+// src/cli/commands/inspect.ts
+import { readFile as readFile5 } from "fs/promises";
+var HELP4 = `
+promptopskit inspect <file>
+
+Print the normalized prompt asset as JSON.
+
+Options:
+  --help, -h     Show this help
+`.trim();
+async function inspect(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(HELP4);
+    return;
+  }
+  const file = args.find((a) => !a.startsWith("--"));
+  if (!file) {
+    console.error("Error: Please provide a prompt file to inspect.");
+    process.exit(1);
+  }
+  const content = await readFile5(file, "utf-8");
+  const { asset } = parsePrompt(content, file);
+  console.log(JSON.stringify(asset, null, 2));
+}
+
+// src/cli/commands/init.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3, dirname as dirname2 } from "path";
+import { existsSync as existsSync2, readFileSync } from "fs";
+var HELP5 = `
+promptopskit init [dir]
+
+Scaffold a prompts directory with starter files.
+
+Options:
+  --help, -h     Show this help
+`.trim();
+var HELLO_PROMPT = `---
+id: hello
+schema_version: 1
+provider: openai
+model: gpt-5.4
+context:
+  inputs:
+    - name
+includes:
+  - ./shared/tone.md
+---
+
+# System instructions
+
+You are a friendly assistant. Be helpful and concise.
+
+# Prompt template
+
+Say hello to {{ name }} and ask how you can help them today.
+`.trimStart();
+var TONE_INCLUDE = `---
+id: shared.tone
+schema_version: 1
+---
+
+# System instructions
+
+Always be polite, professional, and concise. Avoid jargon unless the user uses it first.
+`.trimStart();
+var TEST_SIDECAR = `cases:
+  - name: basic-greeting
+    variables:
+      name: "World"
+  - name: named-greeting
+    variables:
+      name: "Alice"
+`;
+async function init(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(HELP5);
+    return;
+  }
+  const dir = args.find((a) => !a.startsWith("--")) ?? "./prompts";
+  const files = [
+    { path: join3(dir, "hello.md"), content: HELLO_PROMPT },
+    { path: join3(dir, "hello.test.yaml"), content: TEST_SIDECAR },
+    { path: join3(dir, "shared", "tone.md"), content: TONE_INCLUDE }
+  ];
+  let created = 0;
+  let skipped = 0;
+  for (const file of files) {
+    if (existsSync2(file.path)) {
+      console.log(`  skip ${file.path} (already exists)`);
+      skipped++;
+      continue;
+    }
+    await mkdir2(dirname2(file.path), { recursive: true });
+    await writeFile2(file.path, file.content, "utf-8");
+    console.log(`  \u2713 ${file.path}`);
+    created++;
+  }
+  console.log();
+  console.log(`Created ${created} file(s), skipped ${skipped} existing.`);
+  if (existsSync2("package.json")) {
+    try {
+      const pkg = JSON.parse(readFileSync("package.json", "utf-8"));
+      if (!pkg.scripts?.["build:prompts"]) {
+        console.log();
+        console.log(`Tip: Add to your package.json scripts:`);
+        console.log(`  "build:prompts": "promptopskit compile ${dir} ./dist/prompts"`);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/cli/index.ts
+var HELP6 = `
+promptopskit \u2014 Manage prompts, system instructions, tools, and model settings as code
+
+Usage:
+  promptopskit <command> [options]
+
+Commands:
+  init [dir]                           Scaffold a prompts directory with starter files
+  validate <dir>                       Validate prompt files
+  compile <src> <out> [options]        Compile .md prompts to JSON/ESM artifacts
+  render <file> [options]              Render a prompt preview
+  inspect <file>                       Print normalized prompt asset
+
+Options:
+  --help, -h                           Show this help message
+  --version, -v                        Show version
+
+Run promptopskit <command> --help for command-specific help.
+`.trim();
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h") {
+    console.log(HELP6);
+    process.exit(0);
+  }
+  if (command === "--version" || command === "-v") {
+    console.log("0.0.1");
+    process.exit(0);
+  }
+  const commandArgs = args.slice(1);
+  switch (command) {
+    case "init":
+      await init(commandArgs);
+      break;
+    case "validate":
+      await validate(commandArgs);
+      break;
+    case "compile":
+      await compile(commandArgs);
+      break;
+    case "render":
+      await render(commandArgs);
+      break;
+    case "inspect":
+      await inspect(commandArgs);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP6);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map