@leonarto/spec-embryo 0.1.0

package/src/commands/spec.ts

@@ -0,0 +1,108 @@
+import type { ParsedArgs } from "../cli.ts";
+import { flagValue } from "../cli.ts";
+import { SPEC_STATUSES, isSpecStatus } from "../domain.ts";
+import { createSpec, loadProjectContext, readProjectConfig, setSpecStatus } from "../repository.ts";
+import { buildSpecImportBundle, renderSpecImportBundle } from "../services/spec-import.ts";
+
+function parseCommaList(value: string | undefined): string[] {
+  return value
+    ? value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+    : [];
+}
+
+export async function runSpecCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  if (parsed.subcommand === "create") {
+    const title = flagValue(parsed, "title");
+    const summary = flagValue(parsed, "summary");
+    const status = flagValue(parsed, "status");
+
+    if (!title || !summary) {
+      throw new Error("`spec create` requires --title and --summary.");
+    }
+
+    if (status && !isSpecStatus(status)) {
+      throw new Error(`Invalid spec status: ${status}. Expected one of ${SPEC_STATUSES.join(", ")}.`);
+    }
+
+    const spec = await createSpec(rootDir, {
+      title,
+      summary,
+      status,
+      taskIds: parseCommaList(flagValue(parsed, "task-ids")),
+      tags: parseCommaList(flagValue(parsed, "tags")),
+      owner: flagValue(parsed, "owner"),
+    });
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(spec, null, 2);
+    }
+
+    return `Created ${spec.id} [${spec.status}] in ${spec.filePath}`;
+  }
+
+  if (parsed.subcommand === "set-status") {
+    const specId = parsed.positionals[2];
+    const status = parsed.positionals[3];
+
+    if (!specId || !status) {
+      throw new Error("`spec set-status` requires <SPEC-ID> <status>.");
+    }
+
+    if (!isSpecStatus(status)) {
+      throw new Error(`Invalid spec status: ${status}. Expected one of ${SPEC_STATUSES.join(", ")}.`);
+    }
+
+    const spec = await setSpecStatus(rootDir, specId, status);
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(spec, null, 2);
+    }
+
+    return `Updated ${spec.id} to [${spec.status}] in ${spec.filePath}`;
+  }
+
+  if (parsed.subcommand === "import-prompt") {
+    const source = flagValue(parsed, "source");
+    if (!source) {
+      throw new Error("`spec import-prompt` requires --source <folder>.");
+    }
+
+    const maxCharsRaw = flagValue(parsed, "max-chars-per-file");
+    const maxCharsPerFile = maxCharsRaw ? Number.parseInt(maxCharsRaw, 10) : undefined;
+    const config = await readProjectConfig(rootDir);
+    const bundle = await buildSpecImportBundle(rootDir, source, {
+      instructions: flagValue(parsed, "instructions"),
+      maxCharsPerFile: Number.isFinite(maxCharsPerFile) ? maxCharsPerFile : undefined,
+      targetMemoryDir: config.memoryDir,
+    });
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(bundle, null, 2);
+    }
+
+    return renderSpecImportBundle(bundle);
+  }
+
+  if (parsed.subcommand !== "list") {
+    throw new Error("Supported spec commands in v1 are `spec list`, `spec create`, `spec set-status`, and `spec import-prompt`.");
+  }
+
+  const context = await loadProjectContext(rootDir);
+  const statusFilter = flagValue(parsed, "status");
+  const specs = context.specs.filter((spec) => (statusFilter ? spec.status === statusFilter : true));
+
+  if (parsed.flags.has("json")) {
+    return JSON.stringify(specs, null, 2);
+  }
+
+  if (specs.length === 0) {
+    return "No specs found.";
+  }
+
+  return specs
+    .map((spec) => `${spec.id} [${spec.status}] ${spec.title}\n  tasks: ${spec.taskIds.join(", ") || "none"}\n  ${spec.summary}`)
+    .join("\n\n");
+}

package/src/commands/status.ts

@@ -0,0 +1,98 @@
+import type { ParsedArgs } from "../cli.ts";
+import { deriveStatusSnapshot, deriveNextActions } from "../engine.ts";
+import { loadProjectContext } from "../repository.ts";
+import { buildAgentsHealthReport } from "../services/agents.ts";
+
+export async function runStatusCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  const [context, agentsReport] = await Promise.all([loadProjectContext(rootDir), buildAgentsHealthReport(rootDir)]);
+  const snapshot = deriveStatusSnapshot(context);
+  const nextActions = deriveNextActions(context, snapshot);
+
+  if (parsed.flags.has("json")) {
+    return JSON.stringify(
+      {
+        project: context.config.projectName,
+        focus: context.currentState.focus,
+        summary: context.currentState.summary,
+        counts: {
+          specs: snapshot.specCount,
+          tasks: snapshot.taskCount,
+          in_progress: snapshot.inProgressTasks.length,
+          review: snapshot.reviewTasks.length,
+          blocked: snapshot.blockedTasks.length,
+          ready: snapshot.readyTasks.length,
+        },
+        active_spec_ids: snapshot.activeSpecIds,
+        active_task_ids: snapshot.activeTaskIds,
+        next_actions: nextActions,
+        missing_dependencies: snapshot.missingDependencies,
+        changed_items: snapshot.changedItems,
+        git: context.git,
+        agents: agentsReport.summary,
+      },
+      null,
+      2,
+    );
+  }
+
+  const lines = [
+    `Project: ${context.config.projectName}`,
+    `Focus: ${context.currentState.focus}`,
+    `Summary: ${context.currentState.summary}`,
+    "",
+    `Specs: ${snapshot.specCount} total | active ${snapshot.activeSpecIds.length}`,
+    `Tasks: ${snapshot.taskCount} total | in progress ${snapshot.inProgressTasks.length} | review ${snapshot.reviewTasks.length} | blocked ${snapshot.blockedTasks.length} | ready ${snapshot.readyTasks.length}`,
+    `Git: ${context.git.available ? `${context.git.branch ?? "unknown"}${context.git.dirty ? " (dirty)" : " (clean)"}` : "not available"}`,
+    `AGENTS: ${agentsReport.summary.ok ? "healthy" : "needs attention"} | files ${agentsReport.summary.fileCount} | max file ${agentsReport.summary.maxFileTokens} tokens | max chain ${agentsReport.summary.maxChainTokens} tokens`,
+    "",
+    "Active specs:",
+    ...(snapshot.activeSpecIds.length > 0 ? snapshot.activeSpecIds.map((id) => `- ${id}`) : ["- none"]),
+    "Active tasks:",
+    ...(snapshot.activeTaskIds.length > 0 ? snapshot.activeTaskIds.map((id) => `- ${id}`) : ["- none"]),
+    "Next actions:",
+    ...nextActions.map((action) => `- ${action}`),
+  ];
+
+  if (snapshot.blockedTasks.length > 0) {
+    lines.push("", "Blocked tasks:");
+    for (const blocked of snapshot.blockedTasks) {
+      const reason = blocked.unmetDependencies.length > 0 ? blocked.unmetDependencies.join(", ") : "manually blocked";
+      lines.push(`- ${blocked.task.id}: ${blocked.task.title} (${reason})`);
+    }
+  }
+
+  if (snapshot.reviewTasks.length > 0) {
+    lines.push("", "Review tasks:");
+    for (const review of snapshot.reviewTasks) {
+      lines.push(`- ${review.task.id}: ${review.task.title}`);
+    }
+  }
+
+  if (snapshot.missingDependencies.length > 0) {
+    lines.push("", "Dependency issues:");
+    for (const item of snapshot.missingDependencies) {
+      lines.push(`- ${item.taskId} references missing dependency ${item.missingTaskId}`);
+    }
+  }
+
+  if (snapshot.changedItems.length > 0) {
+    lines.push("", "Changed items:");
+    for (const item of snapshot.changedItems.slice(0, 10)) {
+      const label = item.id ? `${item.id}${item.title ? `: ${item.title}` : ""}` : item.path;
+      lines.push(`- [${item.kind}] ${label}`);
+    }
+  }
+
+  if (snapshot.recentHandoff) {
+    lines.push("", `Recent handoff: ${snapshot.recentHandoff.id} | ${snapshot.recentHandoff.title}`);
+  }
+
+  if (!agentsReport.summary.ok) {
+    lines.push("", "AGENTS issues:");
+    for (const failure of agentsReport.failures) {
+      lines.push(`- ${failure}`);
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/commands/task.ts

@@ -0,0 +1,190 @@
+import type { ParsedArgs } from "../cli.ts";
+import { flagValue } from "../cli.ts";
+import { TASK_STATUSES, isTaskStatus } from "../domain.ts";
+import { buildTaskIndex, summarizeTaskNode } from "../engine.ts";
+import { archiveCancelledTasks, archiveDoneTasks, archiveTask, createTask, loadProjectContext, restoreTask, setTaskStatus } from "../repository.ts";
+
+function parseCommaList(value: string | undefined): string[] {
+  return value
+    ? value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+    : [];
+}
+
+export async function runTaskCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  if (parsed.subcommand === "create") {
+    const title = flagValue(parsed, "title");
+    const summary = flagValue(parsed, "summary");
+    const specIds = parseCommaList(flagValue(parsed, "spec-ids"));
+    const status = flagValue(parsed, "status");
+    const priorityRaw = flagValue(parsed, "priority");
+    const priority = priorityRaw ? Number.parseInt(priorityRaw, 10) : undefined;
+
+    if (!title || !summary) {
+      throw new Error("`task create` requires --title and --summary.");
+    }
+
+    if (specIds.length === 0) {
+      throw new Error("`task create` requires --spec-ids <SPEC-001[,SPEC-002]>.");
+    }
+
+    if (status && !isTaskStatus(status)) {
+      throw new Error(`Invalid task status: ${status}. Expected one of ${TASK_STATUSES.join(", ")}.`);
+    }
+
+    if (priority !== undefined && (!Number.isFinite(priority) || priority <= 0)) {
+      throw new Error("`task create --priority` must be a positive integer.");
+    }
+
+    const task = await createTask(rootDir, {
+      title,
+      summary,
+      specIds,
+      status,
+      priority,
+      dependsOn: parseCommaList(flagValue(parsed, "depends-on")),
+      blockedBy: parseCommaList(flagValue(parsed, "blocked-by")),
+      ownerRole: flagValue(parsed, "owner-role"),
+      tags: parseCommaList(flagValue(parsed, "tags")),
+    });
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(task, null, 2);
+    }
+
+    return `Created ${task.id} [${task.status}] in ${task.filePath}`;
+  }
+
+  if (parsed.subcommand === "set-status") {
+    const taskId = parsed.positionals[2];
+    const status = parsed.positionals[3];
+
+    if (!taskId || !status) {
+      throw new Error("`task set-status` requires <TASK-ID> <status>.");
+    }
+
+    if (!isTaskStatus(status)) {
+      throw new Error(`Invalid task status: ${status}. Expected one of ${TASK_STATUSES.join(", ")}.`);
+    }
+
+    const task = await setTaskStatus(rootDir, taskId, status);
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(task, null, 2);
+    }
+
+    return `Updated ${task.id} to [${task.status}] in ${task.filePath}`;
+  }
+
+  if (parsed.subcommand === "archive") {
+    const taskId = parsed.positionals[2];
+    if (!taskId) {
+      throw new Error("`task archive` requires <TASK-ID>.");
+    }
+
+    const task = await archiveTask(rootDir, taskId, {
+      reason: flagValue(parsed, "reason"),
+    });
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(task, null, 2);
+    }
+
+    return `Archived ${task.id} in ${task.filePath}`;
+  }
+
+  if (parsed.subcommand === "archive-done") {
+    const olderThan = flagValue(parsed, "older-than");
+    if (!olderThan) {
+      throw new Error("`task archive-done` requires --older-than <duration>.");
+    }
+
+    const tasks = await archiveDoneTasks(rootDir, olderThan, {
+      reason: flagValue(parsed, "reason"),
+    });
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(tasks, null, 2);
+    }
+
+    return tasks.length === 0 ? "No done tasks were archived." : `Archived ${tasks.length} done task(s).`;
+  }
+
+  if (parsed.subcommand === "archive-cancelled") {
+    const olderThan = flagValue(parsed, "older-than");
+    if (!olderThan) {
+      throw new Error("`task archive-cancelled` requires --older-than <duration>.");
+    }
+
+    const tasks = await archiveCancelledTasks(rootDir, olderThan, {
+      reason: flagValue(parsed, "reason"),
+    });
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(tasks, null, 2);
+    }
+
+    return tasks.length === 0 ? "No cancelled tasks were archived." : `Archived ${tasks.length} cancelled task(s).`;
+  }
+
+  if (parsed.subcommand === "restore") {
+    const taskId = parsed.positionals[2];
+    if (!taskId) {
+      throw new Error("`task restore` requires <TASK-ID>.");
+    }
+
+    const task = await restoreTask(rootDir, taskId);
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(task, null, 2);
+    }
+
+    return `Restored ${task.id} in ${task.filePath}`;
+  }
+
+  if (parsed.subcommand !== "list") {
+    throw new Error(
+      "Supported task commands are `task list`, `task create`, `task set-status`, `task archive`, `task archive-done`, `task archive-cancelled`, and `task restore`.",
+    );
+  }
+
+  const context = await loadProjectContext(rootDir);
+  const statusFilter = flagValue(parsed, "status");
+  const specFilter = flagValue(parsed, "spec");
+  const taskIndex = buildTaskIndex(context.tasks);
+  const tasks = context.tasks.filter((task) => {
+    if (statusFilter && task.status !== statusFilter) {
+      return false;
+    }
+
+    if (specFilter && !task.specIds.includes(specFilter)) {
+      return false;
+    }
+
+    return true;
+  });
+
+  if (parsed.flags.has("json")) {
+    return JSON.stringify(tasks, null, 2);
+  }
+
+  if (tasks.length === 0) {
+    return "No tasks found.";
+  }
+
+  return tasks
+    .sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id))
+    .map((task) => {
+      const summary = summarizeTaskNode(task, taskIndex);
+      const deps = task.dependsOn.join(", ") || "none";
+      const unmet = summary.unmetDependencies.join(", ") || "none";
+      const statusLabel = task.archivedAt ? `${task.status}, archived` : task.status;
+      const archivedLine = task.archivedAt
+        ? `\n  archived_at: ${task.archivedAt}${task.archiveReason ? ` (${task.archiveReason})` : ""}`
+        : "";
+      return `${task.id} [${statusLabel}] p${task.priority} ${task.title}\n  specs: ${task.specIds.join(", ") || "none"}\n  depends_on: ${deps}\n  unmet_dependencies: ${unmet}${archivedLine}\n  ${task.summary}`;
+    })
+    .join("\n\n");
+}

package/src/commands/ui.ts

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+import { env, execPath } from "node:process";
+import type { ParsedArgs } from "../cli.ts";
+import { resolveUiLaunchConfig } from "../services/ui.ts";
+
+export async function runUiCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  const launch = await resolveUiLaunchConfig(rootDir, parsed);
+
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(
+      execPath,
+      ["run", "dev", "--", "--host", launch.host, "--port", String(launch.port)],
+      {
+        cwd: launch.webDir,
+        stdio: "inherit",
+        env: {
+          ...env,
+          SPM_PROJECT_ROOT: rootDir,
+        },
+      },
+    );
+
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+      if (signal === "SIGINT" || signal === "SIGTERM" || code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error(`UI server exited with code ${code ?? "unknown"}.`));
+    });
+  });
+
+  return "";
+}