@leonarto/spec-embryo 0.1.0

package/src/frontmatter.ts

@@ -0,0 +1,83 @@
+import { parse as parseToml } from "smol-toml";
+
+export interface ParsedFrontmatter {
+  attributes: unknown;
+  body: string;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function formatTomlPrimitive(value: string | number | boolean): string {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+
+  return String(value);
+}
+
+function formatTomlValue(value: unknown): string {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return formatTomlPrimitive(value);
+  }
+
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => formatTomlValue(item)).join(", ")}]`;
+  }
+
+  throw new Error(`Unsupported TOML value: ${String(value)}`);
+}
+
+function formatTomlSection(data: Record<string, unknown>, prefix = ""): string[] {
+  const lines: string[] = [];
+  const nested: Array<{ name: string; value: Record<string, unknown> }> = [];
+
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined) {
+      continue;
+    }
+
+    if (isPlainObject(value)) {
+      nested.push({ name: key, value });
+      continue;
+    }
+
+    lines.push(`${key} = ${formatTomlValue(value)}`);
+  }
+
+  for (const section of nested) {
+    const sectionName = prefix ? `${prefix}.${section.name}` : section.name;
+    lines.push("");
+    lines.push(`[${sectionName}]`);
+    lines.push(...formatTomlSection(section.value, sectionName));
+  }
+
+  return lines;
+}
+
+export function parseTomlFrontmatter(input: string): ParsedFrontmatter {
+  const normalized = input.replace(/\r\n/g, "\n");
+
+  if (!normalized.startsWith("+++\n")) {
+    return { attributes: {}, body: normalized.trim() };
+  }
+
+  const match = normalized.match(/^\+\+\+\n([\s\S]*?)\n\+\+\+\n?([\s\S]*)$/);
+
+  if (!match) {
+    throw new Error("Invalid TOML frontmatter. Expected opening and closing +++ fences.");
+  }
+
+  const [, rawAttributes, body = ""] = match;
+  return {
+    attributes: parseToml(rawAttributes),
+    body: body.trim(),
+  };
+}
+
+export function serializeTomlFrontmatter(attributes: Record<string, unknown>, body: string): string {
+  const toml = formatTomlSection(attributes).join("\n").trimEnd();
+  const trimmedBody = body.trim();
+  return `+++\n${toml}\n+++\n\n${trimmedBody}\n`;
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env bun
+
+import { cwd, exit } from "node:process";
+import { helpText, parseArgs } from "./cli.ts";
+import { runAgentsCommand } from "./commands/agents.ts";
+import { runCurrentCommand } from "./commands/current.ts";
+import { runDoctorCommand } from "./commands/doctor.ts";
+import { runHandoffCommand } from "./commands/handoff.ts";
+import { runInitCommand } from "./commands/init.ts";
+import { runReshapeCommand } from "./commands/reshape.ts";
+import { runResumeCommand } from "./commands/resume.ts";
+import { runSpecCommand } from "./commands/spec.ts";
+import { runStatusCommand } from "./commands/status.ts";
+import { runTaskCommand } from "./commands/task.ts";
+import { runUiCommand } from "./commands/ui.ts";
+
+async function main(): Promise<void> {
+  const parsed = parseArgs(process.argv.slice(2));
+  const rootDir = cwd();
+
+  if (!parsed.command || parsed.command === "--help" || parsed.command === "help") {
+    console.log(helpText());
+    return;
+  }
+
+  let output: string;
+
+  switch (parsed.command) {
+    case "init":
+      output = await runInitCommand(rootDir, parsed);
+      break;
+    case "status":
+      output = await runStatusCommand(rootDir, parsed);
+      break;
+    case "doctor":
+      output = await runDoctorCommand(rootDir, parsed);
+      break;
+    case "ui":
+      output = await runUiCommand(rootDir, parsed);
+      break;
+    case "reshape":
+      output = await runReshapeCommand(rootDir, parsed);
+      break;
+    case "resume":
+      output = await runResumeCommand(rootDir, parsed);
+      break;
+    case "handoff":
+      output = await runHandoffCommand(rootDir, parsed);
+      break;
+    case "current":
+      output = await runCurrentCommand(rootDir, parsed);
+      break;
+    case "agents":
+      output = await runAgentsCommand(rootDir, parsed);
+      break;
+    case "spec":
+      output = await runSpecCommand(rootDir, parsed);
+      break;
+    case "task":
+      output = await runTaskCommand(rootDir, parsed);
+      break;
+    default:
+      throw new Error(`Unknown command: ${parsed.command}`);
+  }
+
+  if (output.length > 0) {
+    console.log(output);
+  }
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`spec-embryo error: ${message}`);
+  exit(1);
+});

package/src/paths.ts

@@ -0,0 +1,32 @@
+import { join } from "node:path";
+import type { ProjectConfig } from "./domain.ts";
+
+export interface ProjectPaths {
+  rootDir: string;
+  specpmDir: string;
+  configFile: string;
+  tempDir: string;
+  memoryDir: string;
+  stateFile: string;
+  handoffsDir: string;
+  specsDir: string;
+  tasksDir: string;
+  skillsDir: string;
+  templatesDir: string;
+}
+
+export function resolveProjectPaths(rootDir: string, config?: ProjectConfig): ProjectPaths {
+  return {
+    rootDir,
+    specpmDir: join(rootDir, ".specpm"),
+    configFile: join(rootDir, ".specpm", "config.toml"),
+    tempDir: join(rootDir, ".specpm", "tmp"),
+    memoryDir: config ? join(rootDir, config.memoryDir) : join(rootDir, "docs", "spm"),
+    stateFile: config ? join(rootDir, config.stateFile) : join(rootDir, "docs", "spm", "current.md"),
+    handoffsDir: config ? join(rootDir, config.handoffsDir) : join(rootDir, "docs", "spm", "handoffs"),
+    specsDir: config ? join(rootDir, config.specsDir) : join(rootDir, "docs", "spm", "specs"),
+    tasksDir: config ? join(rootDir, config.tasksDir) : join(rootDir, "docs", "spm", "tasks"),
+    skillsDir: config ? join(rootDir, config.skillsDir) : join(rootDir, "docs", "spm", "skills"),
+    templatesDir: join(rootDir, ".specpm", "templates"),
+  };
+}