@jsleekr/graft 5.8.0 → 6.0.1

package/dist/formatter.js

@@ -0,0 +1,170 @@
+import { formatExpr } from './format.js';
+export function formatProgram(program) {
+    const sections = [];
+    // Imports
+    for (const imp of program.imports) {
+        sections.push(formatImport(imp));
+    }
+    // Memories
+    for (const mem of program.memories) {
+        sections.push(formatMemory(mem));
+    }
+    // Contexts
+    for (const ctx of program.contexts) {
+        if (!ctx.sourceFile || ctx.sourceFile === program.contexts[0]?.sourceFile) {
+            sections.push(formatContext(ctx));
+        }
+    }
+    // Nodes
+    for (const node of program.nodes) {
+        if (!node.sourceFile || node.sourceFile === program.nodes[0]?.sourceFile) {
+            sections.push(formatNode(node));
+        }
+    }
+    // Edges
+    for (const edge of program.edges) {
+        sections.push(formatEdge(edge));
+    }
+    // Graphs
+    for (const graph of program.graphs) {
+        sections.push(formatGraph(graph));
+    }
+    return sections.join('\n\n') + '\n';
+}
+function formatImport(imp) {
+    return `import { ${imp.names.join(', ')} } from "${imp.path}"`;
+}
+function formatMemory(mem) {
+    const fields = mem.fields.map(f => `  ${f.name}: ${formatType(f.type)}`).join('\n');
+    return `memory ${mem.name}(max_tokens: ${formatTokens(mem.maxTokens)}, storage: ${mem.storage}) {\n${fields}\n}`;
+}
+function formatContext(ctx) {
+    const fields = ctx.fields.map(f => `  ${f.name}: ${formatType(f.type)}`).join('\n');
+    return `context ${ctx.name}(max_tokens: ${formatTokens(ctx.maxTokens)}) {\n${fields}\n}`;
+}
+function formatNode(node) {
+    const lines = [];
+    lines.push(`node ${node.name}(model: ${node.model}, budget: ${formatTokens(node.budgetIn)}/${formatTokens(node.budgetOut)}) {`);
+    // reads
+    if (node.reads.length > 0) {
+        lines.push(`  reads: [${node.reads.map(formatContextRef).join(', ')}]`);
+    }
+    // tools
+    if (node.tools.length > 0) {
+        lines.push(`  tools: [${node.tools.join(', ')}]`);
+    }
+    // writes
+    if (node.writes.length > 0) {
+        lines.push(`  writes: [${node.writes.map(w => w.field ? `${w.memory}.${w.field}` : w.memory).join(', ')}]`);
+    }
+    // on_failure
+    if (node.onFailure) {
+        lines.push(`  on_failure: ${formatFailure(node.onFailure)}`);
+    }
+    // produces
+    lines.push('');
+    const producesFields = node.produces.fields.map(f => `    ${f.name}: ${formatType(f.type)}`).join('\n');
+    lines.push(`  produces ${node.produces.name} {`);
+    lines.push(producesFields);
+    lines.push(`  }`);
+    lines.push('}');
+    return lines.join('\n');
+}
+function formatEdge(edge) {
+    if (edge.target.kind === 'conditional') {
+        const branches = edge.target.branches.map(b => {
+            if (b.condition) {
+                return `  when ${formatExpr(b.condition)} -> ${b.target}`;
+            }
+            return `  else -> ${b.target}`;
+        }).join('\n');
+        return `edge ${edge.source} -> {\n${branches}\n}`;
+    }
+    let line = `edge ${edge.source} -> ${edge.target.node}`;
+    if (edge.transforms.length > 0) {
+        line += '\n  | ' + edge.transforms.map(formatTransform).join('\n  | ');
+    }
+    return line;
+}
+function formatGraph(graph) {
+    const params = graph.params.length > 0
+        ? `, ${graph.params.map(p => `${p.name}: ${p.type}${p.default !== undefined ? ` = ${p.default}` : ''}`).join(', ')}`
+        : '';
+    const flowStr = formatFlow(graph.flow, 2);
+    return `graph ${graph.name}(input: ${graph.input}, output: ${graph.output}, budget: ${formatTokens(graph.budget)}${params}) {\n${flowStr}\n}`;
+}
+function formatFlow(flow, indent) {
+    const pad = ' '.repeat(indent);
+    const parts = [];
+    for (const step of flow) {
+        switch (step.kind) {
+            case 'node':
+                parts.push(step.name);
+                break;
+            case 'parallel':
+                parts.push(`parallel { ${step.branches.join('  ')} }`);
+                break;
+            case 'foreach': {
+                const body = formatFlow(step.body, indent + 2);
+                parts.push(`foreach ${step.source}.${step.field} as ${step.binding} (max: ${step.maxIterations}) {\n${body}\n${pad}}`);
+                break;
+            }
+            case 'let':
+                parts.push(`let ${step.name} = ${formatExpr(step.value)}`);
+                break;
+            case 'graph_call':
+                parts.push(`${step.name}(${step.args.map(a => `${a.name}: ${formatExpr(a.value)}`).join(', ')})`);
+                break;
+        }
+    }
+    // Join with -> for sequential steps, but done is implicit
+    return pad + parts.join('\n' + pad + '-> ') + '\n' + pad + '-> done';
+}
+function formatTransform(t) {
+    switch (t.type) {
+        case 'select': return `select(${t.fields.join(', ')})`;
+        case 'drop': return `drop(${t.field})`;
+        case 'compact': return 'compact';
+        case 'truncate': return `truncate(${t.tokens})`;
+        case 'filter': return `filter(${t.field}, ${formatExpr(t.condition)})`;
+    }
+}
+function formatContextRef(ref) {
+    if (ref.field && ref.field.length === 1) {
+        return `${ref.context}.${ref.field[0]}`;
+    }
+    if (ref.field && ref.field.length > 1) {
+        return `${ref.context}.{${ref.field.join(', ')}}`;
+    }
+    return ref.context;
+}
+function formatFailure(f) {
+    switch (f.type) {
+        case 'retry': return `retry(${f.max})`;
+        case 'fallback': return `fallback(${f.node})`;
+        case 'retry_then_fallback': return `retry(${f.max}, fallback: ${f.node})`;
+        case 'skip': return 'skip';
+        case 'abort': return 'abort';
+    }
+}
+function formatType(t) {
+    switch (t.kind) {
+        case 'primitive': return t.name;
+        case 'primitive_range': return `${t.name}(${t.min}..${t.max})`;
+        case 'list': return `List<${formatType(t.element)}>`;
+        case 'map': return `Map<${formatType(t.key)}, ${formatType(t.value)}>`;
+        case 'optional': return `Optional<${formatType(t.inner)}>`;
+        case 'token_bounded': return `TokenBounded<${formatType(t.inner)}, ${t.max}>`;
+        case 'enum': return `enum(${t.values.join(', ')})`;
+        case 'struct': {
+            const fields = t.fields.map(f => `${f.name}: ${formatType(f.type)}`).join(', ');
+            return `${t.name} { ${fields} }`;
+        }
+        case 'domain': return t.name;
+    }
+}
+function formatTokens(n) {
+    if (n >= 1000 && n % 1000 === 0)
+        return `${n / 1000}k`;
+    return String(n);
+}

package/dist/generator.d.ts

@@ -0,0 +1,28 @@
+import { GraftError } from './errors/diagnostics.js';
+/** Function that calls the LLM. Injectable for testing. */
+export type LLMCaller = (params: {
+    system: string;
+    userMessage: string;
+}) => Promise<string>;
+export interface GenerateOptions {
+    output?: string;
+    /** Override the LLM caller (for testing). */
+    llmCaller?: LLMCaller;
+}
+export interface GenerateResult {
+    source: string;
+    errors: GraftError[];
+}
+/**
+ * Extract .gft source from an LLM response.
+ * Multi-strategy: (1) ```gft fence, (2) any fence, (3) bare response.
+ */
+export declare function extractGftSource(response: string): string;
+/**
+ * Build the system prompt for .gft generation.
+ */
+export declare function buildSystemPrompt(): string;
+/**
+ * Generate a .gft file from a natural language description.
+ */
+export declare function generateGft(description: string, options?: GenerateOptions): Promise<GenerateResult>;

package/dist/generator.js

@@ -0,0 +1,255 @@
+/**
+ * graft generate — natural language to .gft pipeline generation via Claude Code subprocess.
+ */
+import { spawnClaude } from './runtime/subprocess.js';
+import { compileToProgram } from './compiler.js';
+import { GraftError } from './errors/diagnostics.js';
+const SYSTEM_PROMPT = `You are a Graft (.gft) pipeline generator. Generate valid .gft source code based on the user's description.
+
+## .gft Syntax Reference
+
+### Context Declaration
+\`\`\`
+context <Name>(max_tokens: <N>) {
+  <fieldName>: <Type>
+  ...
+}
+\`\`\`
+Types: String, Int, Float, Bool, List<T>, Map<K,V>, Optional<T>
+
+### Memory Declaration
+\`\`\`
+memory <Name>(max_tokens: <N>, storage: file) {
+  <fieldName>: <Type>
+  ...
+}
+\`\`\`
+
+### Node Declaration
+\`\`\`
+node <Name>(model: <model>, budget: <in>/<out>) {
+  reads: [<ContextOrProducesName>, ...]
+
+  produces <OutputName> {
+    <fieldName>: <Type>
+    ...
+  }
+}
+\`\`\`
+Models: haiku, sonnet, opus. Budget format: input/output in token shorthand (e.g., 4k/2k, 8k/4k, 12k/6k).
+
+### Edge Declaration
+\`\`\`
+// Direct edge with transforms
+edge <Source> -> <Target>
+  | select(<field1>, <field2>)
+  | compact
+  | filter(<field> <op> <value>)
+  | truncate(<N>)
+  | drop(<field>)
+
+// Conditional edge
+edge <Source> -> {
+  when <condition> -> <Target>
+  when <condition> -> <Target>
+  otherwise -> <Target>
+}
+\`\`\`
+
+### Graph Declaration
+\`\`\`
+graph <Name>(input: <Context>, output: <Produces>, budget: <N>) {
+  // Sequential
+  <Node1> -> <Node2> -> done
+
+  // Parallel
+  parallel {
+    <Node1>
+    <Node2>
+  }
+  -> <Node3> -> done
+
+  // Foreach
+  foreach(<Source>.<field> as <var>, max_iterations: <N>) {
+    <Node> -> done
+  }
+}
+\`\`\`
+
+## Rules
+- Output ONLY valid .gft code inside a \`\`\`gft fenced block
+- Do NOT use import statements
+- Every node must have model, budget (in/out), reads, and produces with typed fields
+- Every graph must declare input, output, and budget
+- Use realistic token budgets: haiku 4k/2k, sonnet 8k/4k, opus 12k/6k
+- Add edge transforms (select, compact) to reduce token flow between nodes
+- Add comments to explain the pipeline
+
+## Complete Example
+
+\`\`\`gft
+// Adversarial Code Review Pipeline
+// Security + Performance + Logic reviewers challenge each other,
+// then a senior reviewer makes the final call.
+
+context PullRequest(max_tokens: 3k) {
+  diff: String
+  description: String
+  files_changed: List<String>
+}
+
+node SecurityReviewer(model: sonnet, budget: 6k/3k) {
+  reads: [PullRequest]
+
+  produces SecurityAnalysis {
+    vulnerabilities: List<String>
+    severity: String
+    recommendation: String
+  }
+}
+
+node LogicReviewer(model: sonnet, budget: 6k/3k) {
+  reads: [PullRequest]
+
+  produces LogicAnalysis {
+    bugs: List<String>
+    edge_cases: List<String>
+    correctness: String
+  }
+}
+
+node PerformanceReviewer(model: haiku, budget: 4k/2k) {
+  reads: [PullRequest]
+
+  produces PerfAnalysis {
+    hotspots: List<String>
+    complexity_concerns: List<String>
+    impact: String
+  }
+}
+
+node SeniorReviewer(model: opus, budget: 10k/5k) {
+  reads: [PullRequest, SecurityAnalysis, LogicAnalysis, PerfAnalysis]
+
+  produces FinalReview {
+    approved: Bool
+    blocking_issues: List<String>
+    suggestions: List<String>
+    summary: String
+  }
+}
+
+edge SecurityReviewer -> SeniorReviewer
+  | select(vulnerabilities, severity)
+  | compact
+
+edge LogicReviewer -> SeniorReviewer
+  | select(bugs, edge_cases)
+  | compact
+
+edge PerformanceReviewer -> SeniorReviewer
+  | select(hotspots, complexity_concerns)
+  | compact
+
+graph AdversarialReview(input: PullRequest, output: FinalReview, budget: 40k) {
+  parallel {
+    SecurityReviewer
+    LogicReviewer
+    PerformanceReviewer
+  }
+  -> SeniorReviewer -> done
+}
+\`\`\`
+`;
+const MAX_RETRIES = 2;
+/**
+ * Extract .gft source from an LLM response.
+ * Multi-strategy: (1) ```gft fence, (2) any fence, (3) bare response.
+ */
+export function extractGftSource(response) {
+    // Strategy 1: ```gft ... ```
+    const gftFence = response.match(/```gft\s*\n([\s\S]*?)```/);
+    if (gftFence)
+        return gftFence[1].trim();
+    // Strategy 2: any ``` ... ```
+    const anyFence = response.match(/```\s*\n([\s\S]*?)```/);
+    if (anyFence)
+        return anyFence[1].trim();
+    // Strategy 3: bare response (strip obvious markdown)
+    return response.replace(/^#+\s.*$/gm, '').trim();
+}
+/**
+ * Build the system prompt for .gft generation.
+ */
+export function buildSystemPrompt() {
+    return SYSTEM_PROMPT;
+}
+/**
+ * Validate generated .gft source using the Graft compiler.
+ */
+function validateSource(source) {
+    try {
+        const result = compileToProgram(source, 'generated.gft');
+        if (!result.success)
+            return result.errors;
+        return [];
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return [new GraftError(msg, { line: 0, column: 0, offset: 0 }, 'error')];
+    }
+}
+/**
+ * Default LLM caller using Claude Code subprocess.
+ */
+function createDefaultCaller() {
+    return async ({ system, userMessage }) => {
+        const prompt = `${system}\n\n---\n\nUser request: ${userMessage}`;
+        const result = await spawnClaude({
+            args: ['--print', '--output-format', 'text', prompt],
+            cwd: process.cwd(),
+            timeoutMs: 120_000,
+        });
+        if (result.exitCode !== 0) {
+            throw new Error(`Claude Code exited with code ${result.exitCode}.\n` +
+                `Make sure Claude Code is installed: npm install -g @anthropic-ai/claude-code\n` +
+                (result.stderr ? `stderr: ${result.stderr.slice(0, 500)}` : ''));
+        }
+        return result.stdout;
+    };
+}
+/**
+ * Generate a .gft file from a natural language description.
+ */
+export async function generateGft(description, options) {
+    if (!description.trim()) {
+        throw new Error('Description cannot be empty.');
+    }
+    const callLLM = options?.llmCaller ?? createDefaultCaller();
+    let bestSource = '';
+    let bestErrors = [];
+    let userMessage = description;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        const text = await callLLM({ system: SYSTEM_PROMPT, userMessage });
+        const source = extractGftSource(text);
+        const errors = validateSource(source);
+        if (errors.length === 0) {
+            return { source, errors: [] };
+        }
+        // Track best attempt (fewest errors)
+        if (bestSource === '' || errors.length < bestErrors.length) {
+            bestSource = source;
+            bestErrors = errors;
+        }
+        // Build retry prompt with error feedback
+        if (attempt < MAX_RETRIES) {
+            const errorMessages = errors
+                .map(e => e.format(source, 'generated.gft'))
+                .join('\n');
+            userMessage =
+                `${description}\n\n` +
+                    `Your previous attempt had these compilation errors. Fix them:\n\n${errorMessages}`;
+        }
+    }
+    return { source: bestSource, errors: bestErrors };
+}