sneakoscope 4.0.3 → 4.0.5

package/dist/core/providers/glm/glm-request-cache.js

@@ -0,0 +1,47 @@
+import crypto from 'node:crypto';
+import { SksLruCache } from '../../perf/lru-cache.js';
+export function createGlmEncodedRequestCache(maxEntries = 128) {
+    return new SksLruCache(maxEntries);
+}
+export function encodeGlmRequestWithCache(request, cache = defaultEncodedRequestCache) {
+    const key = digestRequestForCache(request);
+    const hit = cache.get(key);
+    if (hit)
+        return { entry: hit, cacheHit: true };
+    const body = JSON.stringify(request);
+    const entry = {
+        key,
+        bodySha256: crypto.createHash('sha256').update(body).digest('hex'),
+        byteLength: Buffer.byteLength(body),
+        createdAt: Date.now(),
+        bodyStored: false
+    };
+    cache.set(key, entry);
+    return { entry, cacheHit: false };
+}
+export function digestRequestForCache(request) {
+    const safe = {
+        model: request.model,
+        messages: request.messages,
+        tools: request.tools || null,
+        response_format: request.response_format || null,
+        provider: request.provider || null,
+        max_tokens: request.max_tokens || null,
+        temperature: request.temperature || null,
+        top_p: request.top_p || null,
+        tool_choice: request.tool_choice || null,
+        parallel_tool_calls: request.parallel_tool_calls || null,
+        reasoning: request.reasoning || null
+    };
+    return crypto.createHash('sha256').update(stableStringify(safe)).digest('hex');
+}
+function stableStringify(value) {
+    if (!value || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    const object = value;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(',')}}`;
+}
+const defaultEncodedRequestCache = createGlmEncodedRequestCache();
+//# sourceMappingURL=glm-request-cache.js.map

package/dist/core/providers/glm/glm-speed-context.js

@@ -0,0 +1,82 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { estimateGlmTokens, GLM_SPEED_CONTEXT_HARD_CAP_TOKENS, GLM_SPEED_CONTEXT_TARGET_TOKENS, trimToEstimatedTokens } from './glm-context-budget.js';
+const GENERATED_PATH = /(^|\/)(dist|node_modules|coverage|\.git)(\/|$)|(\.generated\.|\.map$)/;
+const DEFAULT_MAX_FILE_BYTES = 64 * 1024;
+export async function buildGlmSpeedContext(input) {
+    const maxTokens = Math.min(input.maxTokens || GLM_SPEED_CONTEXT_TARGET_TOKENS, GLM_SPEED_CONTEXT_HARD_CAP_TOKENS);
+    const maxFileBytes = Math.max(1024, input.maxFileBytes || DEFAULT_MAX_FILE_BYTES);
+    const sections = [];
+    const omitted = [];
+    addSection(sections, 'task', input.task);
+    addSection(sections, 'constraints', 'GLM speed mode: compact context, one-shot patch, no GPT/OpenAI fallback, no full TriWiki/proof-bank/repo dump.');
+    if (input.gitStatus)
+        addSection(sections, 'git_status', input.gitStatus);
+    if (input.lastError)
+        addSection(sections, 'error', trimToEstimatedTokens(input.lastError, 2000));
+    const readFile = input.readFile || (async () => null);
+    for (const mentioned of input.mentionedPaths || []) {
+        const normalized = mentioned.replace(/\\/g, '/');
+        if (GENERATED_PATH.test(normalized)) {
+            omitted.push({ kind: 'generated_or_large_path', path: mentioned, reason: 'speed_context_excludes_generated_or_vendor_paths' });
+            continue;
+        }
+        const absolute = path.isAbsolute(mentioned) ? mentioned : path.join(input.cwd, mentioned);
+        const rawText = input.readFileSnippet ? await input.readFileSnippet(absolute, maxFileBytes) : await readFile(absolute);
+        const text = rawText === null ? null : trimToUtf8Bytes(rawText, maxFileBytes);
+        if (text === null) {
+            omitted.push({ kind: 'file_snippet', path: mentioned, reason: 'unreadable_or_missing' });
+            continue;
+        }
+        if (Buffer.byteLength(rawText || '', 'utf8') > maxFileBytes) {
+            omitted.push({ kind: 'file_snippet_tail', path: mentioned, reason: 'speed_context_file_byte_budget' });
+        }
+        addSection(sections, 'file_snippet', trimToEstimatedTokens(text, 2400), path.relative(input.cwd, absolute) || mentioned);
+    }
+    const compact = enforceBudget(sections, omitted, maxTokens);
+    return {
+        schema: 'sks.glm-speed-context.v1',
+        digest: digestJson({ sections: compact.sections, omitted: compact.omitted }),
+        estimatedTokens: compact.sections.reduce((sum, section) => sum + section.tokenEstimate, 0),
+        sections: compact.sections,
+        omitted: compact.omitted
+    };
+}
+function addSection(sections, kind, content, sectionPath) {
+    sections.push({
+        kind,
+        ...(sectionPath ? { path: sectionPath } : {}),
+        content,
+        tokenEstimate: estimateGlmTokens(content)
+    });
+}
+function enforceBudget(sections, omitted, maxTokens) {
+    const kept = [];
+    const nextOmitted = [...omitted];
+    let total = 0;
+    for (const section of sections) {
+        if (total + section.tokenEstimate <= maxTokens) {
+            kept.push(section);
+            total += section.tokenEstimate;
+            continue;
+        }
+        nextOmitted.push({
+            kind: section.kind,
+            ...(section.path ? { path: section.path } : {}),
+            reason: 'speed_context_token_budget'
+        });
+    }
+    return { sections: kept, omitted: nextOmitted };
+}
+function digestJson(value) {
+    return crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function trimToUtf8Bytes(text, maxBytes) {
+    if (Buffer.byteLength(text, 'utf8') <= maxBytes)
+        return text;
+    let end = Math.min(text.length, maxBytes);
+    while (end > 0 && Buffer.byteLength(text.slice(0, end), 'utf8') > maxBytes)
+        end -= 1;
+    return text.slice(0, end);
+}
+//# sourceMappingURL=glm-speed-context.js.map

package/dist/core/providers/glm/glm-speed-gate.js

@@ -0,0 +1,40 @@
+import { parseGlmSpeedOutput } from './glm-speed-output-parser.js';
+const FORBIDDEN_TOUCHED_PATH = /(^|\/)(\.github|dist|node_modules)(\/|$)/;
+export function evaluateGlmSpeedGate(output) {
+    const started = Date.now();
+    const checks = [];
+    const parsed = parseGlmSpeedOutput(output);
+    checks.push(check('patch_parse', parsed.kind === 'patch', parsed.kind === 'patch' ? undefined : parsed.reason || parsed.kind));
+    const paths = parsed.kind === 'patch' ? touchedPaths(parsed.content) : [];
+    checks.push(check('touched_path_allowlist', paths.every((file) => !FORBIDDEN_TOUCHED_PATH.test(file)), paths.find((file) => FORBIDDEN_TOUCHED_PATH.test(file))));
+    checks.push(check('patch_apply_dry_run_ready', parsed.kind === 'patch' && /^diff --git /m.test(parsed.content), parsed.kind === 'patch' ? undefined : 'no_patch'));
+    const ok = checks.every((row) => row.ok);
+    return {
+        schema: 'sks.glm-speed-gate.v1',
+        ok,
+        gate_ms: Date.now() - started,
+        deterministic: true,
+        checks,
+        requiresDeepEscalation: !ok
+    };
+}
+function touchedPaths(patch) {
+    const paths = [];
+    for (const line of patch.split(/\r?\n/)) {
+        const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (match?.[1])
+            paths.push(match[1]);
+        if (match?.[2])
+            paths.push(match[2]);
+    }
+    return [...new Set(paths)];
+}
+function check(id, ok, reason) {
+    return {
+        id,
+        ok,
+        ms: 0,
+        ...(reason ? { reason } : {})
+    };
+}
+//# sourceMappingURL=glm-speed-gate.js.map

package/dist/core/providers/glm/glm-speed-output-parser.js

@@ -0,0 +1,40 @@
+const ENVELOPES = {
+    patch: ['<sks_patch>', '</sks_patch>'],
+    need_context: ['<sks_need_context>', '</sks_need_context>'],
+    blocked: ['<sks_blocked>', '</sks_blocked>']
+};
+export function parseGlmSpeedOutput(text) {
+    for (const kind of ['patch', 'need_context', 'blocked']) {
+        const extracted = extractEnvelope(text, ENVELOPES[kind][0], ENVELOPES[kind][1]);
+        if (extracted !== null) {
+            return {
+                kind,
+                content: extracted,
+                ...(kind === 'need_context' ? { paths: parsePaths(extracted) } : {}),
+                ...(kind === 'blocked' ? { reason: parseReason(extracted) } : {})
+            };
+        }
+    }
+    const cleaned = text.trim();
+    return { kind: 'malformed', content: cleaned, reason: 'missing_glm_speed_output_envelope' };
+}
+function extractEnvelope(text, start, end) {
+    const startIndex = text.indexOf(start);
+    if (startIndex < 0)
+        return null;
+    const contentStart = startIndex + start.length;
+    const endIndex = text.indexOf(end, contentStart);
+    if (endIndex < 0)
+        return null;
+    return text.slice(contentStart, endIndex).trim();
+}
+function parsePaths(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s*-\s*(.+?)\s*$/)?.[1])
+        .filter((value) => Boolean(value));
+}
+function parseReason(content) {
+    return content.match(/reason:\s*(.+)/i)?.[1]?.trim() || content.trim();
+}
+//# sourceMappingURL=glm-speed-output-parser.js.map

package/dist/core/providers/glm/glm-tool-schema-cache.js

@@ -0,0 +1,19 @@
+import crypto from 'node:crypto';
+import { SksLruCache } from '../../perf/lru-cache.js';
+export function createGlmToolSchemaCache(maxEntries = 64) {
+    const cache = new SksLruCache(maxEntries);
+    return {
+        get(toolsetVersion) {
+            return cache.get(toolsetVersion);
+        },
+        set(toolsetVersion, tools) {
+            const entry = { key: toolsetVersion, tools, createdAt: Date.now() };
+            cache.set(toolsetVersion, entry);
+            return entry;
+        }
+    };
+}
+export function digestToolset(tools) {
+    return crypto.createHash('sha256').update(JSON.stringify(tools)).digest('hex');
+}
+//# sourceMappingURL=glm-tool-schema-cache.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '4.0.3';
+export const PACKAGE_VERSION = '4.0.5';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",