@aigne/ash 0.0.1

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

@@ -0,0 +1,102 @@
+import { describe, it, expect } from "vitest";
+import { buildSystemPrompt, buildCorrectionPrompt } from "./system-prompt.js";
+import type { AshRunFailure } from "./ash-run-result.js";
+
+describe("System Prompt Assembly", () => {
+  // ── buildSystemPrompt ──────────────────────────────────
+
+  it("contains rules, tools, and ASH reference", () => {
+    const prompt = buildSystemPrompt({ max_iterations: 3 });
+    expect(prompt).toContain("You are an AOS agent");
+    expect(prompt).toContain("ash.validate");
+    expect(prompt).toContain("ash.run");
+    expect(prompt).toContain("ash.explain_error");
+    expect(prompt).toContain("ASH quick reference");
+  });
+
+  it("shows max_iterations count", () => {
+    const prompt = buildSystemPrompt({ max_iterations: 3 });
+    expect(prompt).toContain("3 attempts");
+  });
+
+  it("singular attempt for max_iterations=1", () => {
+    const prompt = buildSystemPrompt({ max_iterations: 1 });
+    expect(prompt).toContain("1 attempt");
+    expect(prompt).not.toContain("1 attempts");
+  });
+
+  it("rejects max_iterations=0", () => {
+    expect(() => buildSystemPrompt({ max_iterations: 0 })).toThrow();
+  });
+
+  it("does not contain API keys or internal paths", () => {
+    const prompt = buildSystemPrompt({ max_iterations: 5 });
+    expect(prompt).not.toMatch(/api[_-]?key/i);
+    expect(prompt).not.toMatch(/\/Users\//);
+    expect(prompt).not.toMatch(/\/home\//);
+  });
+
+  // ── buildCorrectionPrompt ──────────────────────────────
+
+  it("contains step, error kind, detail, and suggestion", () => {
+    const failure: AshRunFailure = {
+      status: "error",
+      steps: [{ step: 1, command: "find", status: "ok", duration_ms: 10, output: [] }],
+      failedAt: { kind: "ToolNotFound", name: "foo", available: ["find", "where"], message: "not found" },
+      duration_ms: 20,
+    };
+    const prompt = buildCorrectionPrompt(failure, 'job "test" { find /users }');
+    expect(prompt).toContain("ToolNotFound");
+    expect(prompt).toContain("not found");
+    expect(prompt).toContain('job "test" { find /users }');
+  });
+
+  it("includes previous script", () => {
+    const failure: AshRunFailure = {
+      status: "error",
+      steps: [],
+      failedAt: { kind: "ParseError", message: "unexpected token", line: 3 },
+      duration_ms: 5,
+    };
+    const script = 'job "broken" {\n  find /x\n  ???\n}';
+    const prompt = buildCorrectionPrompt(failure, script);
+    expect(prompt).toContain(script);
+  });
+
+  it("omits suggestion line when error has no suggestion", () => {
+    const failure: AshRunFailure = {
+      status: "error",
+      steps: [],
+      failedAt: { kind: "RuntimeError", message: "boom" },
+      duration_ms: 1,
+    };
+    const prompt = buildCorrectionPrompt(failure, "output hello");
+    expect(prompt).toContain("RuntimeError");
+    expect(prompt).not.toMatch(/Suggestion:.*undefined/);
+  });
+
+  it("does not truncate very long script", () => {
+    const failure: AshRunFailure = {
+      status: "error",
+      steps: [],
+      failedAt: { kind: "Timeout", step: "find", limit_ms: 1000, message: "timeout" },
+      duration_ms: 1000,
+    };
+    const longScript = "find /users\n".repeat(1000);
+    const prompt = buildCorrectionPrompt(failure, longScript);
+    expect(prompt).toContain(longScript);
+  });
+
+  it("does not leak world data beyond the failing step", () => {
+    const failure: AshRunFailure = {
+      status: "error",
+      steps: [
+        { step: 1, command: "find", status: "ok", duration_ms: 10, output: [{ secret: "password123" }] },
+      ],
+      failedAt: { kind: "RuntimeError", message: "step 2 failed" },
+      duration_ms: 20,
+    };
+    const prompt = buildCorrectionPrompt(failure, "find /users | save /out");
+    expect(prompt).not.toContain("password123");
+  });
+});

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

@@ -0,0 +1,81 @@
+/**
+ * System Prompt Assembly for ASH AI Dev Loop.
+ *
+ * Implements the prompt contracts from INTENT §5.1 and §5.2.
+ */
+
+import type { AshRunFailure } from "./ash-run-result.js";
+import type { AshTypedError } from "./ash-typed-error.js";
+
+export interface LoopConfig {
+  max_iterations: number;
+}
+
+/**
+ * Build the initial system prompt for the AI dev loop (INTENT §5.1).
+ */
+export function buildSystemPrompt(config: LoopConfig): string {
+  if (config.max_iterations < 1) {
+    throw new Error("max_iterations must be at least 1");
+  }
+  const plural = config.max_iterations === 1 ? "attempt" : "attempts";
+  return `You are an AOS agent. You operate inside AOS by writing and running ASH scripts.
+
+Rules:
+1. Write ASH scripts to accomplish the user's intent.
+2. Use ash.validate before ash.run.
+3. If ash.run fails, read the structured error carefully.
+4. Fix only the failing step. Do not rewrite unrelated steps.
+5. You have at most ${config.max_iterations} ${plural}.
+
+Available tools:
+- ash.validate(script) → ParseError[]
+- ash.run(script, mode="dry-run") → AshRunResult
+- ash.explain_error(error) → explanation + suggestions
+
+ASH quick reference:
+- discover intent="..." → find tools
+- pick [n] → select from results
+- exec <tool> [args] → run tool (goes through Intent Gate)
+- read/write/edit → AFS operations
+- pipe with | → chain steps`;
+}
+
+/**
+ * Build the correction prompt for a failed iteration (INTENT §5.2).
+ *
+ * Only includes the error info and previous script — never leaks
+ * step output data to avoid world data exposure.
+ */
+export function buildCorrectionPrompt(failure: AshRunFailure, script: string): string {
+  const err = failure.failedAt as AshTypedError;
+  const failedStep = failure.steps.length > 0
+    ? failure.steps[failure.steps.length - 1]
+    : undefined;
+
+  const lines = [
+    "The previous ASH script failed.",
+    "",
+    "Failure:",
+    `- Step: ${failedStep ? `${failedStep.step} (${failedStep.command})` : "unknown"}`,
+    `- Error: ${err.kind}`,
+    `- Detail: ${err.message}`,
+  ];
+
+  const suggestion = (err as any).suggestion;
+  if (suggestion) {
+    lines.push(`- Suggestion: ${suggestion}`);
+  }
+
+  lines.push(
+    "",
+    "Previous script:",
+    "---",
+    script,
+    "---",
+    "",
+    "Fix the script. Only change the failing step unless the fix requires structural changes.",
+  );
+
+  return lines.join("\n");
+}

package/src/ast.ts

@@ -0,0 +1,186 @@
+export interface Annotation {
+  name: string;
+  args: string[];
+  line: number;
+  column: number;
+}
+
+export interface QueryCondition {
+  field: string;
+  op: "==" | "!=" | ">" | "<" | ">=" | "<=";
+  value: string | number;
+}
+
+export interface FindExpression {
+  kind: "find";
+  path: string;
+  query?: QueryCondition;
+}
+
+export interface WhereClause {
+  kind: "where";
+  left: string;
+  op: "==" | "!=" | ">" | "<" | ">=" | "<=";
+  right: string | number;
+}
+
+// ── Expression types (v3.1: restricted expression system) ──
+
+export interface BinaryExpression {
+  kind: "binary";
+  op: "+" | "-" | "*" | "/";
+  left: Expression;
+  right: Expression;
+}
+
+export interface FieldAccessExpression {
+  kind: "field_access";
+  path: string; // dot-separated, e.g. "user.name"
+}
+
+export interface LiteralExpression {
+  kind: "literal";
+  value: string | number;
+}
+
+export interface VarRefExpression {
+  kind: "var_ref";
+  name: string; // without $
+}
+
+export type Expression =
+  | BinaryExpression
+  | FieldAccessExpression
+  | LiteralExpression
+  | VarRefExpression;
+
+export interface MapExpression {
+  kind: "map";
+  field: string; // dot-separated, e.g. "user.name" (single-field mode)
+  mappings?: Record<string, string>; // { outputKey: inputField } (object mapping mode, no colon)
+  expression?: Expression; // single-expression mode: map name + " " + surname
+  exprMappings?: Record<string, Expression>; // expression object mode: map { key: expr, ... }
+}
+
+export interface SaveExpression {
+  kind: "save";
+  path: string;
+}
+
+export interface PublishExpression {
+  kind: "publish";
+  path: string;
+}
+
+export interface TeeExpression {
+  kind: "tee";
+  path: string;
+}
+
+export interface FanoutExpression {
+  kind: "fanout";
+  branches: PipelineStage[][];
+}
+
+export interface OutputExpression {
+  kind: "output";
+  message: string;
+  expression?: Expression;
+}
+
+export interface InputExpression {
+  kind: "input";
+  prompt: string;
+}
+
+export interface CountExpression {
+  kind: "count";
+}
+
+export interface GroupByExpression {
+  kind: "group-by";
+  field: string;
+}
+
+export interface ActionExpression {
+  kind: "action";
+  path: string;
+  relative?: boolean;
+  params?: Record<string, unknown>;
+}
+
+export interface RouteBranch {
+  value: string; // match value, or "_" for fallback
+  targetJob: string;
+}
+
+export interface RouteExpression {
+  kind: "route";
+  field: string;
+  branches: RouteBranch[];
+  fallback?: string; // fallback job name (from `_ -> job name`)
+}
+
+export interface LookupExpression {
+  kind: "lookup";
+  path: string;
+  joinKey: string; // field to join on
+}
+
+export type PipelineStage =
+  | FindExpression
+  | WhereClause
+  | MapExpression
+  | SaveExpression
+  | PublishExpression
+  | TeeExpression
+  | FanoutExpression
+  | OutputExpression
+  | InputExpression
+  | CountExpression
+  | GroupByExpression
+  | ActionExpression
+  | RouteExpression
+  | LookupExpression;
+
+export interface EventTrigger {
+  kind: "event";
+  path: string;
+  event: string;
+}
+
+export interface CronTrigger {
+  kind: "cron";
+  expression: string;
+}
+
+export type TriggerDeclaration = EventTrigger | CronTrigger;
+
+export interface JobDeclaration {
+  kind: "job";
+  name: string;
+  annotations: Annotation[];
+  pipeline: PipelineStage[];
+  trigger?: TriggerDeclaration;
+}
+
+export interface LetStatement {
+  kind: "let";
+  name: string;
+  value: string | number;
+  pipeline?: PipelineStage[]; // runtime let: let x = find /data | count
+}
+
+export interface ParamDeclaration {
+  kind: "param";
+  name: string;
+  defaultValue: string | number;
+}
+
+export type TopLevelStatement = JobDeclaration | OutputExpression | LetStatement | ParamDeclaration;
+
+export interface Program {
+  statements: TopLevelStatement[];
+  /** Backward-compatible accessor: returns only job declarations */
+  jobs: JobDeclaration[];
+}