@wkronmiller/lisa 0.1.0

package/src/spec/workflows/diff.ts

@@ -0,0 +1,209 @@
+import { DEFAULT_SPEC_DIFF_BASE_REF, collectSpecDiff, getSpecDiffRelativePath } from "../diff";
+import { loadSpecWorkspace, loadSpecWorkspaceAtRef } from "../loader";
+import { planSpecImplementation } from "../planner";
+import type { ValidationIssue } from "../types";
+import { resolveWorkspaceLayout, toLogicalPath } from "../workspace";
+
+interface DiffCommandOptions {
+  base?: string;
+  head?: string;
+  help: boolean;
+}
+
+export interface DiffCommandIO {
+  print(message: string): void;
+  error(message: string): void;
+}
+
+function createConsoleIO(): DiffCommandIO {
+  return {
+    print(message: string): void {
+      console.log(message);
+    },
+    error(message: string): void {
+      console.error(message);
+    },
+  };
+}
+
+function printDiffHelp(io: DiffCommandIO): void {
+  io.print(`Lisa spec diff
+
+Usage:
+  lisa spec diff [options]
+
+Options:
+  --base <rev>   Diff base revision (default: HEAD)
+  --head <rev>   Diff head revision (default: worktree)
+  --help, -h     Show this help
+`);
+}
+
+function parseDiffArgs(args: string[]): DiffCommandOptions {
+  const options: DiffCommandOptions = { help: false };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) {
+      continue;
+    }
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === "--base" || arg === "--head") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error(`${arg} requires a value.`);
+      }
+      index += 1;
+      if (arg === "--base") {
+        options.base = value;
+      } else {
+        options.head = value.toLowerCase() === "worktree" ? undefined : value;
+      }
+      continue;
+    }
+
+    throw new Error(`Unknown lisa spec diff option: ${arg}`);
+  }
+
+  return options;
+}
+
+function formatIssuesForConsole(issues: ValidationIssue[], workspaceRoot: string): string[] {
+  const layout = resolveWorkspaceLayout(workspaceRoot);
+  return issues.map((issue) => `${issue.severity}: ${toLogicalPath(layout, issue.path)} - ${issue.message}`);
+}
+
+function getBlockingValidationIssues(
+  workspace: ReturnType<typeof loadSpecWorkspace>,
+  diff: ReturnType<typeof collectSpecDiff>,
+): ValidationIssue[] {
+  const changedSpecIds = new Set(diff.deltas.map((delta) => delta.specId));
+  const changedBaseSpecIds = new Set(
+    diff.deltas.flatMap((delta) => {
+      if (delta.kind === "base") {
+        return [delta.specId];
+      }
+
+      return delta.extendsSpecId ? [delta.extendsSpecId] : [];
+    }),
+  );
+  const referencedEnvironments = new Set(
+    diff.deltas.flatMap((delta) => {
+      const document = delta.nextDocument ?? delta.previousDocument;
+      return typeof document?.frontmatter.environment === "string" ? [document.frontmatter.environment] : [];
+    }),
+  );
+  const relevantPaths = new Set<string>(diff.deltas.map((delta) => delta.path));
+
+  for (const document of workspace.documents) {
+    if (document.id && (changedSpecIds.has(document.id) || changedBaseSpecIds.has(document.id))) {
+      relevantPaths.add(document.path);
+      continue;
+    }
+
+    if (
+      document.kind !== "base" &&
+      typeof document.frontmatter.extends === "string" &&
+      changedBaseSpecIds.has(document.frontmatter.extends)
+    ) {
+      relevantPaths.add(document.path);
+    }
+  }
+
+  for (const environment of workspace.environments) {
+    if (environment.name && referencedEnvironments.has(environment.name)) {
+      relevantPaths.add(environment.path);
+    }
+  }
+
+  return workspace.issues.filter((issue) => issue.severity === "error" && relevantPaths.has(issue.path));
+}
+
+export async function runSpecDiffCommand(
+  args: string[],
+  cwd = process.cwd(),
+  io: DiffCommandIO = createConsoleIO(),
+): Promise<number> {
+  try {
+    const options = parseDiffArgs(args);
+    if (options.help) {
+      printDiffHelp(io);
+      return 0;
+    }
+
+    const layout = resolveWorkspaceLayout(cwd);
+    if (layout.storageMode === "external" && (args.includes("--base") || args.includes("--head"))) {
+      io.error("External Lisa workspaces do not support `--base` or `--head` for spec history yet.");
+      return 1;
+    }
+
+    const currentWorkspace = loadSpecWorkspace(cwd);
+    const diff = collectSpecDiff(cwd, {
+      baseRef: options.base,
+      headRef: options.head,
+    });
+    const workspace = options.head ? loadSpecWorkspaceAtRef(options.head, cwd) : currentWorkspace;
+    const plan = planSpecImplementation(workspace, diff);
+    const blockingValidationIssues = getBlockingValidationIssues(workspace, diff);
+
+    io.print("Lisa Spec Diff");
+    io.print(`Range: ${diff.baseRef} -> ${diff.headRef}`);
+    io.print(`Changed specs: ${diff.deltas.length}`);
+    io.print("");
+
+    if (workspace.issues.length > 0) {
+      io.print("Workspace Validation");
+      for (const issue of formatIssuesForConsole(workspace.issues, workspace.workspacePath)) {
+        io.print(`- ${issue}`);
+      }
+      io.print("");
+    }
+
+    if (diff.deltas.length === 0) {
+      io.print("No spec changes detected.");
+      return 0;
+    }
+
+    if (blockingValidationIssues.length > 0) {
+      io.error("Spec diff cannot produce a reliable plan until the changed specs validate cleanly.");
+      return 1;
+    }
+
+    io.print("Deltas");
+    for (const delta of diff.deltas) {
+      io.print(`- ${delta.specId} (${delta.kind}, ${delta.fileChange}) at ${getSpecDiffRelativePath(diff, delta.path)}`);
+      if (delta.extendsSpecId) {
+        io.print(`  extends: ${delta.extendsSpecId}`);
+      }
+      for (const change of delta.sectionChanges) {
+        io.print(`  - ${change.section} [${change.changeType}]`);
+      }
+    }
+    io.print("");
+
+    io.print("Planned Tasks");
+    for (const task of plan.tasks) {
+      io.print(`- [${task.type}] ${task.description}`);
+    }
+    io.print("");
+
+    io.print("Mapped Test Commands");
+    if (plan.testCommands.length === 0) {
+      io.print("- none");
+    } else {
+      for (const command of plan.testCommands) {
+        io.print(`- ${command}`);
+      }
+    }
+
+    return 0;
+  } catch (error) {
+    io.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}