@jsleekr/graft 5.7.0

package/dist/runtime/token-tracker.js

@@ -0,0 +1,56 @@
+import * as fs from 'node:fs';
+import { BUDGET_WARNING_THRESHOLD, BUDGET_CRITICAL_THRESHOLD } from '../constants.js';
+export class TokenTracker {
+    budget;
+    consumed = 0;
+    entries = [];
+    logPath;
+    constructor(budget, logPath = null) {
+        this.budget = budget;
+        this.logPath = logPath;
+    }
+    record(nodeName, usage, estimated) {
+        const actual = usage ? usage.inputTokens + usage.outputTokens : undefined;
+        const est = estimated.in + estimated.out;
+        this.consumed += actual ?? est;
+        const timestamp = new Date().toISOString();
+        const entry = { nodeName, estimated: est, actual, cumulative: this.consumed, timestamp };
+        this.entries.push(entry);
+        if (this.logPath) {
+            const actualStr = actual !== undefined ? String(actual) : 'N/A';
+            const pct = this.budget > 0 ? Math.round((this.consumed / this.budget) * 100) : 0;
+            const line = `[${timestamp}] Node ${nodeName} | estimated: ${est} | actual: ${actualStr} | cumulative: ${this.consumed}/${this.budget} (${pct}%)\n`;
+            try {
+                fs.appendFileSync(this.logPath, line);
+            }
+            catch { /* silent */ }
+        }
+    }
+    get fraction() {
+        return this.budget > 0 ? this.consumed / this.budget : 0;
+    }
+    get isWarning() {
+        return this.fraction >= BUDGET_WARNING_THRESHOLD;
+    }
+    get isCritical() {
+        return this.fraction >= BUDGET_CRITICAL_THRESHOLD;
+    }
+    get totalConsumed() {
+        return this.consumed;
+    }
+    getEntries() {
+        return [...this.entries];
+    }
+    getSummary() {
+        return {
+            budget: this.budget,
+            consumed: this.consumed,
+            fraction: this.fraction,
+            perNode: this.entries.map(e => ({
+                node: e.nodeName,
+                actual: e.actual,
+                estimated: e.estimated,
+            })),
+        };
+    }
+}

package/dist/runtime/transforms.d.ts

@@ -0,0 +1,2 @@
+import { Transform } from '../parser/ast.js';
+export declare function applyTransforms(data: unknown, transforms: Transform[]): unknown;

package/dist/runtime/transforms.js

@@ -0,0 +1,104 @@
+import { evaluateExpr } from './expr-eval.js';
+export function applyTransforms(data, transforms) {
+    let result = data;
+    for (const t of transforms) {
+        result = applyOne(result, t);
+    }
+    return result;
+}
+function applyOne(data, transform) {
+    if (data === null || data === undefined || typeof data !== 'object')
+        return data;
+    switch (transform.type) {
+        case 'select': return applySelect(data, transform.fields);
+        case 'filter': return applyFilter(data, transform.field, transform.condition);
+        case 'drop': return applyDrop(data, transform.field);
+        case 'compact': return applyCompact(data);
+        case 'truncate': return applyTruncate(data, transform.tokens);
+    }
+}
+function applySelect(obj, fields) {
+    const result = {};
+    for (const f of fields) {
+        if (f in obj)
+            result[f] = obj[f];
+    }
+    return result;
+}
+function applyFilter(obj, field, condition) {
+    const arr = obj[field];
+    if (!Array.isArray(arr))
+        return obj;
+    const filtered = arr.filter(item => {
+        if (typeof item !== 'object' || item === null)
+            return false;
+        const itemMap = new Map(Object.entries(item));
+        return !!evaluateExpr(condition, itemMap);
+    });
+    return { ...obj, [field]: filtered };
+}
+function applyDrop(obj, field) {
+    const result = { ...obj };
+    delete result[field];
+    return result;
+}
+function applyCompact(data) {
+    if (data === null || data === undefined)
+        return undefined;
+    if (typeof data !== 'object')
+        return data;
+    if (Array.isArray(data)) {
+        return data.map(item => applyCompact(item)).filter(item => !isEmpty(item));
+    }
+    const obj = data;
+    const result = {};
+    for (const [key, val] of Object.entries(obj)) {
+        const compacted = applyCompact(val);
+        if (!isEmpty(compacted))
+            result[key] = compacted;
+    }
+    return result;
+}
+function isEmpty(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (value === '')
+        return true;
+    if (Array.isArray(value) && value.length === 0)
+        return true;
+    if (typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0)
+        return true;
+    return false;
+}
+function applyTruncate(data, maxTokens) {
+    const maxChars = maxTokens * 4; // ~1 token per 4 chars
+    const json = JSON.stringify(data);
+    if (json.length <= maxChars)
+        return data;
+    if (typeof data === 'string' && data.length > maxChars)
+        return data.slice(0, maxChars) + '...';
+    if (typeof data !== 'object' || data === null)
+        return data;
+    const ratio = maxChars / json.length;
+    return truncateDeep(data, ratio);
+}
+function truncateDeep(data, ratio) {
+    if (data === null || data === undefined)
+        return data;
+    if (typeof data === 'string') {
+        const maxLen = Math.max(10, Math.floor(data.length * ratio));
+        return data.length > maxLen ? data.slice(0, maxLen) + '...' : data;
+    }
+    if (Array.isArray(data)) {
+        const maxItems = Math.max(1, Math.floor(data.length * ratio));
+        return data.slice(0, maxItems).map(item => truncateDeep(item, ratio));
+    }
+    if (typeof data === 'object') {
+        const obj = data;
+        const result = {};
+        for (const [key, val] of Object.entries(obj))
+            result[key] = truncateDeep(val, ratio);
+        return result;
+    }
+    return data;
+}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+export type { Program, ContextDecl, NodeDecl, MemoryDecl, EdgeDecl, GraphDecl } from './parser/ast.js';
+export type { ProgramIndex } from './program-index.js';
+export { GraftError } from './errors/diagnostics.js';
+export type { GraftErrorCode, SourceLocation } from './errors/diagnostics.js';
+export type { CodegenBackend, CodegenContext } from './codegen/backend.js';
+export type { GeneratedFile } from './codegen/codegen.js';
+export type { TokenReport } from './analyzer/estimator.js';
+export type { ProgramResult, CompileResult } from './compiler.js';
+export type { RunResult, RunOptions, NodeResult } from './runtime/executor.js';
+export type { TokenUsage } from './runtime/subprocess.js';

package/dist/types.js

@@ -0,0 +1 @@
+export { GraftError } from './errors/diagnostics.js';

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+import { Field, TypeExpr } from './parser/ast.js';
+export declare function fieldsToJsonExample(fields: Field[]): Record<string, unknown>;
+export declare function typeToExample(type: TypeExpr): unknown;

package/dist/utils.js

@@ -0,0 +1,35 @@
+export function fieldsToJsonExample(fields) {
+    const obj = {};
+    for (const field of fields) {
+        obj[field.name] = typeToExample(field.type);
+    }
+    return obj;
+}
+export function typeToExample(type) {
+    switch (type.kind) {
+        case 'primitive':
+            switch (type.name) {
+                case 'String': return '<string>';
+                case 'Int': return 0;
+                case 'Float': return 0.0;
+                case 'Bool': return false;
+                default: return '<unknown>';
+            }
+        case 'primitive_range':
+            return type.min;
+        case 'list':
+            return [typeToExample(type.element)];
+        case 'map':
+            return {};
+        case 'optional':
+            return typeToExample(type.inner);
+        case 'token_bounded':
+            return typeToExample(type.inner);
+        case 'enum':
+            return type.values.join('|');
+        case 'struct':
+            return fieldsToJsonExample(type.fields);
+        case 'domain':
+            return `<${type.name}>`;
+    }
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,11 @@
+import { createRequire } from 'node:module';
+let version;
+try {
+    const require = createRequire(import.meta.url);
+    const pkg = require('../package.json');
+    version = pkg.version;
+}
+catch {
+    version = '0.0.0-unknown';
+}
+export const VERSION = version;

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@jsleekr/graft",
+  "version": "5.7.0",
+  "description": "Graft compiler — compile .gft graph DSL to Claude Code harness structures",
+  "type": "module",
+  "license": "MIT",
+  "author": "JSLEEKR",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JSLEEKR/graft.git"
+  },
+  "keywords": ["graft", "compiler", "dsl", "llm", "claude", "graph"],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./ast": {
+      "import": "./dist/parser/ast.js",
+      "types": "./dist/parser/ast.d.ts"
+    },
+    "./compiler": {
+      "import": "./dist/compiler.js",
+      "types": "./dist/compiler.d.ts"
+    },
+    "./runtime": {
+      "import": "./dist/runtime/executor.js",
+      "types": "./dist/runtime/executor.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    },
+    "./format": {
+      "import": "./dist/format.js",
+      "types": "./dist/format.d.ts"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "graft": "./dist/index.js",
+    "graft-lsp": "./dist/lsp/server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "check": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^14.0.0",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0"
+  }
+}