@mhingston5/lasso 0.1.0

package/src/pi/command-input.ts

@@ -0,0 +1,209 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, win32 } from "node:path";
+import type { HarnessSpec } from "../spec/types.js";
+import { parseWorkflowRequest, type ReferenceWorkflowRequest } from "../reference/catalog.js";
+
+export type ParsedCommandTarget =
+  | { kind: "reference"; request: ReferenceWorkflowRequest; runtimeInput: {} }
+  | { kind: "custom"; spec: HarnessSpec; runtimeInput: unknown };
+
+type CommandName = "compile" | "run";
+
+type GenericHarnessCommandRequest =
+  | {
+      spec: unknown;
+      input?: unknown;
+    }
+  | {
+      specPath: unknown;
+      input?: unknown;
+    };
+
+export async function parseCommandTarget(args: string, commandName: CommandName): Promise<ParsedCommandTarget> {
+  const trimmed = args.trim();
+  if (!trimmed) {
+    throw new Error(buildUsage(commandName));
+  }
+
+  const prefixedPath = parsePrefixedPath(trimmed);
+  if (prefixedPath !== undefined) {
+    if (!isAbsoluteSpecPath(prefixedPath)) {
+      throw new Error("Spec path must be an absolute path");
+    }
+
+    return loadCustomSpecTarget(prefixedPath, {});
+  }
+
+  if (isAbsoluteSpecPath(trimmed)) {
+    return loadCustomSpecTarget(trimmed, {});
+  }
+
+  if (looksLikeRelativeSpecPath(trimmed)) {
+    throw new Error("Spec path must be an absolute path");
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error(buildInvalidInputMessage(commandName));
+  }
+
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error(buildInvalidInputMessage(commandName));
+  }
+
+  const record = parsed as Record<string, unknown>;
+
+  if ("workflow" in record) {
+    return {
+      kind: "reference",
+      request: parseWorkflowRequest(trimmed),
+      runtimeInput: {},
+    };
+  }
+
+  if ("spec" in record || "specPath" in record) {
+    return parseGenericHarnessCommandRequest(record as GenericHarnessCommandRequest);
+  }
+
+  if (looksLikeHarnessSpecRecord(record)) {
+    return {
+      kind: "custom",
+      spec: record as HarnessSpec,
+      runtimeInput: {},
+    };
+  }
+
+  if (looksLikeLegacyReferenceRequest(record)) {
+    return {
+      kind: "reference",
+      request: parseWorkflowRequest(trimmed),
+      runtimeInput: {},
+    };
+  }
+
+  throw new Error(buildInvalidInputMessage(commandName));
+}
+
+function buildUsage(commandName: CommandName): string {
+  return `Usage: /lasso:${commandName} <workflow request JSON | HarnessSpec JSON | {spec|specPath,input?} | path:/abs/spec.json>`;
+}
+
+function buildInvalidInputMessage(commandName: CommandName): string {
+  return `Invalid ${commandName} input. Expected workflow request JSON, HarnessSpec JSON, {spec|specPath,input?}, or an absolute spec path.`;
+}
+
+function parsePrefixedPath(value: string): string | undefined {
+  if (!value.toLowerCase().startsWith("path:")) {
+    return undefined;
+  }
+
+  return value.slice("path:".length).trim();
+}
+
+function isAbsoluteSpecPath(value: string): boolean {
+  return isAbsolute(value) || win32.isAbsolute(value);
+}
+
+function looksLikeRelativeSpecPath(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return false;
+  }
+
+  if (trimmed.toLowerCase().startsWith("path:")) {
+    return true;
+  }
+
+  return trimmed.endsWith(".json") || trimmed.includes("/") || trimmed.includes("\\");
+}
+
+function looksLikeHarnessSpecRecord(record: Record<string, unknown>): boolean {
+  return "name" in record || "graph" in record;
+}
+
+function looksLikeLegacyReferenceRequest(record: Record<string, unknown>): boolean {
+  return (
+    "repoPath" in record
+    || "sourceBranch" in record
+    || "targetBranch" in record
+    || "reviewInstructions" in record
+    || "verificationCommands" in record
+  );
+}
+
+async function parseGenericHarnessCommandRequest(
+  record: GenericHarnessCommandRequest,
+): Promise<ParsedCommandTarget> {
+  const hasSpec = Object.prototype.hasOwnProperty.call(record, "spec");
+  const hasSpecPath = Object.prototype.hasOwnProperty.call(record, "specPath");
+
+  if (hasSpec === hasSpecPath) {
+    throw new Error("Generic harness request must include exactly one of `spec` or `specPath`");
+  }
+
+  const runtimeInput = Object.prototype.hasOwnProperty.call(record, "input") ? record.input : {};
+
+  if (hasSpecPath) {
+    if (typeof record.specPath !== "string") {
+      throw new Error("Generic harness request `specPath` must be a string");
+    }
+
+    if (!isAbsoluteSpecPath(record.specPath)) {
+      throw new Error("specPath must be an absolute path");
+    }
+
+    return loadCustomSpecTarget(record.specPath, runtimeInput);
+  }
+
+  if (typeof record.spec === "string") {
+    throw new Error("Generic harness request uses `specPath` for file paths, not `spec`");
+  }
+
+  if (!record.spec || typeof record.spec !== "object") {
+    throw new Error("Generic harness request `spec` must be a JSON object");
+  }
+
+  return {
+    kind: "custom",
+    spec: record.spec as HarnessSpec,
+    runtimeInput,
+  };
+}
+
+async function loadCustomSpecTarget(specPath: string, runtimeInput: unknown): Promise<ParsedCommandTarget> {
+  return {
+    kind: "custom",
+    spec: await loadHarnessSpecFromFile(specPath),
+    runtimeInput,
+  };
+}
+
+async function loadHarnessSpecFromFile(specPath: string): Promise<HarnessSpec> {
+  let raw: string;
+  try {
+    raw = await readFile(specPath, "utf8");
+  } catch (error) {
+    const errno = error as NodeJS.ErrnoException;
+    if (errno?.code === "ENOENT") {
+      throw new Error(`Spec file not found: ${specPath}`);
+    }
+
+    const message = errno?.message ?? String(error);
+    throw new Error(`Failed to read spec file: ${specPath} (${message})`);
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Spec file must contain valid JSON: ${specPath}`);
+  }
+
+  if (!parsed || typeof parsed !== "object" || !looksLikeHarnessSpecRecord(parsed as Record<string, unknown>)) {
+    throw new Error(`Spec file must contain a HarnessSpec JSON object: ${specPath}`);
+  }
+
+  return parsed as HarnessSpec;
+}

package/src/pi/commands.ts

@@ -0,0 +1,351 @@
+import { randomUUID } from "node:crypto";
+import type { RegisteredCommand, SourceInfo } from "@mariozechner/pi-coding-agent";
+import { type WorkflowRegistry } from "pi-duroxide";
+import { compileHarnessSpec, type CompiledHarnessWorkflow } from "../compiler/compile.js";
+import { planWorkflowRequest } from "../planner/synthesize.js";
+import type { PlannerResult } from "../planner/types.js";
+import { parseReplanRequest, replanWorkflowRequest } from "../replanner/synthesize.js";
+import type { ReplanResult } from "../replanner/types.js";
+import type { HarnessSpec } from "../spec/types.js";
+import { MAX_ADAPTIVE_VERSIONS } from "../replanner/runtime.js";
+import { parseCommandTarget, type ParsedCommandTarget } from "./command-input.js";
+import { buildReferenceHarnessSpec, type ReferenceWorkflowRequest } from "../reference/catalog.js";
+import { prepareInitialAdaptiveInput } from "../replanner/runtime.js";
+
+const compiledHarnesses = new Map<string, CompiledHarnessWorkflow>();
+let lastCompiledHarnessName: string | undefined;
+
+export function createLassoCommands(registry: WorkflowRegistry): RegisteredCommand[] {
+  const compileCommand: RegisteredCommand = {
+    name: "lasso:compile",
+    sourceInfo: extSourceInfo(),
+    description: "Compile either a bundled Lasso workflow request or a custom HarnessSpec payload.",
+    handler: async (args, ctx) => {
+      try {
+        const target = await parseCommandTarget(args, "compile");
+        const compiled = compileCommandTarget(target);
+        ctx.ui.notify(
+          [
+            `Compiled \`${compiled.name}\``,
+            `- spec nodes: ${compiled.spec.graph.nodes.length}`,
+            `- cir nodes: ${compiled.cir.nodes.length}`,
+            `- registered workflows: ${compiled.workflows.length}`,
+          ].join("\n"),
+          "info",
+        );
+      } catch (error) {
+        ctx.ui.notify(formatCommandError(error), "error");
+      }
+    },
+  };
+
+  const runCommand: RegisteredCommand = {
+    name: "lasso:run",
+    sourceInfo: extSourceInfo(),
+    description: "Compile, register, and start either a bundled Lasso workflow request or a custom HarnessSpec payload.",
+    handler: async (args, ctx) => {
+      try {
+        const target = await parseCommandTarget(args, "run");
+        const compiled = compileCommandTarget(target);
+        compiled.register();
+
+        const runtime = registry.getRuntime();
+        if (!runtime) {
+          ctx.ui.notify("Workflow runtime not available", "error");
+          return;
+        }
+
+        const client = runtime.getClient();
+        if (!client) {
+          ctx.ui.notify("Workflow runtime not started", "error");
+          return;
+        }
+
+        const runtimeInput = target.kind === "reference"
+          ? prepareInitialAdaptiveInput(target.request, compiled.spec, target.runtimeInput)
+          : target.runtimeInput;
+
+        const instanceId = randomUUID();
+        await client.startOrchestration(instanceId, compiled.name, runtimeInput);
+        ctx.ui.notify(`Started \`${compiled.name}\` (${instanceId})`, "info");
+      } catch (error) {
+        ctx.ui.notify(formatCommandError(error), "error");
+      }
+    },
+  };
+
+  const inspectCommand: RegisteredCommand = {
+    name: "lasso:inspect",
+    sourceInfo: extSourceInfo(),
+    description: "Show the compiled spec, CIR, and workflow runtime state for the latest or named Lasso workflow.",
+    handler: async (args, ctx) => {
+      try {
+        const name = args.trim() || lastCompiledHarnessName;
+        if (!name) {
+          ctx.ui.notify("No compiled Lasso workflow available. Run /lasso:compile or /lasso:run first.", "error");
+          return;
+        }
+
+        const compiled = compiledHarnesses.get(name);
+        if (!compiled) {
+          ctx.ui.notify(`No compiled Lasso workflow named \`${name}\` is available.`, "error");
+          return;
+        }
+
+        const runtime = registry.getRuntime();
+        const client = runtime?.getClient();
+        const instances = client ? await client.listAllInstances() : [];
+        const matchingInstances = instances.filter(instance => {
+          const record = instance as { name?: string };
+          return !record.name || record.name === compiled.name;
+        });
+
+        const lines = [
+          `### Lasso Workflow \`${compiled.name}\``,
+          "",
+          "#### Spec",
+          "```json",
+          JSON.stringify(compiled.spec, null, 2),
+          "```",
+          "",
+          "#### CIR",
+          "```json",
+          JSON.stringify(compiled.cir, null, 2),
+          "```",
+          "",
+          "#### Runtime State",
+          "```json",
+          JSON.stringify(matchingInstances, null, 2),
+          "```",
+        ];
+
+        if (compiled.adaptive) {
+          const { currentVersion, lineage } = compiled.adaptive;
+          lines.push(
+            "",
+            "#### Adaptive Lineage",
+            "",
+            `Version: ${currentVersion.version}`,
+            `Parent: ${currentVersion.parentVersion ?? "none"}`,
+            `Reason: ${currentVersion.reason}`,
+          );
+
+          if (lineage.length > 0) {
+            lines.push(
+              "",
+              "| # | Outcome | Duration | Failures | Needs Input |",
+              "|---|---------|----------|----------|-------------|",
+            );
+
+            for (const entry of lineage) {
+              const duration = entry.metrics.durationMs >= 1000
+                ? `${(entry.metrics.durationMs / 1000).toFixed(1)}s`
+                : `${entry.metrics.durationMs}ms`;
+              const needsInput = entry.failures.some(f => f.rootCause === "human_block") ? "yes" : "no";
+              lines.push(
+                `| ${entry.version} | ${entry.terminalNodeId} | ${duration} | ${entry.failures.length} | ${needsInput} |`,
+              );
+            }
+          }
+
+          const status = currentVersion.version >= MAX_ADAPTIVE_VERSIONS ? "stopped" : `evolving (version ${currentVersion.version} of ${MAX_ADAPTIVE_VERSIONS})`;
+          lines.push("", `Status: ${status}`);
+        }
+
+        ctx.ui.notify(lines.join("\n"), "info");
+      } catch (error) {
+        ctx.ui.notify(formatCommandError(error), "error");
+      }
+    },
+  };
+
+  const planCommand: RegisteredCommand = {
+    name: "lasso:plan",
+    sourceInfo: extSourceInfo(),
+    description: "Draft a reference workflow request envelope from a freeform brief without compiling or running it.",
+    handler: async (args, ctx) => {
+      try {
+        if (!args.trim()) {
+          ctx.ui.notify("Usage: /lasso:plan <freeform brief>", "error");
+          return;
+        }
+
+        const result = planWorkflowRequest(args);
+        ctx.ui.notify(renderPlannerResult(result), "info");
+      } catch (error) {
+        ctx.ui.notify(formatCommandError(error), "error");
+      }
+    },
+  };
+
+  const replanCommand: RegisteredCommand = {
+    name: "lasso:replan",
+    sourceInfo: extSourceInfo(),
+    description: "Draft a revised workflow request from a prior request plus explicit outcome signals without compiling or running it.",
+    handler: async (args, ctx) => {
+      try {
+        if (!args.trim()) {
+          ctx.ui.notify("Usage: /lasso:replan <replan request JSON>", "error");
+          return;
+        }
+
+        const request = parseReplanRequest(args);
+        const result = replanWorkflowRequest(request);
+        ctx.ui.notify(renderReplannerResult(result), "info");
+      } catch (error) {
+        ctx.ui.notify(formatCommandError(error), "error");
+      }
+    },
+  };
+
+  return [compileCommand, runCommand, inspectCommand, planCommand, replanCommand];
+}
+
+export function clearCompiledHarnesses(): void {
+  compiledHarnesses.clear();
+  lastCompiledHarnessName = undefined;
+}
+
+export function compileCommandTarget(target: ParsedCommandTarget): CompiledHarnessWorkflow {
+  if (target.kind === "reference") {
+    return compileReferenceHarness(target.request);
+  }
+
+  return compileCustomHarness(target.spec);
+}
+
+export function compileReferenceHarness(request: ReferenceWorkflowRequest): CompiledHarnessWorkflow {
+  const spec = buildReferenceHarnessSpec(request);
+  return compileCustomHarness(spec);
+}
+
+function compileCustomHarness(spec: HarnessSpec): CompiledHarnessWorkflow {
+  const compiled = compileHarnessSpec(spec);
+  compiledHarnesses.set(compiled.name, compiled);
+  lastCompiledHarnessName = compiled.name;
+  return compiled;
+}
+
+function extSourceInfo(): SourceInfo {
+  return { path: "", source: "extension", scope: "temporary", origin: "top-level", baseDir: undefined };
+}
+
+function formatCommandError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}
+
+function renderPlannerResult(result: PlannerResult): string {
+  if (result.status === "draft_request") {
+    const lines = [
+      `### Planner Draft \`${result.workflow}\``,
+      "",
+      "#### Rationale",
+      ...result.rationale.map(item => `- ${item}`),
+    ];
+
+    if (result.warnings.length > 0) {
+      lines.push("", "#### Warnings", ...result.warnings.map(item => `- ${item}`));
+    }
+
+    lines.push(
+      "",
+      "#### Request JSON",
+      "```json",
+      JSON.stringify(result.request, null, 2),
+      "```",
+      "",
+      "Next: pass this JSON into `/lasso:compile` or `/lasso:run` when you are ready.",
+    );
+
+    return lines.join("\n");
+  }
+
+  const lines = ["### Planner Needs Clarification"];
+
+  if (result.candidateWorkflow) {
+    lines.push("", `Likely workflow: \`${result.candidateWorkflow}\``);
+  }
+
+  lines.push("", "#### Reasons", ...result.reasons.map(item => `- ${item}`));
+
+  if (result.missingFields.length > 0) {
+    lines.push("", "#### Missing Fields", ...result.missingFields.map(item => `- ${item}`));
+  }
+
+  lines.push("", "#### Guidance", ...result.guidance.map(item => `- ${item}`));
+
+  return lines.join("\n");
+}
+
+function renderReplannerResult(result: ReplanResult): string {
+  if (result.status === "draft_request") {
+    const lines = [
+      `### Replan Draft \`${result.workflow}\``,
+      "",
+      `- Trigger: \`${result.trigger}\``,
+      `- Risk level: \`${result.riskLevel}\``,
+      "",
+      "#### Rationale",
+      ...result.rationale.map(item => `- ${item}`),
+    ];
+
+    if (result.warnings.length > 0) {
+      lines.push("", "#### Warnings", ...result.warnings.map(item => `- ${item}`));
+    }
+
+    if (result.changes.length > 0) {
+      lines.push("", "#### Changes", ...result.changes.map(item => `- ${item}`));
+    }
+
+    lines.push(
+      "",
+      "#### Request JSON",
+      "```json",
+      JSON.stringify(result.request, null, 2),
+      "```",
+      "",
+      "Next: pass this JSON into `/lasso:compile` or `/lasso:run` when you are ready.",
+    );
+
+    return lines.join("\n");
+  }
+
+  if (result.status === "needs_operator_input") {
+    const lines = ["### Replan Needs Operator Input"];
+
+    if (result.candidateWorkflow) {
+      lines.push("", `Likely workflow: \`${result.candidateWorkflow}\``);
+    }
+
+    lines.push(
+      `Risk level: \`${result.riskLevel}\``,
+      "",
+      "#### Reasons",
+      ...result.reasons.map(item => `- ${item}`),
+    );
+
+    if (result.missingFields.length > 0) {
+      lines.push("", "#### Missing Fields", ...result.missingFields.map(item => `- ${item}`));
+    }
+
+    lines.push("", "#### Guidance", ...result.guidance.map(item => `- ${item}`));
+    return lines.join("\n");
+  }
+
+  return [
+    "### Replan Stop",
+    "",
+    `Workflow: \`${result.workflow}\``,
+    `Risk level: \`${result.riskLevel}\``,
+    "",
+    "#### Reasons",
+    ...result.reasons.map(item => `- ${item}`),
+    "",
+    "#### Guidance",
+    ...result.guidance.map(item => `- ${item}`),
+  ].join("\n");
+}

package/src/pi/extension.ts

@@ -0,0 +1,16 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import workflowExtension, { getWorkflowRegistry, type WorkflowRegistry } from "pi-duroxide";
+import { createLassoCommands } from "./commands.js";
+
+export default async function lassoExtension(pi: ExtensionAPI) {
+  await workflowExtension(pi);
+
+  const registry = getWorkflowRegistry();
+  if (!registry) {
+    return;
+  }
+
+  for (const command of createLassoCommands(registry)) {
+    pi.registerCommand(command.name, command);
+  }
+}

package/src/planner/synthesize.ts

@@ -0,0 +1,83 @@
+import type { ReferenceWorkflowRequest } from "../reference/catalog.js";
+import { parsePromptOrSkill } from "../synthesis/skill-parser.js";
+import { buildTaskGraph } from "../synthesis/graph-builder.js";
+import { analyzeRisks } from "../synthesis/risk-analyzer.js";
+import { synthesizePolicy } from "../synthesis/policy-builder.js";
+import type { PlannerResult } from "./types.js";
+import type { CapabilityRegistry } from "../capabilities/types.js";
+import type { EnvironmentModel } from "../environment/types.js";
+
+export function planWorkflowRequest(
+  brief: string,
+  registry?: CapabilityRegistry,
+  environment?: EnvironmentModel
+): PlannerResult {
+  // Reject empty briefs
+  if (!brief || brief.trim().length === 0) {
+    return {
+      status: "needs_clarification",
+      reasons: ["Brief is empty"],
+      missingFields: ["brief"],
+      guidance: [
+        "Please provide a workflow description including repo path, workflow type (PR review/merge or patch validation), and required commands."
+      ]
+    };
+  }
+  
+  // Parse the brief or skill markdown into IntentIR
+  const parseResult = parsePromptOrSkill(brief);
+  
+  // Handle rejection
+  if ("rejected" in parseResult) {
+    // Populate missingFields when workflow type is ambiguous
+    const missingFields = parseResult.reasons.some(r => r.includes("workflow type") || r.includes("workflow family")) 
+      ? ["workflow type"] 
+      : [];
+    
+    return {
+      status: "needs_clarification",
+      candidateWorkflow: parseResult.candidateFamily,
+      reasons: parseResult.reasons,
+      missingFields,
+      guidance: parseResult.guidance
+    };
+  }
+  
+  const intent = parseResult.intent;
+  
+  // Build task graph from intent
+  const graph = buildTaskGraph(intent, registry, environment);
+  
+  // Analyze risks
+  const risks = analyzeRisks(graph, registry);
+  
+  // Synthesize policy
+  const policyResult = synthesizePolicy(graph, risks);
+  
+  // Handle policy synthesis failure
+  if (!policyResult.success) {
+    return {
+      status: "needs_clarification",
+      candidateWorkflow: intent.family,
+      reasons: policyResult.reasons,
+      missingFields: policyResult.missingFields,
+      guidance: policyResult.guidance
+    };
+  }
+  
+  const policy = policyResult.policy;
+  
+  // Build the request
+  const request: ReferenceWorkflowRequest = {
+    workflow: policy.workflow,
+    input: policy.bundle
+  };
+  
+  return {
+    status: "draft_request",
+    workflow: policy.workflow,
+    request,
+    rationale: policy.rationale,
+    warnings: policy.warnings
+  };
+}