@jsleekr/graft 5.7.0

package/dist/runtime/expr-eval.js

@@ -0,0 +1,138 @@
+export function evaluateExpr(expr, outputs, variables, warnings) {
+    switch (expr.kind) {
+        case 'literal':
+            return expr.value;
+        case 'field_access': {
+            // Single-segment: check variables first (variable-first resolution per R2 ratchet v4.0-R21)
+            if (expr.segments.length === 1) {
+                if (variables?.has(expr.segments[0])) {
+                    return variables.get(expr.segments[0]);
+                }
+                // Could be a node name with single output
+                return outputs.get(expr.segments[0]);
+            }
+            // Multi-segment: first segment is source name, rest are nested field access
+            const root = outputs.get(expr.segments[0]);
+            if (root === undefined || root === null)
+                return undefined;
+            let current = root;
+            for (let i = 1; i < expr.segments.length; i++) {
+                if (current === null || current === undefined || typeof current !== 'object')
+                    return undefined;
+                current = current[expr.segments[i]];
+            }
+            return current;
+        }
+        case 'binary': {
+            // Short-circuit for logical and null coalescing operators
+            if (expr.op === '&&') {
+                const left = evaluateExpr(expr.left, outputs, variables, warnings);
+                return left ? evaluateExpr(expr.right, outputs, variables, warnings) : left;
+            }
+            if (expr.op === '||') {
+                const left = evaluateExpr(expr.left, outputs, variables, warnings);
+                return left ? left : evaluateExpr(expr.right, outputs, variables, warnings);
+            }
+            if (expr.op === '??') {
+                const left = evaluateExpr(expr.left, outputs, variables, warnings);
+                return left !== null && left !== undefined ? left : evaluateExpr(expr.right, outputs, variables, warnings);
+            }
+            const left = evaluateExpr(expr.left, outputs, variables, warnings);
+            const right = evaluateExpr(expr.right, outputs, variables, warnings);
+            switch (expr.op) {
+                case '+':
+                    if (typeof left === 'string' || typeof right === 'string')
+                        return String(left) + String(right);
+                    return Number(left) + Number(right);
+                case '-': return Number(left) - Number(right);
+                case '*': return Number(left) * Number(right);
+                case '/': {
+                    const divisor = Number(right);
+                    if (divisor === 0) {
+                        warnings?.push('division by zero in expression');
+                        return 0;
+                    }
+                    return Number(left) / divisor;
+                }
+                case '%': {
+                    const divisor = Number(right);
+                    if (divisor === 0) {
+                        warnings?.push('division by zero in expression');
+                        return 0;
+                    }
+                    return Number(left) % divisor;
+                }
+                case '>': return Number(left) > Number(right);
+                case '<': return Number(left) < Number(right);
+                case '>=': return Number(left) >= Number(right);
+                case '<=': return Number(left) <= Number(right);
+                case '==': return left === right;
+                case '!=': return left !== right;
+            }
+            break;
+        }
+        case 'unary': {
+            const operand = evaluateExpr(expr.operand, outputs, variables, warnings);
+            if (expr.op === '-')
+                return -Number(operand);
+            if (expr.op === '!')
+                return !operand;
+            return operand;
+        }
+        case 'group':
+            return evaluateExpr(expr.inner, outputs, variables, warnings);
+        case 'call': {
+            const args = expr.args.map(a => evaluateExpr(a, outputs, variables, warnings));
+            switch (expr.name) {
+                case 'len': {
+                    const val = args[0];
+                    if (Array.isArray(val))
+                        return val.length;
+                    if (typeof val === 'string')
+                        return val.length;
+                    return 0;
+                }
+                case 'max': return Math.max(Number(args[0]), Number(args[1]));
+                case 'min': return Math.min(Number(args[0]), Number(args[1]));
+                case 'str': return typeof args[0] === 'object' && args[0] !== null ? JSON.stringify(args[0]) : String(args[0]);
+                case 'abs': return Math.abs(Number(args[0]));
+                case 'round': return Math.round(Number(args[0]));
+                case 'keys': {
+                    const val = args[0];
+                    if (typeof val === 'object' && val !== null && !Array.isArray(val)) {
+                        return Object.keys(val);
+                    }
+                    return [];
+                }
+                default: return undefined;
+            }
+        }
+        case 'template': {
+            return expr.parts.map(part => {
+                if (part.kind === 'text')
+                    return part.value;
+                const val = evaluateExpr(part.value, outputs, variables, warnings);
+                return String(val);
+            }).join('');
+        }
+        case 'conditional': {
+            const cond = evaluateExpr(expr.condition, outputs, variables, warnings);
+            return cond
+                ? evaluateExpr(expr.consequent, outputs, variables, warnings)
+                : evaluateExpr(expr.alternate, outputs, variables, warnings);
+        }
+        default: {
+            const _exhaustive = expr;
+            return _exhaustive;
+        }
+    }
+}
+export function resolveNestedField(segments, obj) {
+    let current = obj;
+    for (const seg of segments) {
+        if (current === null || current === undefined || typeof current !== 'object')
+            return undefined;
+        current = current[seg];
+    }
+    return current;
+}

package/dist/runtime/flow-runner.d.ts

@@ -0,0 +1,21 @@
+import { FlowNode, FailureStrategy, ConditionalBranch, Transform, GraphDecl } from '../parser/ast.js';
+import { NodeResult } from './executor.js';
+import { RuntimeState } from './prompt-builder.js';
+import { MAX_CONDITIONAL_HOPS } from '../constants.js';
+import { evaluateExpr, resolveNestedField } from './expr-eval.js';
+export { MAX_CONDITIONAL_HOPS };
+export { evaluateExpr, resolveNestedField };
+export interface ConditionalEdgeInfo {
+    branches: ConditionalBranch[];
+    transforms: Transform[];
+}
+export interface FlowContext extends RuntimeState {
+    executeNode: (name: string) => Promise<NodeResult>;
+    getFailureStrategy?: (name: string) => FailureStrategy | undefined;
+    getConditionalEdge?: (sourceName: string) => ConditionalEdgeInfo | null;
+    variables?: Map<string, unknown>;
+    getGraphDecl?: (name: string) => GraphDecl | undefined;
+}
+export declare function applyFallbackAlias(name: string, result: NodeResult, ctx: FlowContext): void;
+export declare function executeConditionalChain(flowNodeName: string, result: NodeResult, ctx: FlowContext, nodeResults: NodeResult[], errors: string[]): Promise<void>;
+export declare function executeFlowNodes(flow: FlowNode[], nodeResults: NodeResult[], errors: string[], ctx: FlowContext): Promise<void>;

package/dist/runtime/flow-runner.js

@@ -0,0 +1,230 @@
+import { resolveField } from './prompt-builder.js';
+import { applyTransforms } from './transforms.js';
+import { MAX_CONDITIONAL_HOPS } from '../constants.js';
+import { evaluateExpr, resolveNestedField } from './expr-eval.js';
+export { MAX_CONDITIONAL_HOPS };
+export { evaluateExpr, resolveNestedField };
+async function executeWithFailureStrategy(name, nodeResults, errors, ctx) {
+    const result = await ctx.executeNode(name);
+    if (result.success)
+        return result;
+    const strategy = ctx.getFailureStrategy?.(name);
+    if (!strategy || strategy.type === 'abort') {
+        nodeResults.push(result);
+        errors.push(result.error ?? `Node ${name} failed`);
+        return null;
+    }
+    switch (strategy.type) {
+        case 'skip':
+            nodeResults.push(result);
+            return null;
+        case 'retry': {
+            for (let attempt = 1; attempt <= strategy.max; attempt++) {
+                const retry = await ctx.executeNode(name);
+                if (retry.success)
+                    return retry;
+            }
+            nodeResults.push(result);
+            errors.push(result.error ?? `Node ${name} failed after ${strategy.max} retries`);
+            return null;
+        }
+        case 'fallback': {
+            const fallback = await ctx.executeNode(strategy.node);
+            if (fallback.success)
+                return fallback;
+            nodeResults.push(fallback);
+            errors.push(fallback.error ?? `Fallback node ${strategy.node} also failed`);
+            return null;
+        }
+        case 'retry_then_fallback': {
+            for (let attempt = 1; attempt <= strategy.max; attempt++) {
+                const retry = await ctx.executeNode(name);
+                if (retry.success)
+                    return retry;
+            }
+            const fallback = await ctx.executeNode(strategy.node);
+            if (fallback.success)
+                return fallback;
+            nodeResults.push(fallback);
+            errors.push(fallback.error ?? `Fallback node ${strategy.node} failed after ${strategy.max} retries of ${name}`);
+            return null;
+        }
+    }
+}
+export function applyFallbackAlias(name, result, ctx) {
+    if (result.node !== name) {
+        ctx.outputs.set(name, result.output);
+    }
+}
+export async function executeConditionalChain(flowNodeName, result, ctx, nodeResults, errors) {
+    const visited = new Set();
+    visited.add(flowNodeName);
+    let currentNodeName = flowNodeName;
+    let currentOutput = result.output;
+    let hop = 0;
+    for (; hop < MAX_CONDITIONAL_HOPS; hop++) {
+        if (errors.length > 0)
+            break;
+        const edgeInfo = ctx.getConditionalEdge?.(currentNodeName);
+        if (!edgeInfo || !currentOutput || typeof currentOutput !== 'object')
+            break;
+        const { branches, transforms } = edgeInfo;
+        const output = currentOutput;
+        const outputMap = new Map(Object.entries(output));
+        let routedTo = null;
+        let elseBranch = null;
+        for (const branch of branches) {
+            if (!branch.condition) {
+                elseBranch = branch.target;
+            }
+            else if (!!evaluateExpr(branch.condition, outputMap, ctx.variables)) {
+                routedTo = branch.target;
+                break;
+            }
+        }
+        const target = routedTo ?? elseBranch;
+        if (!target || target === 'done')
+            break;
+        // Apply transforms after condition evaluation, before target execution
+        if (transforms.length > 0) {
+            const transformed = applyTransforms(currentOutput, transforms);
+            ctx.outputs.set(currentNodeName, transformed);
+        }
+        // Cycle detection
+        if (visited.has(target)) {
+            errors.push(`Conditional edge cycle detected: ${[...visited, target].join(' -> ')}`);
+            break;
+        }
+        visited.add(target);
+        const conditionalResult = await executeWithFailureStrategy(target, nodeResults, errors, ctx);
+        if (!conditionalResult)
+            break;
+        nodeResults.push(conditionalResult);
+        applyFallbackAlias(target, conditionalResult, ctx);
+        currentNodeName = target;
+        currentOutput = conditionalResult.output;
+    }
+    // Post-loop depth limit check: if we used all hops without breaking, the chain is too deep
+    if (hop >= MAX_CONDITIONAL_HOPS && errors.length === 0) {
+        errors.push(`Conditional chain from '${flowNodeName}' exceeded maximum depth of ${MAX_CONDITIONAL_HOPS} hops`);
+    }
+}
+export async function executeFlowNodes(flow, nodeResults, errors, ctx) {
+    for (const flowNode of flow) {
+        if (errors.length > 0)
+            break; // abort on failure
+        switch (flowNode.kind) {
+            case 'node': {
+                if (flowNode.name === 'done')
+                    continue;
+                const result = await executeWithFailureStrategy(flowNode.name, nodeResults, errors, ctx);
+                if (result) {
+                    nodeResults.push(result);
+                    applyFallbackAlias(flowNode.name, result, ctx);
+                    await executeConditionalChain(flowNode.name, result, ctx, nodeResults, errors);
+                }
+                break;
+            }
+            case 'parallel': {
+                const branches = flowNode.branches.filter(name => name !== 'done');
+                const promises = branches.map(name => executeWithFailureStrategy(name, nodeResults, errors, ctx)
+                    .then(result => { if (result)
+                    nodeResults.push(result); })
+                    .catch((reason) => {
+                    const nr = {
+                        node: name,
+                        output: null,
+                        durationMs: 0,
+                        success: false,
+                        error: reason instanceof Error ? reason.message : String(reason),
+                    };
+                    nodeResults.push(nr);
+                    errors.push(nr.error);
+                }));
+                await Promise.allSettled(promises);
+                break;
+            }
+            case 'foreach': {
+                const sourceData = ctx.outputs.get(flowNode.source);
+                if (sourceData === undefined) {
+                    // Source node produced no output (skipped or not executed)
+                    break;
+                }
+                const items = resolveField(sourceData, flowNode.field);
+                if (!Array.isArray(items)) {
+                    errors.push(`foreach: ${flowNode.source}.${flowNode.field} is not an array`);
+                    break;
+                }
+                const hadBinding = ctx.outputs.has(flowNode.binding);
+                const prevBinding = ctx.outputs.get(flowNode.binding);
+                const maxIter = Math.min(items.length, flowNode.maxIterations);
+                for (let i = 0; i < maxIter; i++) {
+                    if (errors.length > 0)
+                        break;
+                    ctx.outputs.set(flowNode.binding, items[i]);
+                    const errorsBefore = errors.length;
+                    await executeFlowNodes(flowNode.body, nodeResults, errors, ctx);
+                    // Annotate any new errors with iteration context
+                    for (let e = errorsBefore; e < errors.length; e++) {
+                        errors[e] = `${errors[e]} (foreach iteration ${i + 1} of ${maxIter})`;
+                    }
+                }
+                // Restore or clean up binding
+                if (hadBinding) {
+                    ctx.outputs.set(flowNode.binding, prevBinding);
+                }
+                else {
+                    ctx.outputs.delete(flowNode.binding);
+                }
+                break;
+            }
+            case 'let': {
+                if (!ctx.variables)
+                    ctx.variables = new Map();
+                const value = evaluateExpr(flowNode.value, ctx.outputs, ctx.variables);
+                ctx.variables.set(flowNode.name, value);
+                break;
+            }
+            case 'graph_call': {
+                const graphDecl = ctx.getGraphDecl?.(flowNode.name);
+                if (!graphDecl) {
+                    errors.push(`Graph '${flowNode.name}' not found`);
+                    break;
+                }
+                // Build child variable map from params
+                const childVars = new Map();
+                const paramMap = new Map(graphDecl.params.map(p => [p.name, p]));
+                for (const arg of flowNode.args) {
+                    const val = evaluateExpr(arg.value, ctx.outputs, ctx.variables);
+                    childVars.set(arg.name, val);
+                }
+                // Fill defaults for missing params
+                for (const param of graphDecl.params) {
+                    if (!childVars.has(param.name) && param.default !== undefined) {
+                        childVars.set(param.name, param.default);
+                    }
+                }
+                // Execute child graph with its own variable scope and isolated outputs
+                const childCtx = {
+                    ...ctx,
+                    variables: childVars,
+                    outputs: new Map(ctx.outputs),
+                };
+                const beforeCount = nodeResults.length;
+                await executeFlowNodes(graphDecl.flow, nodeResults, errors, childCtx);
+                // Capture last node output from child execution and store under graph call name
+                if (nodeResults.length > beforeCount) {
+                    const lastResult = nodeResults[nodeResults.length - 1];
+                    if (lastResult.success) {
+                        ctx.outputs.set(flowNode.name, lastResult.output);
+                    }
+                }
+                break;
+            }
+            default: {
+                const _exhaustive = flowNode;
+                throw new Error(`Unhandled FlowNode kind: ${_exhaustive.kind}`);
+            }
+        }
+    }
+}

package/dist/runtime/memory.d.ts

@@ -0,0 +1,5 @@
+import { MemoryDecl } from '../parser/ast.js';
+export declare function loadMemory(memoryDir: string, name: string, options?: {
+    verbose?: boolean;
+}): Record<string, unknown> | null;
+export declare function saveMemory(memoryDir: string, mem: MemoryDecl, nodeOutput: unknown, fields?: string[]): void;

package/dist/runtime/memory.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function loadMemory(memoryDir, name, options) {
+    const filePath = path.join(memoryDir, `${name.toLowerCase()}.json`);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        if (options?.verbose) {
+            console.warn(`[MEMORY] Warning: ${filePath} exists but contains invalid JSON — treating as empty`);
+        }
+        return null;
+    }
+}
+export function saveMemory(memoryDir, mem, nodeOutput, fields) {
+    fs.mkdirSync(memoryDir, { recursive: true });
+    const filePath = path.join(memoryDir, `${mem.name.toLowerCase()}.json`);
+    let current = {};
+    if (fs.existsSync(filePath)) {
+        try {
+            current = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            current = {};
+        }
+    }
+    if (typeof nodeOutput === 'object' && nodeOutput !== null) {
+        const output = nodeOutput;
+        const targetFields = fields
+            ? mem.fields.filter(f => fields.includes(f.name))
+            : mem.fields;
+        for (const field of targetFields) {
+            if (field.name in output) {
+                current[field.name] = output[field.name];
+            }
+        }
+    }
+    fs.writeFileSync(filePath, JSON.stringify(current, null, 2));
+}

package/dist/runtime/prompt-builder.d.ts

@@ -0,0 +1,12 @@
+import { NodeDecl } from '../parser/ast.js';
+export interface RuntimeState {
+    outputs: Map<string, unknown>;
+    input: Record<string, unknown>;
+}
+export interface PromptContext extends RuntimeState {
+    graphInputName: string;
+}
+export declare function resolveField(data: unknown, field: string): unknown;
+export declare function buildPrompt(nodeDecl: NodeDecl, ctx: PromptContext): string;
+export declare function buildContextSection(nodeDecl: NodeDecl, ctx: PromptContext): string;
+export declare function generateMockOutput(nodeDecl: NodeDecl): Record<string, unknown>;

package/dist/runtime/prompt-builder.js

@@ -0,0 +1,66 @@
+import { fieldsToJsonExample } from '../utils.js';
+export function resolveField(data, field) {
+    if (data === null || data === undefined || typeof data !== 'object')
+        return undefined;
+    return data[field];
+}
+export function buildPrompt(nodeDecl, ctx) {
+    const jsonSchema = fieldsToJsonExample(nodeDecl.produces.fields);
+    const contextSection = buildContextSection(nodeDecl, ctx);
+    return `# ${nodeDecl.name} Agent
+
+## Task
+You are the ${nodeDecl.name} node in a Graft pipeline.
+
+## Input Context
+${contextSection}
+
+## Output Contract
+Produce JSON output matching this schema:
+\`\`\`json
+${JSON.stringify(jsonSchema, null, 2)}
+\`\`\`
+
+## Rules
+- Output ONLY valid JSON. No explanations, no markdown, no code fences.
+- Stay within ${nodeDecl.budgetOut} output tokens.
+`;
+}
+export function buildContextSection(nodeDecl, ctx) {
+    const sections = [];
+    for (const ref of nodeDecl.reads) {
+        const contextData = ctx.outputs.get(ref.context);
+        if (contextData !== undefined) {
+            if (ref.field) {
+                for (const f of ref.field) {
+                    const fieldVal = resolveField(contextData, f);
+                    sections.push(`### ${ref.context}.${f}\n\`\`\`json\n${JSON.stringify(fieldVal, null, 2)}\n\`\`\``);
+                }
+            }
+            else {
+                sections.push(`### ${ref.context}\n\`\`\`json\n${JSON.stringify(contextData, null, 2)}\n\`\`\``);
+            }
+        }
+        else {
+            // Check if input matches the context name
+            if (ref.context === ctx.graphInputName) {
+                if (ref.field) {
+                    for (const f of ref.field) {
+                        const fieldVal = resolveField(ctx.input, f);
+                        sections.push(`### ${ref.context}.${f}\n\`\`\`json\n${JSON.stringify(fieldVal, null, 2)}\n\`\`\``);
+                    }
+                }
+                else {
+                    sections.push(`### ${ref.context}\n\`\`\`json\n${JSON.stringify(ctx.input, null, 2)}\n\`\`\``);
+                }
+            }
+            else {
+                sections.push(`### ${ref.context}\nNo data available.`);
+            }
+        }
+    }
+    return sections.length > 0 ? sections.join('\n\n') : 'No external context required.';
+}
+export function generateMockOutput(nodeDecl) {
+    return fieldsToJsonExample(nodeDecl.produces.fields);
+}

package/dist/runtime/subprocess.d.ts

@@ -0,0 +1,20 @@
+export interface SpawnResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+}
+export interface SpawnOptions {
+    args: string[];
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function spawnClaude(options: SpawnOptions): Promise<SpawnResult>;
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+export declare function parseCLIOutput(stdout: string): {
+    content: unknown;
+    tokenUsage?: TokenUsage;
+};
+export declare function extractJson(stdout: string): unknown;

package/dist/runtime/subprocess.js

@@ -0,0 +1,99 @@
+import { spawn } from 'node:child_process';
+export function spawnClaude(options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('claude', options.args, {
+            cwd: options.cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+        child.stdin?.end(); // Critical: close stdin immediately
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout?.on('data', (chunk) => stdoutChunks.push(chunk));
+        child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            setTimeout(() => child.kill('SIGKILL'), 5000);
+        }, options.timeoutMs);
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            if (err.code === 'ENOENT') {
+                reject(new Error('Claude CLI not found. Install: npm install -g @anthropic-ai/claude-code'));
+            }
+            else {
+                reject(err);
+            }
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            const stdout = Buffer.concat(stdoutChunks).toString('utf-8');
+            const stderr = Buffer.concat(stderrChunks).toString('utf-8');
+            if (timedOut) {
+                reject(new Error(`Claude subprocess timed out after ${options.timeoutMs / 1000}s. stderr: ${stderr.slice(0, 500)}`));
+                return;
+            }
+            resolve({ stdout, stderr, exitCode: code });
+        });
+    });
+}
+export function parseCLIOutput(stdout) {
+    const trimmed = stdout.trim();
+    try {
+        const parsed = JSON.parse(trimmed);
+        // Only treat as CLI envelope if result AND a metadata field present
+        if (typeof parsed === 'object' && parsed !== null && 'result' in parsed &&
+            ('usage' in parsed || 'model' in parsed || 'cost_usd' in parsed)) {
+            let tokenUsage;
+            if (parsed.usage && typeof parsed.usage === 'object' &&
+                typeof parsed.usage.input_tokens === 'number' &&
+                typeof parsed.usage.output_tokens === 'number') {
+                tokenUsage = {
+                    inputTokens: parsed.usage.input_tokens,
+                    outputTokens: parsed.usage.output_tokens,
+                };
+            }
+            let content;
+            if (typeof parsed.result === 'string') {
+                try {
+                    content = JSON.parse(parsed.result);
+                }
+                catch {
+                    content = parsed.result;
+                }
+            }
+            else {
+                content = parsed.result;
+            }
+            return { content, tokenUsage };
+        }
+    }
+    catch { /* not JSON */ }
+    const content = extractJson(stdout);
+    return { content, tokenUsage: undefined };
+}
+export function extractJson(stdout) {
+    const trimmed = stdout.trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch { /* fallback */ }
+    const firstBrace = trimmed.indexOf('{');
+    const lastBrace = trimmed.lastIndexOf('}');
+    if (firstBrace !== -1 && lastBrace > firstBrace) {
+        try {
+            return JSON.parse(trimmed.slice(firstBrace, lastBrace + 1));
+        }
+        catch { /* fallback */ }
+    }
+    const firstBracket = trimmed.indexOf('[');
+    const lastBracket = trimmed.lastIndexOf(']');
+    if (firstBracket !== -1 && lastBracket > firstBracket) {
+        try {
+            return JSON.parse(trimmed.slice(firstBracket, lastBracket + 1));
+        }
+        catch { /* fallback */ }
+    }
+    throw new Error(`Failed to parse JSON from claude output. First 200 chars: ${trimmed.slice(0, 200)}`);
+}

package/dist/runtime/token-tracker.d.ts

@@ -0,0 +1,36 @@
+export interface TokenLogEntry {
+    nodeName: string;
+    estimated: number;
+    actual: number | undefined;
+    cumulative: number;
+    timestamp: string;
+}
+export declare class TokenTracker {
+    private budget;
+    private consumed;
+    private entries;
+    private logPath;
+    constructor(budget: number, logPath?: string | null);
+    record(nodeName: string, usage: {
+        inputTokens: number;
+        outputTokens: number;
+    } | undefined, estimated: {
+        in: number;
+        out: number;
+    }): void;
+    get fraction(): number;
+    get isWarning(): boolean;
+    get isCritical(): boolean;
+    get totalConsumed(): number;
+    getEntries(): TokenLogEntry[];
+    getSummary(): {
+        budget: number;
+        consumed: number;
+        fraction: number;
+        perNode: Array<{
+            node: string;
+            actual?: number;
+            estimated: number;
+        }>;
+    };
+}