@mhingston5/lasso 0.1.0

package/src/composition/types.ts

@@ -0,0 +1,105 @@
+import type { HarnessSpec, TaskNode, TaskEdge, ConditionNode, MergeNode } from "../spec/types.js";
+
+export interface HarnessChain {
+  name: string;
+  stages: HarnessStage[];
+}
+
+export interface HarnessStage {
+  name: string;
+  spec: HarnessSpec;
+  inputMapping: Record<string, string>;
+  condition?: string;
+}
+
+export interface CompositionResult {
+  combinedSpec: HarnessSpec;
+  stageCount: number;
+  totalNodes: number;
+  estimatedDurationMs: number;
+}
+
+export interface HarnessComposer {
+  chain(stages: HarnessStage[]): CompositionResult;
+  parallel(harnesses: HarnessSpec[]): CompositionResult;
+  conditional(condition: string, trueHarness: HarnessSpec, falseHarness?: HarnessSpec): CompositionResult;
+}
+
+export function prefixNodeId(stageName: string, nodeId: string): string {
+  return `${stageName}:${nodeId}`;
+}
+
+export function prefixNode(stageName: string, node: TaskNode): TaskNode {
+  const prefixed: TaskNode = {
+    ...node,
+    id: prefixNodeId(stageName, node.id),
+  } as TaskNode;
+
+  if (node.kind === "condition") {
+    (prefixed as ConditionNode).thenNodeId = prefixNodeId(stageName, (node as ConditionNode).thenNodeId);
+    (prefixed as ConditionNode).elseNodeId = prefixNodeId(stageName, (node as ConditionNode).elseNodeId);
+  }
+
+  if (node.kind === "merge") {
+    (prefixed as MergeNode).waitFor = (node as MergeNode).waitFor.map((id: string) => prefixNodeId(stageName, id));
+  }
+
+  return prefixed;
+}
+
+export function prefixEdge(stageName: string, edge: TaskEdge): TaskEdge {
+  return {
+    from: prefixNodeId(stageName, edge.from),
+    to: prefixNodeId(stageName, edge.to),
+  };
+}
+
+export function prefixSpec(stageName: string, spec: HarnessSpec): HarnessSpec {
+  return {
+    name: spec.name,
+    graph: {
+      entryNodeId: prefixNodeId(stageName, spec.graph.entryNodeId),
+      nodes: spec.graph.nodes.map((node) => prefixNode(stageName, node)),
+      edges: spec.graph.edges.map((edge) => prefixEdge(stageName, edge)),
+    },
+    ...(spec.executionPolicy ? { executionPolicy: spec.executionPolicy } : {}),
+    ...(spec.humanPolicy ? { humanPolicy: spec.humanPolicy } : {}),
+    ...(spec.observabilityPolicy ? { observabilityPolicy: spec.observabilityPolicy } : {}),
+  };
+}
+
+export function findTerminalNodes(spec: HarnessSpec): string[] {
+  const nodeIds = new Set(spec.graph.nodes.map((n) => n.id));
+  const hasIncoming = new Set(spec.graph.edges.map((e) => e.to));
+
+  const terminals: string[] = [];
+  for (const node of spec.graph.nodes) {
+    if (node.kind === "condition") {
+      continue;
+    }
+    if (!hasIncoming.has(node.id) && node.id !== spec.graph.entryNodeId) {
+      continue;
+    }
+    const hasOutgoing = spec.graph.edges.some((e) => e.from === node.id);
+    if (!hasOutgoing && node.kind !== "merge") {
+      terminals.push(node.id);
+    }
+  }
+
+  if (terminals.length === 0) {
+    for (const node of spec.graph.nodes) {
+      if (node.kind !== "condition" && node.kind !== "merge") {
+        const hasOutgoing = spec.graph.edges.some((e) => e.from === node.id);
+        if (!hasOutgoing) {
+          terminals.push(node.id);
+        }
+      }
+    }
+  }
+
+  if (terminals.length === 0 && spec.graph.nodes.length === 1) {
+    return [spec.graph.entryNodeId];
+  }
+
+  return terminals;
+}

package/src/environment/analyzer.ts

@@ -0,0 +1,56 @@
+import type {
+  EnvironmentModel,
+  EnvironmentAnalysis,
+  ToolCapability,
+  Constraint,
+} from "./types.js";
+
+export function analyzeEnvironment(
+  model: EnvironmentModel,
+  requiredTools?: string[]
+): EnvironmentAnalysis {
+  const matchedTools: ToolCapability[] = [];
+  const missingTools: string[] = [];
+
+  if (requiredTools && requiredTools.length > 0) {
+    for (const toolName of requiredTools) {
+      const found = model.tools.find(t => t.name === toolName);
+      if (found && found.available) {
+        matchedTools.push(found);
+      } else {
+        missingTools.push(toolName);
+      }
+    }
+  }
+
+  const highRiskConstraints = model.constraints.filter(c => c.severity === "high");
+
+  const totalRequired = requiredTools?.length ?? 0;
+  let readinessScore = totalRequired > 0
+    ? Math.round((matchedTools.length / totalRequired) * 100)
+    : 100;
+
+  for (const constraint of highRiskConstraints) {
+    readinessScore = Math.max(0, readinessScore - 20);
+  }
+
+  const preparatorySteps: string[] = [];
+
+  for (const missing of missingTools) {
+    preparatorySteps.push(`Install missing tool: ${missing}`);
+  }
+
+  for (const constraint of model.constraints) {
+    if (constraint.severity === "high" || constraint.severity === "medium") {
+      preparatorySteps.push(`Address constraint: ${constraint.description}`);
+    }
+  }
+
+  return {
+    matchedTools,
+    missingTools,
+    highRiskConstraints,
+    readinessScore,
+    preparatorySteps,
+  };
+}

package/src/environment/discovery.ts

@@ -0,0 +1,179 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { statfs } from "node:fs/promises";
+import { connect } from "node:net";
+import type {
+  EnvironmentModel,
+  ToolCapability,
+  Resource,
+  Constraint,
+  AuthState,
+  RepoState,
+  ExternalSystem,
+  DiscoveryOptions,
+} from "./types.js";
+
+const execAsync = promisify(exec);
+
+const DEFAULT_TOOLS = ["bash", "git", "node", "npm", "python", "docker", "kubectl"];
+
+async function probeTool(name: string): Promise<ToolCapability> {
+  try {
+    const { stdout } = await execAsync(`${name} --version`, { timeout: 5000 });
+    const version = stdout.trim().split("\n")[0].trim();
+    return { name, version, available: true };
+  } catch {
+    return { name, available: false };
+  }
+}
+
+async function probeDisk(): Promise<Resource> {
+  try {
+    const stat = await statfs("/");
+    const totalBytes = BigInt(stat.bsize) * BigInt(stat.blocks);
+    const freeBytes = BigInt(stat.bsize) * BigInt(stat.bfree);
+    const usedBytes = totalBytes - freeBytes;
+    const usagePct = ((Number(usedBytes) / Number(totalBytes)) * 100).toFixed(1);
+
+    return {
+      name: "disk",
+      type: "disk",
+      available: true,
+      limit: `${(Number(totalBytes) / 1e9).toFixed(1)}GB`,
+      usage: `${usagePct}%`,
+    };
+  } catch {
+    return { name: "disk", type: "disk", available: false };
+  }
+}
+
+async function probeRepo(repoPath: string): Promise<RepoState | undefined> {
+  try {
+    const { stdout: branch } = await execAsync("git branch --show-current", {
+      cwd: repoPath,
+      timeout: 5000,
+    });
+
+    const { stdout: status } = await execAsync("git status --porcelain", {
+      cwd: repoPath,
+      timeout: 5000,
+    });
+
+    const { stdout: remotesOut } = await execAsync("git remote", {
+      cwd: repoPath,
+      timeout: 5000,
+    });
+
+    const { stdout: tagsOut } = await execAsync("git tag --list", {
+      cwd: repoPath,
+      timeout: 5000,
+    });
+
+    return {
+      path: repoPath,
+      branch: branch.trim() || undefined,
+      hasUncommittedChanges: status.trim().length > 0,
+      remotes: remotesOut.trim().split("\n").filter(Boolean),
+      tags: tagsOut.trim().split("\n").filter(Boolean),
+    };
+  } catch {
+    return {
+      path: repoPath,
+      hasUncommittedChanges: false,
+      remotes: [],
+      tags: [],
+    };
+  }
+}
+
+async function probeExternalSystem(
+  host: string,
+  port: number,
+  timeoutMs: number
+): Promise<ExternalSystem> {
+  const start = Date.now();
+  return new Promise((resolve) => {
+    const socket = connect({ host, port, timeout: timeoutMs });
+
+    socket.on("connect", () => {
+      const latency = Date.now() - start;
+      socket.destroy();
+      resolve({ name: host, reachable: true, latencyMs: latency });
+    });
+
+    socket.on("error", (err) => {
+      socket.destroy();
+      resolve({ name: host, reachable: false, error: err.message });
+    });
+
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve({ name: host, reachable: false, error: "Connection timed out" });
+    });
+  });
+}
+
+function detectConstraints(tools: ToolCapability[]): Constraint[] {
+  const constraints: Constraint[] = [];
+
+  const gitTool = tools.find(t => t.name === "git");
+  if (gitTool && !gitTool.available) {
+    constraints.push({
+      type: "permission",
+      description: "git is not available — repo operations will fail",
+      severity: "high",
+    });
+  }
+
+  const dockerTool = tools.find(t => t.name === "docker");
+  if (dockerTool && !dockerTool.available) {
+    constraints.push({
+      type: "permission",
+      description: "docker is not available — container operations will fail",
+      severity: "medium",
+    });
+  }
+
+  return constraints;
+}
+
+function detectAuthState(): AuthState[] {
+  return [];
+}
+
+export async function discoverEnvironment(
+  repoPath?: string,
+  options?: DiscoveryOptions
+): Promise<EnvironmentModel> {
+  const toolsToProbe = options?.tools ?? DEFAULT_TOOLS;
+  const toolResults = await Promise.all(toolsToProbe.map(probeTool));
+
+  const diskResource = await probeDisk();
+
+  let repoState: RepoState | undefined;
+  if (repoPath) {
+    repoState = await probeRepo(repoPath);
+  }
+
+  const externalSystems: ExternalSystem[] = [];
+  if (options?.externalSystems && options.externalSystems.length > 0) {
+    const timeout = options.networkTimeoutMS ?? 3000;
+    const probes = options.externalSystems.map(async (host) => {
+      return probeExternalSystem(host, 443, timeout);
+    });
+    externalSystems.push(...(await Promise.all(probes)));
+  }
+
+  const constraints = detectConstraints(toolResults);
+  const authState = detectAuthState();
+
+  return {
+    tools: toolResults,
+    resources: [diskResource],
+    constraints,
+    authState,
+    repoState,
+    externalSystems,
+    discoveredAt: Date.now(),
+  };
+}

package/src/environment/types.ts

@@ -0,0 +1,68 @@
+export interface ToolCapability {
+  name: string;
+  version?: string;
+  available: boolean;
+  path?: string;
+}
+
+export interface Resource {
+  name: string;
+  type: "disk" | "memory" | "network" | "cpu";
+  available: boolean;
+  limit?: string;
+  usage?: string;
+}
+
+export interface Constraint {
+  type: "auth" | "network" | "permission" | "rate-limit";
+  description: string;
+  severity: "low" | "medium" | "high";
+}
+
+export interface AuthState {
+  system: string;
+  authenticated: boolean;
+  expiresAt?: number;
+  scopes?: string[];
+}
+
+export interface RepoState {
+  path: string;
+  branch?: string;
+  hasUncommittedChanges: boolean;
+  remotes: string[];
+  tags: string[];
+}
+
+export interface ExternalSystem {
+  name: string;
+  reachable: boolean;
+  latencyMs?: number;
+  error?: string;
+}
+
+export interface EnvironmentModel {
+  tools: ToolCapability[];
+  resources: Resource[];
+  constraints: Constraint[];
+  authState: AuthState[];
+  repoState?: RepoState;
+  externalSystems: ExternalSystem[];
+  discoveredAt: number;
+}
+
+export interface DiscoveryOptions {
+  tools?: string[];
+  checkAuth?: boolean;
+  checkNetwork?: boolean;
+  networkTimeoutMs?: number;
+  externalSystems?: string[];
+}
+
+export interface EnvironmentAnalysis {
+  matchedTools: ToolCapability[];
+  missingTools: string[];
+  highRiskConstraints: Constraint[];
+  readinessScore: number;
+  preparatorySteps: string[];
+}

package/src/failures/classifiers.ts

@@ -0,0 +1,134 @@
+export interface ClassifierResult {
+  matched: boolean;
+  evidence: string[];
+}
+
+const AUTH_PATTERNS = [
+  { regex: /\b401\b/i, evidence: "HTTP 401" },
+  { regex: /\b403\b/i, evidence: "HTTP 403" },
+  { regex: /unauthorized/i, evidence: "unauthorized" },
+  { regex: /authentication required/i, evidence: "authentication required" },
+  { regex: /token expired/i, evidence: "token expired" },
+  { regex: /invalid credentials/i, evidence: "invalid credentials" },
+  { regex: /access denied/i, evidence: "access denied" },
+  { regex: /forbidden/i, evidence: "forbidden" },
+];
+
+const TOOL_PATTERNS = [
+  { regex: /command not found/i, evidence: "command not found" },
+  { regex: /exit(?:ed)? with code (\d+)/i, evidence: "exit code" },
+  { regex: /no such file or directory/i, evidence: "no such file or directory" },
+  { regex: /stderr:/i, evidence: "stderr output" },
+  { regex: /ENOENT/i, evidence: "ENOENT" },
+  { regex: /not a valid/i, evidence: "not a valid" },
+];
+
+const RESOURCE_PATTERNS = [
+  { regex: /no space left on device/i, evidence: "disk full" },
+  { regex: /out of memory/i, evidence: "out of memory" },
+  { regex: /heap.*memory/i, evidence: "heap memory" },
+  { regex: /rate limit/i, evidence: "rate limit" },
+  { regex: /too many requests/i, evidence: "too many requests" },
+  { regex: /cannot allocate memory/i, evidence: "cannot allocate memory" },
+  { regex: /resource.*exhaust/i, evidence: "resource exhausted" },
+];
+
+const SEMANTIC_PATTERNS = [
+  { regex: /assertion failed/i, evidence: "assertion failed" },
+  { regex: /unexpected output/i, evidence: "unexpected output" },
+  { regex: /schema/i, evidence: "schema" },
+  { regex: /type mismatch/i, evidence: "type mismatch" },
+  { regex: /validation error/i, evidence: "validation error" },
+  { regex: /invalid (?:format|json|yaml|xml)/i, evidence: "invalid format" },
+];
+
+const HUMAN_PATTERNS = [
+  { regex: /reject(?:ed)?/i, evidence: "rejected" },
+  { regex: /declined/i, evidence: "declined" },
+  { regex: /no response/i, evidence: "no response" },
+  { regex: /timed out waiting for human/i, evidence: "human timeout" },
+  { regex: /human.*timeout/i, evidence: "human timeout" },
+  { regex: /approval.*timeout/i, evidence: "approval timeout" },
+];
+
+const ENVIRONMENT_DRIFT_PATTERNS = [
+  { regex: /version mismatch/i, evidence: "version mismatch" },
+  { regex: /cannot find module/i, evidence: "missing dependency" },
+  { regex: /module.*not found/i, evidence: "missing dependency" },
+  { regex: /config(?:uration)? changed/i, evidence: "config changed" },
+  { regex: /incompatible.*version/i, evidence: "incompatible version" },
+  { regex: /required.*version/i, evidence: "required version" },
+  { regex: /dependency.*missing/i, evidence: "missing dependency" },
+];
+
+const NETWORK_PATTERNS = [
+  { regex: /(?:connection|request) timed out/i, evidence: "timeout" },
+  { regex: /ECONNREFUSED/i, evidence: "connection refused" },
+  { regex: /ENOTFOUND/i, evidence: "DNS" },
+  { regex: /getaddrinfo/i, evidence: "DNS" },
+  { regex: /network.*unreachable/i, evidence: "network unreachable" },
+  { regex: /socket hang up/i, evidence: "socket hang up" },
+  { regex: /ECONNRESET/i, evidence: "connection reset" },
+  { regex: /ETIMEDOUT/i, evidence: "ETIMEDOUT" },
+  { regex: /connect.*refused/i, evidence: "connection refused" },
+];
+
+function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return String(error);
+}
+
+function matchPatterns(
+  message: string,
+  patterns: Array<{ regex: RegExp; evidence: string }>,
+): ClassifierResult {
+  const evidence: string[] = [];
+  for (const pattern of patterns) {
+    if (pattern.regex.test(message)) {
+      if (pattern.regex.source.includes("(\\d+)")) {
+        const match = message.match(pattern.regex);
+        if (match) {
+          evidence.push(`${pattern.evidence} ${match[1]}`);
+        } else {
+          evidence.push(pattern.evidence);
+        }
+      } else {
+        evidence.push(pattern.evidence);
+      }
+    }
+  }
+  return { matched: evidence.length > 0, evidence };
+}
+
+export function classifyAuthFailure(error: unknown): ClassifierResult {
+  return matchPatterns(getErrorMessage(error), AUTH_PATTERNS);
+}
+
+export function classifyToolFailure(error: unknown): ClassifierResult {
+  return matchPatterns(getErrorMessage(error), TOOL_PATTERNS);
+}
+
+export function classifyResourceFailure(error: unknown): ClassifierResult {
+  return matchPatterns(getErrorMessage(error), RESOURCE_PATTERNS);
+}
+
+export function classifySemanticFailure(error: unknown): ClassifierResult {
+  return matchPatterns(getErrorMessage(error), SEMANTIC_PATTERNS);
+}
+
+export function classifyHumanFailure(error: unknown): ClassifierResult {
+  return matchPatterns(getErrorMessage(error), HUMAN_PATTERNS);
+}
+
+export function classifyEnvironmentDriftFailure(error: unknown): ClassifierResult {
+  return matchPatterns(getErrorMessage(error), ENVIRONMENT_DRIFT_PATTERNS);
+}
+
+export function classifyNetworkFailure(error: unknown): ClassifierResult {
+  return matchPatterns(getErrorMessage(error), NETWORK_PATTERNS);
+}