@wkronmiller/lisa 0.1.0

package/src/spec/commands/config.ts

@@ -0,0 +1,146 @@
+import { join } from "path";
+
+import { loadLocalConfig, localConfigPath, resetLocalConfig, saveLocalConfig } from "../local-config";
+import { resolveWorkspaceLayout } from "../workspace";
+
+interface ConfigCommandOptions {
+  harness?: string;
+  reset: boolean;
+  help: boolean;
+}
+
+export interface ConfigCommandIO {
+  print(message: string): void;
+  error(message: string): void;
+}
+
+function createConsoleIO(): ConfigCommandIO {
+  return {
+    print(message: string): void {
+      console.log(message);
+    },
+    error(message: string): void {
+      console.error(message);
+    },
+  };
+}
+
+function printConfigHelp(io: ConfigCommandIO): void {
+  io.print(`Lisa spec config
+
+Usage:
+  lisa spec config [options]
+
+Options:
+  --harness <id>     Set the local harness override
+  --reset            Remove all local config overrides
+  --help, -h         Show this help
+
+With no options, prints the current local configuration.
+
+Local config is saved to .specs/config.local.yaml (gitignored) and
+overrides the repo config for all stages. CLI flags and the LISA_HARNESS
+environment variable take precedence over local config. External
+workspaces store the local override in the Lisa-managed runtime root
+instead of the repository.
+`);
+}
+
+function parseConfigArgs(args: string[]): ConfigCommandOptions {
+  const options: ConfigCommandOptions = {
+    reset: false,
+    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 === "--reset") {
+      options.reset = true;
+      continue;
+    }
+
+    if (arg === "--harness") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("--harness requires a value.");
+      }
+      index += 1;
+      options.harness = value;
+      continue;
+    }
+
+    throw new Error(`Unknown lisa spec config option: ${arg}`);
+  }
+
+  return options;
+}
+
+export async function runSpecConfigCommand(
+  args: string[],
+  cwd = process.cwd(),
+  io: ConfigCommandIO = createConsoleIO(),
+): Promise<number> {
+  try {
+    const options = parseConfigArgs(args);
+    if (options.help) {
+      printConfigHelp(io);
+      return 0;
+    }
+
+    const layout = resolveWorkspaceLayout(cwd);
+    const configRoot = layout.localConfigRoot;
+    const configFile = localConfigPath(configRoot);
+
+    if (options.reset) {
+      const removed = resetLocalConfig(configRoot);
+      io.print(removed ? `Removed ${configFile}` : "No local config to remove.");
+      return 0;
+    }
+
+    if (options.harness !== undefined) {
+      saveLocalConfig(configRoot, { harness: options.harness });
+
+      io.print("Lisa spec config");
+      io.print("");
+      io.print(`Wrote ${configFile}`);
+      io.print(`  harness: ${options.harness}`);
+      return 0;
+    }
+
+    // No flags — show current local config
+    const current = loadLocalConfig(configRoot);
+
+    io.print("Lisa spec config");
+    io.print("");
+    if (!current.harness) {
+      io.print("No local config overrides set.");
+      io.print("");
+      io.print("Set overrides with:");
+      io.print("  lisa spec config --harness claude-code");
+    } else {
+      io.print(`Local config: ${configFile}`);
+      io.print(`  harness: ${current.harness}`);
+    }
+
+    const envHarness = process.env.LISA_HARNESS;
+    if (envHarness) {
+      io.print("");
+      io.print("Environment override (takes precedence over local config):");
+      io.print(`  LISA_HARNESS=${envHarness}`);
+    }
+
+    return 0;
+  } catch (error) {
+    io.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}

package/src/spec/commands/diff.ts

@@ -0,0 +1 @@
+export { runSpecDiffCommand } from "../workflows/diff";

package/src/spec/commands/generate.ts

@@ -0,0 +1 @@
+export { runSpecGenerateCommand } from "../workflows/generate";

package/src/spec/commands/guide.ts

@@ -0,0 +1 @@
+export { runSpecGuideCommand } from "../workflows/guide";

package/src/spec/commands/harness-list.ts

@@ -0,0 +1,36 @@
+import { inspectHarnesses } from "../../harness/registry";
+import type { HarnessCapabilities } from "../../harness/types";
+
+function formatCapabilities(capabilities: HarnessCapabilities): string {
+  const labels: string[] = [];
+
+  if (capabilities.canEditFiles) labels.push("edit-files");
+  if (capabilities.canResumeSessions) labels.push("resume-sessions");
+  if (capabilities.supportsStructuredOutput) labels.push("structured-output");
+  if (capabilities.supportsStreaming) labels.push("streaming");
+  if (capabilities.supportsModelSelection) labels.push("model-selection");
+  if (capabilities.supportsReadOnlyMode) labels.push("read-only");
+
+  return labels.length > 0 ? labels.join(", ") : "none";
+}
+
+export async function runSpecHarnessListCommand(cwd = process.cwd()): Promise<number> {
+  const harnesses = await inspectHarnesses(cwd);
+
+  console.log("Lisa Spec Harnesses");
+  console.log("");
+
+  for (const inspection of harnesses) {
+    const { adapter, availability, capabilities } = inspection;
+    console.log(`${adapter.id} - ${adapter.displayName}`);
+    console.log(`  status: ${availability.available ? "available" : "unavailable"}`);
+    console.log(`  reason: ${availability.reason}`);
+    console.log(`  command: ${availability.command ?? "n/a"}`);
+    console.log(`  stages: ${adapter.supportedStages.join(", ")}`);
+    console.log(`  capabilities: ${formatCapabilities(capabilities)}`);
+    console.log(`  description: ${adapter.description}`);
+    console.log("");
+  }
+
+  return 0;
+}

package/src/spec/commands/implement.ts

@@ -0,0 +1 @@
+export { runSpecImplementCommand } from "../workflows/implement";

package/src/spec/commands/import.ts

@@ -0,0 +1 @@
+export { runSpecImportCommand } from "../workflows/import";

package/src/spec/commands/init.ts

@@ -0,0 +1 @@
+export { runSpecInitCommand } from "../workflows/init";

package/src/spec/commands/status.ts

@@ -0,0 +1,87 @@
+import { runSpecStatusWorkflow } from "../workflows/status";
+
+function printStatusHelp(): void {
+  console.log(`Lisa spec status
+
+Usage:
+  lisa spec status
+`);
+}
+
+function parseStatusArgs(args: string[]): { help: boolean } {
+  const options = { help: false };
+
+  for (const arg of args) {
+    if (!arg) {
+      continue;
+    }
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    throw new Error(`Unknown lisa spec status option: ${arg}`);
+  }
+
+  return options;
+}
+
+export async function runSpecStatusCommand(args: string[] = [], cwd = process.cwd()): Promise<number> {
+  try {
+    const options = parseStatusArgs(args);
+    if (options.help) {
+      printStatusHelp();
+      return 0;
+    }
+
+    const { workspace, harnesses, availableHarnesses } = await runSpecStatusWorkflow(cwd);
+
+    console.log("Lisa Spec Status");
+    console.log("");
+    console.log(`Workspace: ${workspace.workspacePath}`);
+    console.log(`Storage mode: ${workspace.storageMode}`);
+    console.log(`Spec root: ${workspace.exists ? `present (${workspace.rootPath})` : `missing (${workspace.rootPath})`}`);
+    console.log(`Spec config: ${workspace.hasConfig ? `present (${workspace.configPath})` : `missing (${workspace.configPath})`}`);
+    console.log(`Base specs: ${workspace.backendSpecCount + workspace.frontendSpecCount} (${workspace.backendSpecCount} backend, ${workspace.frontendSpecCount} frontend)`);
+    console.log(`Benchmark sidecars: ${workspace.benchmarkSpecCount}`);
+    console.log(`Environment configs: ${workspace.environmentCount}`);
+    console.log("Resolved roots:");
+    console.log(`- repo spec root: ${workspace.repoSpecRoot}`);
+    if (workspace.worktreeSpecRoot) {
+      console.log(`- worktree spec root: ${workspace.worktreeSpecRoot}`);
+    }
+    if (workspace.globalPackRoots.length > 0) {
+      console.log(`- global pack roots: ${workspace.globalPackRoots.join(", ")}`);
+    } else {
+      console.log("- global pack roots: none");
+    }
+    console.log(`- runtime root: ${workspace.runtimeRoot}`);
+    console.log(`- snapshot root: ${workspace.snapshotRoot}`);
+    console.log("");
+
+    if (!workspace.exists) {
+      console.log(workspace.storageMode === "external"
+        ? "Run `lisa spec init --external` to scaffold the external Lisa workspace roots for this repository."
+        : "Run `lisa spec init` to scaffold `.specs/config.yaml` and starter directories.");
+      console.log("");
+    }
+
+    console.log(`Harness adapters: ${availableHarnesses.length}/${harnesses.length} available`);
+
+    for (const inspection of harnesses) {
+      const status = inspection.availability.available ? "available" : "unavailable";
+      console.log(`- ${inspection.adapter.id}: ${status} - ${inspection.availability.reason}`);
+    }
+
+    if (harnesses.length > 0) {
+      console.log("");
+      console.log("Run `lisa spec harness list` for capability details.");
+    }
+
+    return 0;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}

package/src/spec/config.ts

@@ -0,0 +1,63 @@
+import type { Stage } from "../harness/types";
+import type { ParsedSpecConfig, ResolvedStageProfile, StageProfileOverrides } from "./types";
+
+const LEGACY_HARNESS_ALIASES: Record<string, string> = {
+  ralph: "opencode",
+};
+
+export function resolveConfiguredHarnessId(config: ParsedSpecConfig, harness: string): string {
+  if (config.harnesses[harness]) {
+    return harness;
+  }
+
+  const alias = LEGACY_HARNESS_ALIASES[harness];
+  return alias && config.harnesses[alias] ? alias : harness;
+}
+
+function hasValidHarnessArgs(args: unknown): boolean {
+  return args === undefined || (Array.isArray(args) && args.every((entry) => typeof entry === "string"));
+}
+
+export interface LocalOverrides {
+  harness?: string;
+}
+
+export function resolveStageProfile(
+  config: ParsedSpecConfig,
+  stage: Stage,
+  overrides: StageProfileOverrides = {},
+  localOverrides: LocalOverrides = {},
+): ResolvedStageProfile | undefined {
+  const profileName = overrides.profile ?? config.defaultStageProfiles[stage];
+  if (!profileName) {
+    return undefined;
+  }
+
+  const profile = config.profiles[profileName];
+  if (!profile?.harness) {
+    return undefined;
+  }
+
+  const selectedHarness = overrides.harness ?? localOverrides.harness ?? profile.harness;
+  if (!selectedHarness) {
+    return undefined;
+  }
+
+  const harness = resolveConfiguredHarnessId(config, selectedHarness);
+
+  const harnessConfig = config.harnesses[harness];
+  const hasValidArgs = harnessConfig && hasValidHarnessArgs(harnessConfig.raw.args);
+  if (!harnessConfig?.command || !hasValidArgs) {
+    return undefined;
+  }
+
+  return {
+    stage,
+    profileName,
+    harness,
+    model: overrides.model ?? profile.model,
+    allowEdits: profile.allowEdits ?? false,
+    command: harnessConfig.command,
+    args: harnessConfig.args,
+  };
+}