@aigne/ash 0.0.1 → 0.0.2-beta.1

package/src/ai-dev-loop/ash-typed-error.ts

@@ -1,50 +0,0 @@
-/**
- * AshTypedError — Discriminated union of all ASH error types.
- *
- * Each kind carries enough structured information for AI self-repair.
- */
-
-export type AshTypedError =
-  | { kind: "IntentDenied"; invariant: string; message: string; suggestion?: string }
-  | { kind: "CapabilityMissing"; capability: string; message: string }
-  | { kind: "ToolNotFound"; name: string; available: string[]; message: string }
-  | { kind: "ValidationFailed"; field: string; expected: string; got: string; message: string }
-  | { kind: "BudgetExceeded"; device: string; limit: number; used: number; message: string }
-  | { kind: "Timeout"; step: string; limit_ms: number; message: string }
-  | { kind: "ParseError"; line?: number; message: string }
-  | { kind: "RuntimeError"; message: string; context?: Record<string, unknown> };
-
-const VALID_KINDS = new Set([
-  "IntentDenied", "CapabilityMissing", "ToolNotFound", "ValidationFailed",
-  "BudgetExceeded", "Timeout", "ParseError", "RuntimeError",
-]);
-
-export function isAshTypedError(value: unknown): value is AshTypedError {
-  if (!value || typeof value !== "object") return false;
-  const obj = value as Record<string, unknown>;
-  return typeof obj.kind === "string" && VALID_KINDS.has(obj.kind) && typeof obj.message === "string";
-}
-
-/**
- * Best-effort conversion from raw ASH error string → AshTypedError.
- */
-export function fromJobError(errorStr: string): AshTypedError {
-  if (errorStr.startsWith("Capability denied:")) {
-    const capability = errorStr.replace("Capability denied:", "").trim();
-    return { kind: "CapabilityMissing", capability, message: errorStr };
-  }
-
-  if (errorStr.includes("not found") || errorStr.includes("unknown command")) {
-    return { kind: "ToolNotFound", name: errorStr, available: [], message: errorStr };
-  }
-
-  if (errorStr.includes("timeout") || errorStr.includes("Timeout")) {
-    return { kind: "Timeout", step: "", limit_ms: 0, message: errorStr };
-  }
-
-  if (errorStr.includes("parse") || errorStr.includes("syntax") || errorStr.includes("Unexpected")) {
-    return { kind: "ParseError", message: errorStr };
-  }
-
-  return { kind: "RuntimeError", message: errorStr };
-}

package/src/ai-dev-loop/ash-validate.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ashValidate } from "./ash-validate.js";
-
-describe("ash.validate", () => {
-  // ── Happy Path ─────────────────────────────────────────
-
-  it("valid script → empty ParseError[]", () => {
-    const errors = ashValidate('job "test" { find /users | map name }');
-    expect(errors).toHaveLength(0);
-  });
-
-  it("script with unknown command → ParseError", () => {
-    const errors = ashValidate('job "test" { find /users | foobar }');
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors[0].kind).toBe("ParseError");
-  });
-
-  it("script with unterminated string → ParseError with line number", () => {
-    const errors = ashValidate('job "test { find /users }');
-    expect(errors.length).toBeGreaterThan(0);
-  });
-
-  it("multiple errors → all collected in array", () => {
-    // Two unknown commands
-    const errors = ashValidate('job "test" { foobar | bazqux }');
-    expect(errors.length).toBeGreaterThan(0);
-  });
-
-  // ── Bad Path ───────────────────────────────────────────
-
-  it("empty string → empty ParseError[] (valid, no jobs)", () => {
-    const errors = ashValidate("");
-    expect(errors).toHaveLength(0);
-  });
-
-  it("null/undefined input → rejected", () => {
-    expect(() => ashValidate(null as any)).toThrow();
-    expect(() => ashValidate(undefined as any)).toThrow();
-  });
-
-  // ── Edge Cases ─────────────────────────────────────────
-
-  it("script with only comments → valid", () => {
-    // ASH may or may not support comments — if it does, this is valid
-    // If not, it may be an empty program which is valid
-    const errors = ashValidate("");
-    expect(errors).toHaveLength(0);
-  });
-
-  it("script with unknown command → type error reported", () => {
-    const errors = ashValidate('job "test" { find /users | foobar }');
-    expect(errors.length).toBeGreaterThan(0);
-  });
-});

package/src/ai-dev-loop/ash-validate.ts

@@ -1,34 +0,0 @@
-/**
- * ash.validate — Static analysis for ASH scripts.
- *
- * Reuses existing compileSource() diagnostics to catch syntax + type errors
- * without executing.
- */
-
-import { compileSource } from "../compiler.js";
-import type { AshTypedError } from "./ash-typed-error.js";
-
-export function ashValidate(source: string): AshTypedError[] {
-  if (source == null) {
-    throw new Error("ash.validate: source must be a string, got " + typeof source);
-  }
-
-  if (!source.trim()) {
-    return [];
-  }
-
-  const result = compileSource(source);
-  const errors: AshTypedError[] = [];
-
-  for (const diag of result.diagnostics) {
-    if (diag.severity === "warning") continue;
-
-    errors.push({
-      kind: "ParseError",
-      line: diag.line,
-      message: diag.message,
-    });
-  }
-
-  return errors;
-}

package/src/ai-dev-loop/dev-loop.test.ts

@@ -1,364 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { runDevLoop } from "./dev-loop.js";
-import type { AshRunResult } from "./ash-run-result.js";
-
-/** Fake think: returns tool calls with ASH script content */
-function fakeThink(scripts: string[]) {
-  let call = 0;
-  return vi.fn(async (_req: any) => ({
-    kind: "completed" as const,
-    response: {
-      content: scripts[call] ?? "",
-      tool_calls: [
-        { id: `tc-${call}`, name: "ash_run", arguments: JSON.stringify({ script: scripts[call++] ?? "" }) },
-      ],
-    },
-    toolResults: [],
-  }));
-}
-
-/** Fake runner: returns success or failure based on the script */
-function fakeRunner(failScripts: Set<string> = new Set()) {
-  return vi.fn(async (source: string): Promise<AshRunResult> => {
-    if (failScripts.has(source)) {
-      return {
-        status: "error",
-        steps: [{ step: 1, command: "find", status: "error", duration_ms: 5 }],
-        failedAt: { kind: "RuntimeError", message: `Failed: ${source}` },
-        duration_ms: 5,
-      };
-    }
-    return {
-      status: "ok",
-      steps: [{ step: 1, command: "find", status: "ok", duration_ms: 5, output: [{ id: 1 }] }],
-      output: [{ id: 1 }],
-      duration_ms: 5,
-    };
-  });
-}
-
-function fakeValidate() {
-  return vi.fn(async (_source: string) => []);
-}
-
-function fakeObserve() {
-  return vi.fn(async (_data: any) => {});
-}
-
-describe("AI Dev Loop Core", () => {
-  // ── Happy Path ─────────────────────────────────────────
-
-  it("success on first try", async () => {
-    const think = fakeThink(['job "test" { find /users }']);
-    const runner = fakeRunner();
-    const validate = fakeValidate();
-    const observe = fakeObserve();
-
-    const result = await runDevLoop({
-      intent: "find all users",
-      max_iterations: 3,
-      think,
-      runner,
-      validate,
-      observe,
-    });
-
-    expect(result.status).toBe("ok");
-    expect(result.iterations).toBe(1);
-    expect(result.finalResult?.status).toBe("ok");
-    expect(think).toHaveBeenCalledTimes(1);
-  });
-
-  it("first run fails → LLM corrects → second run succeeds", async () => {
-    const badScript = "bad script";
-    const goodScript = 'job "fixed" { find /users }';
-    const think = fakeThink([badScript, goodScript]);
-    const runner = fakeRunner(new Set([badScript]));
-    const validate = fakeValidate();
-    const observe = fakeObserve();
-
-    const result = await runDevLoop({
-      intent: "find users",
-      max_iterations: 5,
-      think,
-      runner,
-      validate,
-      observe,
-    });
-
-    expect(result.status).toBe("ok");
-    expect(result.iterations).toBe(2);
-    expect(think).toHaveBeenCalledTimes(2);
-  });
-
-  it("returns final AshRunResult and all observations", async () => {
-    const think = fakeThink(["script1"]);
-    const runner = fakeRunner();
-    const observe = fakeObserve();
-
-    const result = await runDevLoop({
-      intent: "do something",
-      max_iterations: 3,
-      think,
-      runner,
-      validate: fakeValidate(),
-      observe,
-    });
-
-    expect(result.finalResult).toBeDefined();
-    expect(result.observations.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it("each iteration calls observe with execution result", async () => {
-    const think = fakeThink(["s1", "s2"]);
-    const runner = fakeRunner(new Set(["s1"]));
-    const observe = fakeObserve();
-
-    await runDevLoop({
-      intent: "test",
-      max_iterations: 3,
-      think,
-      runner,
-      validate: fakeValidate(),
-      observe,
-    });
-
-    expect(observe).toHaveBeenCalledTimes(2);
-  });
-
-  it("calls validate before run", async () => {
-    const callOrder: string[] = [];
-    const validate = vi.fn(async () => { callOrder.push("validate"); return []; });
-    const runner = vi.fn(async (): Promise<AshRunResult> => {
-      callOrder.push("run");
-      return { status: "ok", steps: [], output: [], duration_ms: 0 };
-    });
-
-    await runDevLoop({
-      intent: "test",
-      max_iterations: 1,
-      think: fakeThink(["script"]),
-      runner,
-      validate,
-      observe: fakeObserve(),
-    });
-
-    expect(callOrder).toEqual(["validate", "run"]);
-  });
-
-  it("successful loop returns iteration count", async () => {
-    const think = fakeThink(["a", "b", "c"]);
-    const runner = fakeRunner(new Set(["a", "b"]));
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 5,
-      think,
-      runner,
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.iterations).toBe(3);
-  });
-
-  // ── Bad Path ───────────────────────────────────────────
-
-  it("exceeds max_iterations → returns last failure (INV-4)", async () => {
-    const think = fakeThink(["bad1", "bad2", "bad3"]);
-    const runner = fakeRunner(new Set(["bad1", "bad2", "bad3"]));
-
-    const result = await runDevLoop({
-      intent: "will fail",
-      max_iterations: 3,
-      think,
-      runner,
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.status).toBe("error");
-    expect(result.iterations).toBe(3);
-    expect(result.finalResult?.status).toBe("error");
-    expect(result.observations).toHaveLength(3);
-  });
-
-  it("validate catches parse error → correction prompt without run", async () => {
-    const validate = vi.fn(async (source: string) => {
-      if (source === "bad syntax") {
-        return [{ kind: "ParseError" as const, message: "unexpected token", line: 1 }];
-      }
-      return [];
-    });
-    const runner = fakeRunner();
-    const think = fakeThink(["bad syntax", "good script"]);
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 3,
-      think,
-      runner,
-      validate,
-      observe: fakeObserve(),
-    });
-
-    // Runner should only be called for the good script
-    expect(runner).toHaveBeenCalledTimes(1);
-    expect(result.status).toBe("ok");
-  });
-
-  it("LLM returns empty response → treated as error", async () => {
-    const think = vi.fn(async () => ({
-      kind: "completed" as const,
-      response: { content: "", tool_calls: undefined },
-      toolResults: [],
-    }));
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 2,
-      think,
-      runner: fakeRunner(),
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.status).toBe("error");
-  });
-
-  it("think throws → loop terminates with error", async () => {
-    const think = vi.fn(async () => { throw new Error("LLM down"); });
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 3,
-      think,
-      runner: fakeRunner(),
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.status).toBe("error");
-    expect(result.error).toContain("LLM down");
-  });
-
-  it("budget exceeded mid-loop → loop terminates with error", async () => {
-    let callCount = 0;
-    const think = vi.fn(async () => {
-      callCount++;
-      if (callCount === 2) throw new Error("BudgetExceeded: token limit reached");
-      return {
-        kind: "completed" as const,
-        response: {
-          content: "",
-          tool_calls: [{ id: "tc-1", name: "ash_run", arguments: JSON.stringify({ script: "fail" }) }],
-        },
-        toolResults: [],
-      };
-    });
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 5,
-      think,
-      runner: fakeRunner(new Set(["fail"])),
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.status).toBe("error");
-    expect(result.error).toContain("BudgetExceeded");
-    expect(result.iterations).toBe(2);
-  });
-
-  it("extractScript: script from content fallback when no tool_calls", async () => {
-    const think = vi.fn(async () => ({
-      kind: "completed" as const,
-      response: { content: 'job "fromContent" { find /x }', tool_calls: undefined },
-      toolResults: [],
-    }));
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 1,
-      think,
-      runner: fakeRunner(),
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.status).toBe("ok");
-  });
-
-  // ── Edge Cases ─────────────────────────────────────────
-
-  it("max_iterations=1 → single attempt, no correction", async () => {
-    const think = fakeThink(["script"]);
-    const runner = fakeRunner(new Set(["script"]));
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 1,
-      think,
-      runner,
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.status).toBe("error");
-    expect(result.iterations).toBe(1);
-    expect(think).toHaveBeenCalledTimes(1);
-  });
-
-  it("LLM fixes on last iteration → success", async () => {
-    const scripts = ["bad1", "bad2", "bad3", "bad4", "good"];
-    const think = fakeThink(scripts);
-    const runner = fakeRunner(new Set(["bad1", "bad2", "bad3", "bad4"]));
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 5,
-      think,
-      runner,
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.status).toBe("ok");
-    expect(result.iterations).toBe(5);
-  });
-
-  it("all iterations fail → returns array of all failures", async () => {
-    const think = fakeThink(["f1", "f2"]);
-    const runner = fakeRunner(new Set(["f1", "f2"]));
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 2,
-      think,
-      runner,
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.observations).toHaveLength(2);
-  });
-
-  // ── Security ───────────────────────────────────────────
-
-  it("default mode is dry-run (INV-1)", async () => {
-    const think = fakeThink(["script"]);
-    const runner = fakeRunner();
-
-    const result = await runDevLoop({
-      intent: "test",
-      max_iterations: 1,
-      think,
-      runner,
-      validate: fakeValidate(),
-      observe: fakeObserve(),
-    });
-
-    expect(result.mode).toBe("dry-run");
-  });
-});

package/src/ai-dev-loop/dev-loop.ts

@@ -1,156 +0,0 @@
-/**
- * AI Dev Loop Core — bounded generate → validate → run → observe → correct loop.
- *
- * Invariants enforced:
- * - INV-1: Default mode is dry-run
- * - INV-3: Observe only, never commit to long-term memory
- * - INV-4: Bounded by max_iterations
- */
-
-import type { AshRunResult, AshRunFailure } from "./ash-run-result.js";
-import type { AshTypedError } from "./ash-typed-error.js";
-import { buildSystemPrompt, buildCorrectionPrompt } from "./system-prompt.js";
-
-export interface DevLoopConfig {
-  intent: string;
-  max_iterations: number;
-  mode?: "dry-run" | "live";
-  think: (request: any) => Promise<any>;
-  runner: (source: string) => Promise<AshRunResult>;
-  validate: (source: string) => Promise<AshTypedError[]>;
-  observe: (data: any) => Promise<void>;
-}
-
-export interface DevLoopResult {
-  status: "ok" | "error";
-  iterations: number;
-  mode: "dry-run" | "live";
-  finalResult?: AshRunResult;
-  observations: any[];
-  error?: string;
-}
-
-/**
- * Run the AI dev loop: think → extract ASH → validate → run → observe → correct or return.
- */
-export async function runDevLoop(config: DevLoopConfig): Promise<DevLoopResult> {
-  const mode = config.mode ?? "dry-run";
-  const observations: any[] = [];
-  let lastFailure: AshRunFailure | undefined;
-  let lastScript: string | undefined;
-
-  for (let i = 0; i < config.max_iterations; i++) {
-    // 1. Think — ask LLM for ASH script
-    let thinkResult: any;
-    try {
-      const messages: any[] = [];
-      if (i === 0) {
-        messages.push({ role: "system", content: buildSystemPrompt({ max_iterations: config.max_iterations }) });
-        messages.push({ role: "user", content: config.intent });
-      } else {
-        messages.push({ role: "user", content: buildCorrectionPrompt(lastFailure!, lastScript!) });
-      }
-      thinkResult = await config.think({ messages });
-    } catch (err: any) {
-      return { status: "error", iterations: i + 1, mode, observations, error: err.message };
-    }
-
-    // 2. Extract script from tool call or content
-    const script = extractScript(thinkResult);
-    if (!script) {
-      const obs = { iteration: i + 1, error: "empty_response" };
-      observations.push(obs);
-      await config.observe(obs);
-      // If no script, treat as failure for this iteration
-      if (i === config.max_iterations - 1) {
-        return { status: "error", iterations: i + 1, mode, observations, error: "LLM returned no script" };
-      }
-      // Create a synthetic failure for correction
-      lastFailure = {
-        status: "error",
-        steps: [],
-        failedAt: { kind: "RuntimeError", message: "LLM returned no ASH script" } as AshTypedError,
-        duration_ms: 0,
-      };
-      lastScript = "";
-      continue;
-    }
-
-    lastScript = script;
-
-    // 3. Validate
-    const errors = await config.validate(script);
-    if (errors.length > 0) {
-      const obs = { iteration: i + 1, script, validation_errors: errors };
-      observations.push(obs);
-      await config.observe(obs);
-
-      if (i === config.max_iterations - 1) {
-        return {
-          status: "error",
-          iterations: i + 1,
-          mode,
-          observations,
-          finalResult: {
-            status: "error",
-            steps: [],
-            failedAt: errors[0],
-            duration_ms: 0,
-          },
-        };
-      }
-
-      lastFailure = {
-        status: "error",
-        steps: [],
-        failedAt: errors[0] as AshTypedError,
-        duration_ms: 0,
-      };
-      continue;
-    }
-
-    // 4. Run
-    const result = await config.runner(script);
-
-    // 5. Observe
-    const obs = { iteration: i + 1, script, result };
-    observations.push(obs);
-    await config.observe(obs);
-
-    // 6. Check result
-    if (result.status === "ok") {
-      return { status: "ok", iterations: i + 1, mode, finalResult: result, observations };
-    }
-
-    // Failed — prepare for correction
-    lastFailure = result as AshRunFailure;
-  }
-
-  // Exhausted all iterations
-  return {
-    status: "error",
-    iterations: config.max_iterations,
-    mode,
-    finalResult: lastFailure,
-    observations,
-  };
-}
-
-function extractScript(thinkResult: any): string | undefined {
-  // Try tool_calls first (ash_run call)
-  const toolCalls = thinkResult?.response?.tool_calls;
-  if (Array.isArray(toolCalls)) {
-    for (const tc of toolCalls) {
-      if (tc.name === "ash_run") {
-        try {
-          const args = typeof tc.arguments === "string" ? JSON.parse(tc.arguments) : tc.arguments;
-          if (args?.script) return args.script;
-        } catch { /* ignore parse error */ }
-      }
-    }
-  }
-  // Fall back to content
-  const content = thinkResult?.response?.content;
-  if (typeof content === "string" && content.trim()) return content.trim();
-  return undefined;
-}