@claude-flow/cli 3.60.1 → 3.61.1

package/dist/src/rure/cuda-parse.js

@@ -0,0 +1,127 @@
+/**
+ * ruRE Phase 5 — CUDA fatbin and cubin static analysis (ADR-0006). One entry point: `analyzeCuda(bytes)` decides what it was handed from
+ * the bytes (a host ELF or PE with a `.nv_fatbin` section, a standalone fatbin, a standalone cubin, or PTX text), walks the containers,
+ * decompresses what may be decompressed under the caps, and returns the inventory: architectures, PTX, kernels and what each costs.
+ * Parses, never executes; no CUDA toolkit or driver is touched.
+ */
+import { parseBinary, MAX_BINARY_BYTES } from './binary-parse.js';
+import { defaultZstd, FATBIN_MAGIC, MAX_TOTAL_BYTES, readPayload, walkFatbin } from './cuda-fatbin.js';
+import { isCubin, parseCubin } from './cuda-cubin.js';
+import { looksLikePtx, scanPtx } from './cuda-ptx.js';
+export { MAX_BINARY_BYTES };
+const FATBIN_SECTIONS = new Set(['.nv_fatbin', '.nv_fatb', '__nv_fatbin']);
+const SIGNAL_SECTION = /^(?:\.nv|__nv|\.nvFatBin)/;
+const SIGNAL_LIBRARY = /cuda|cudart|cublas|cudnn|cufft|curand|cusparse|nvrtc|nvcuda|nvml/i;
+const SIGNAL_IMPORT = /^(?:cu[A-Z]\w*|__cuda\w+|__cudaRegister\w+)$/;
+const SIGNAL_MAX = 24;
+const archOf = (n) => (n > 0 && n < 1000 ? `sm_${n}` : null);
+const kindName = (k) => (k === 1 ? 'ptx' : k === 2 ? 'cubin' : 'unknown');
+const empty = (source) => ({ source, hostSection: null, hostSignals: [], containers: 0, entries: [], cubinArchs: [], ptxArchs: [], kernels: [], ptx: [], warnings: [], truncated: false });
+/** Reads the entries of one or more fatbin containers found in b[start, end) and fills `info`. */
+function readFatbin(b, start, end, info, opts) {
+    const zstd = opts.zstd === undefined ? defaultZstd : opts.zstd;
+    const budget = { left: MAX_TOTAL_BYTES };
+    const walked = walkFatbin(b, start, end, info.warnings);
+    info.containers = walked.containers;
+    info.truncated = info.truncated || walked.truncated;
+    if (walked.containers === 0)
+        info.warnings.push('no fatbin container (magic 0xBA55ED50) at the start of the section');
+    for (const raw of walked.entries)
+        info.entries.push(readEntry(b, raw, zstd, budget, info, opts));
+    const archs = (kind) => [...new Set(info.entries.filter(e => e.kind === kind && e.arch !== null).map(e => e.arch))].sort();
+    info.cubinArchs = archs('cubin');
+    info.ptxArchs = archs('ptx');
+}
+function readEntry(b, raw, zstd, budget, info, opts) {
+    const kind = kindName(raw.kind);
+    const payload = readPayload(b, raw, zstd, budget);
+    const arch = archOf(raw.archNumber);
+    const entry = {
+        index: raw.index,
+        container: raw.container,
+        kind,
+        rawKind: raw.kind,
+        arch,
+        version: `0x${raw.version.toString(16)}`,
+        flags: `0x${raw.flags.toString(16)}`,
+        compressed: payload.compressed,
+        storedBytes: raw.compressedSize > 0 ? raw.compressedSize : raw.payloadLength,
+        size: payload.data === null ? null : payload.data.length,
+        read: payload.data !== null,
+        ...(payload.note !== undefined && { note: payload.note }),
+        ...(raw.objNameOffset !== 0 || raw.objNameLen !== 0 ? { objName: { offset: raw.objNameOffset, length: raw.objNameLen } } : {}),
+    };
+    if (payload.data === null)
+        return entry;
+    if (kind === 'cubin') {
+        if (!isCubin(payload.data)) {
+            entry.read = false;
+            entry.note = 'a cubin entry whose payload is not a CUDA ELF: not read';
+            return entry;
+        }
+        const cubin = parseCubin(payload.data);
+        info.warnings.push(...cubin.warnings.map(w => `entry ${raw.index}: ${w}`));
+        info.truncated = info.truncated || cubin.truncated;
+        if (arch !== null && cubin.archFlag !== null && cubin.archFlag !== 0 && cubin.archFlag !== raw.archNumber) {
+            info.warnings.push(`entry ${raw.index}: the entry header says ${arch}, the cubin's e_flags say sm_${cubin.archFlag}`);
+        }
+        for (const k of cubin.kernels)
+            info.kernels.push({ ...k, entry: raw.index, arch });
+    }
+    else if (kind === 'ptx') {
+        const text = payload.data.toString('latin1').replace(/\0+$/, '');
+        info.ptx.push({ ...scanPtx(text, opts.includePtx === true), entry: raw.index });
+    }
+    return entry;
+}
+/** Names in a host binary that say it is a CUDA program (never anything but its own names; nothing is loaded). */
+function hostSignalsOf(host) {
+    const out = [
+        ...host.sections.map(s => s.name).filter(n => SIGNAL_SECTION.test(n)),
+        ...host.libraries.filter(n => SIGNAL_LIBRARY.test(n)),
+        ...host.imports.filter(n => SIGNAL_IMPORT.test(n)).slice(0, 12),
+    ];
+    return [...new Set(out)].slice(0, SIGNAL_MAX);
+}
+/** What the bytes are and what is in them. Never throws on hostile input: a failure is a warning. */
+export function analyzeCuda(b, opts = {}) {
+    if (b.length >= 4 && b.readUInt32LE(0) === FATBIN_MAGIC) {
+        const info = empty('fatbin');
+        readFatbin(b, 0, b.length, info, opts);
+        return info;
+    }
+    if (isCubin(b)) {
+        const info = empty('cubin');
+        const cubin = parseCubin(b);
+        const arch = cubin.archFlag === null ? null : archOf(cubin.archFlag);
+        info.warnings.push(...cubin.warnings);
+        info.truncated = cubin.truncated;
+        info.kernels = cubin.kernels.map(k => ({ ...k, entry: null, arch }));
+        info.cubinArchs = arch === null ? [] : [arch];
+        return info;
+    }
+    if (looksLikePtx(b)) {
+        const info = empty('ptx');
+        const ptx = scanPtx(b.toString('latin1'), opts.includePtx === true);
+        info.ptx = [{ ...ptx, entry: null }];
+        info.ptxArchs = ptx.target === null ? [] : [ptx.target];
+        return info;
+    }
+    const info = empty('host');
+    const host = parseBinary(b);
+    info.warnings.push(...host.warnings);
+    info.hostSignals = hostSignalsOf(host);
+    const section = host.sections.find(s => FATBIN_SECTIONS.has(s.name));
+    if (section === undefined) {
+        info.warnings.push(`no .nv_fatbin section: this does not look like a CUDA program (format ${host.format})`);
+        return info;
+    }
+    info.hostSection = { name: section.name, offset: section.offset, size: section.size };
+    if (section.offset < 0 || section.size <= 0 || section.offset + section.size > b.length) {
+        info.warnings.push('the .nv_fatbin section runs past the file: not read');
+        return info;
+    }
+    readFatbin(b, section.offset, section.offset + section.size, info, opts);
+    return info;
+}
+//# sourceMappingURL=cuda-parse.js.map

package/dist/src/rure/cuda-ptx.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ruRE Phase 5 — PTX text (ADR-0006): NVIDIA's virtual ISA. Only a bounded scan for the header directives and the kernel and function
+ * names; the text is never interpreted further and never run. The scan reads at most 4 MiB, and every pattern is linear.
+ */
+export declare const MAX_PTX_SCAN: number;
+export declare const MAX_PTX_TEXT: number;
+export interface PtxInfo {
+    version: string | null;
+    target: string | null;
+    addressSize: number | null;
+    /** `.entry` kernels with the number of `.param` declarations in their signature. */
+    entries: {
+        name: string;
+        params: number;
+    }[];
+    /** `.func` device functions. */
+    functions: string[];
+    /** The text itself, only when asked for, cut at MAX_PTX_TEXT. */
+    text?: string;
+    textTruncated?: boolean;
+    scanTruncated: boolean;
+}
+/**
+ * True when the bytes look like PTX source: the first directive is `.version` after comments and blank space. A hand-written scan, not a
+ * regex: a lazy comment pattern inside a repeated group backtracks exponentially on `/*` followed by many `*` + `/` pairs (CodeQL js/redos
+ * caught the first version of this). Every step here moves forward, so the cost is linear in the 8 KiB it looks at.
+ */
+export declare function looksLikePtx(b: Buffer): boolean;
+export declare function scanPtx(text: string, includeText: boolean): PtxInfo;
+//# sourceMappingURL=cuda-ptx.d.ts.map

package/dist/src/rure/cuda-ptx.js

@@ -0,0 +1,67 @@
+/**
+ * ruRE Phase 5 — PTX text (ADR-0006): NVIDIA's virtual ISA. Only a bounded scan for the header directives and the kernel and function
+ * names; the text is never interpreted further and never run. The scan reads at most 4 MiB, and every pattern is linear.
+ */
+export const MAX_PTX_SCAN = 4 * 1024 * 1024;
+export const MAX_PTX_TEXT = 64 * 1024;
+const MAX_NAMES = 500;
+const NAME_MAX = 200;
+/**
+ * True when the bytes look like PTX source: the first directive is `.version` after comments and blank space. A hand-written scan, not a
+ * regex: a lazy comment pattern inside a repeated group backtracks exponentially on `/*` followed by many `*` + `/` pairs (CodeQL js/redos
+ * caught the first version of this). Every step here moves forward, so the cost is linear in the 8 KiB it looks at.
+ */
+export function looksLikePtx(b) {
+    const head = b.toString('latin1', 0, Math.min(b.length, 8192));
+    let i = 0;
+    for (;;) {
+        while (i < head.length && (head.charCodeAt(i) <= 32 || head.charCodeAt(i) === 0xa0))
+            i += 1;
+        if (head.startsWith('//', i)) {
+            const end = head.indexOf('\n', i);
+            if (end < 0)
+                return false;
+            i = end + 1;
+        }
+        else if (head.startsWith('/*', i)) {
+            const end = head.indexOf('*/', i + 2);
+            if (end < 0)
+                return false;
+            i = end + 2;
+        }
+        else
+            break;
+    }
+    return /^\.version\s+\d/.test(head.slice(i, i + 32));
+}
+export function scanPtx(text, includeText) {
+    const scanned = text.length > MAX_PTX_SCAN ? text.slice(0, MAX_PTX_SCAN) : text;
+    const info = {
+        // Space and tab only, never `\s`, at a line start: `\s` also matches newlines, so every line start inside a run of blank lines rescanned the
+        // rest of the run (80000 blank lines took 4.6 s and 320000 took 71 s before this).
+        version: /^[ \t]*\.version[ \t]+(\d+\.\d+)/m.exec(scanned)?.[1] ?? null,
+        target: /^[ \t]*\.target[ \t]+([A-Za-z0-9_., ]{1,60}?)[ \t]*(?:\/\/|$)/m.exec(scanned)?.[1]?.trim() ?? null,
+        addressSize: Number(/^[ \t]*\.address_size[ \t]+(\d+)/m.exec(scanned)?.[1] ?? NaN) || null,
+        entries: [],
+        functions: [],
+        scanTruncated: text.length > MAX_PTX_SCAN,
+    };
+    const re = /\.(entry|func)\s{1,64}(?:\([^)]{0,200}\)\s{0,64})?([A-Za-z_$%][\w$.%]{0,198})\s{0,64}\(/g;
+    let m;
+    while ((m = re.exec(scanned)) !== null && info.entries.length + info.functions.length < MAX_NAMES) {
+        const name = m[2].slice(0, NAME_MAX);
+        if (m[1] === 'func') {
+            info.functions.push(name);
+            continue;
+        }
+        const close = scanned.indexOf(')', re.lastIndex);
+        const signature = scanned.slice(re.lastIndex, close < 0 || close - re.lastIndex > 4096 ? re.lastIndex + 4096 : close);
+        info.entries.push({ name, params: (signature.match(/\.param\b/g) ?? []).length });
+    }
+    if (includeText) {
+        info.text = scanned.length > MAX_PTX_TEXT ? scanned.slice(0, MAX_PTX_TEXT) : scanned;
+        info.textTruncated = scanned.length > MAX_PTX_TEXT;
+    }
+    return info;
+}
+//# sourceMappingURL=cuda-ptx.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.60.1",
+  "version": "3.61.1",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",