weaver-work-cli 0.1.8 → 0.1.20

package/dist/core/output.js

@@ -1,11 +1,238 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
+import { pruneRefs, writeRef } from './refs.js';
 export function writeRawJson(outputPath, value) {
     const absolutePath = resolve(outputPath);
     mkdirSync(dirname(absolutePath), { recursive: true });
     writeFileSync(absolutePath, JSON.stringify(value, null, 2), 'utf-8');
     return absolutePath;
 }
+/** 宿主实测约 24-32 KB 后会把 stdout 截断成约 2048 B 预览，取保守值。 */
+export const DEFAULT_RESULT_THRESHOLD_BYTES = 24 * 1024;
+/** 比 continuation 的 10 分钟更长：读结果往往要跨多步任务。 */
+export const DEFAULT_REF_TTL_MS = 30 * 60_000;
+export const DEFAULT_REF_MAX_COUNT = 50;
+export const DEFAULT_REF_MAX_BYTES = 200 * 1024 * 1024;
+const COMPACT_TIERS = [
+    { array: 10, string: 200 },
+    { array: 5, string: 80 },
+    { array: 2, string: 40 },
+    { array: 1, string: 20 },
+];
+function numberFromEnv(name) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim() === '')
+        return undefined;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function configValue(ctx, key) {
+    const io = ctx.config.get('io');
+    if (io && typeof io === 'object' && !Array.isArray(io)) {
+        const holder = io;
+        if (key in holder)
+            return holder[key];
+    }
+    return ctx.config.get(key);
+}
+function numeric(ctx, envName, configKey, fallback) {
+    const fromEnv = numberFromEnv(envName);
+    if (fromEnv !== undefined)
+        return fromEnv;
+    const fromConfig = configValue(ctx, configKey);
+    if (typeof fromConfig === 'number' && Number.isFinite(fromConfig))
+        return fromConfig;
+    return fallback;
+}
+export function resultThresholdBytes(ctx) {
+    const value = numeric(ctx, 'WEAVER_WORK_CLI_REF_THRESHOLD', 'resultThreshold', DEFAULT_RESULT_THRESHOLD_BYTES);
+    return value === 0 || value >= 2 * 1024 ? Math.floor(value) : DEFAULT_RESULT_THRESHOLD_BYTES;
+}
+export function refTtlMs(ctx) {
+    const value = numeric(ctx, 'WEAVER_WORK_CLI_REF_TTL_MS', 'refTtlMs', DEFAULT_REF_TTL_MS);
+    return value >= 1 ? Math.floor(value) : DEFAULT_REF_TTL_MS;
+}
+export function refMaxCount(ctx) {
+    const value = numeric(ctx, 'WEAVER_WORK_CLI_REF_MAX_COUNT', 'refMaxCount', DEFAULT_REF_MAX_COUNT);
+    return value >= 1 ? Math.floor(value) : DEFAULT_REF_MAX_COUNT;
+}
+export function refMaxBytes(ctx) {
+    const value = numeric(ctx, 'WEAVER_WORK_CLI_REF_MAX_BYTES', 'refMaxBytes', DEFAULT_REF_MAX_BYTES);
+    return value >= 1 ? Math.floor(value) : DEFAULT_REF_MAX_BYTES;
+}
+export function bytesOf(value) {
+    return Buffer.byteLength(JSON.stringify(value ?? null, null, 2), 'utf8');
+}
+function compactValue(value, arrayLimit, stringLimit, depth = 0) {
+    if (depth > 6)
+        return '<omitted: too deep>';
+    if (typeof value === 'string') {
+        return value.length > stringLimit
+            ? `${value.slice(0, stringLimit)}…(truncated ${value.length - stringLimit} chars)`
+            : value;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, arrayLimit).map((item) => compactValue(item, arrayLimit, stringLimit, depth + 1));
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [key, inner] of Object.entries(value)) {
+            out[key] = compactValue(inner, arrayLimit, stringLimit, depth + 1);
+        }
+        return out;
+    }
+    return value;
+}
+/** 逐档收紧，尽量让精简版本身也落在 stdout 预算内。 */
+export function compactForStdout(value, budgetBytes) {
+    let current = value;
+    for (const tier of COMPACT_TIERS) {
+        current = compactValue(value, tier.array, tier.string);
+        if (bytesOf(current) <= budgetBytes)
+            return current;
+    }
+    return current;
+}
+/**
+ * 保留判别字段（ok / operation / schemaVersion / error 等），压缩其余字段。
+ *
+ * 不能只压 `data`：像 `invoice schema` 这类命令的 envelope 没有 data 键，
+ * 大字段是 `operations` / `withheldOperations`，只压 data 等于没压。
+ */
+export function compactRecord(value, budgetBytes, keepKeys) {
+    let current = value;
+    for (const tier of COMPACT_TIERS) {
+        const out = {};
+        for (const [key, inner] of Object.entries(value)) {
+            out[key] = keepKeys.includes(key) ? inner : compactValue(inner, tier.array, tier.string);
+        }
+        current = out;
+        if (bytesOf(out) <= budgetBytes)
+            return out;
+    }
+    return current;
+}
+/** 兜底：逐档压缩后仍超预算时，只留判别字段与占位符，保证指针必然落在前 2048 B 内。 */
+export function skeletonOf(value, keepKeys, hasRef = true) {
+    const out = {};
+    const recoveryHint = hasRef ? 'use --input-ref' : 'result unavailable';
+    for (const [key, inner] of Object.entries(value)) {
+        if (keepKeys.includes(key)) {
+            out[key] = key === 'error' ? compactError(inner) : inner;
+        }
+        else if (Array.isArray(inner)) {
+            out[key] = `<omitted: ${inner.length} items, ${recoveryHint}>`;
+        }
+        else if (inner && typeof inner === 'object') {
+            out[key] = `<omitted: ${Object.keys(inner).length} keys, ${recoveryHint}>`;
+        }
+        else if (typeof inner === 'string') {
+            out[key] = inner.length > 160 ? `${inner.slice(0, 160)}…(truncated)` : inner;
+        }
+        else {
+            out[key] = inner;
+        }
+    }
+    return out;
+}
+/** 判别成败所必需的字段，压缩时原样保留。 */
+export const ENVELOPE_KEEP_KEYS = [
+    'schemaVersion',
+    'ok',
+    'operation',
+    'status',
+    'error',
+];
+/** 错误可能带很大的 details；精简时保留分类和可执行的错误信息。 */
+function compactError(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const error = value;
+    const out = {};
+    for (const key of ['type', 'subtype', 'code', 'retryable', 'stage']) {
+        if (error[key] !== undefined)
+            out[key] = error[key];
+    }
+    if (typeof error.message === 'string') {
+        out.message = error.message.length > 240 ? `${error.message.slice(0, 240)}…(truncated)` : error.message;
+    }
+    if (error.details !== undefined)
+        out.details = '<omitted: see the error subtype and message>';
+    return out;
+}
+function operationOf(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const operation = value.operation;
+        if (typeof operation === 'string')
+            return operation;
+    }
+    return undefined;
+}
+function warningsOf(value) {
+    const warnings = value.warnings;
+    return Array.isArray(warnings) ? warnings : [];
+}
+/**
+ * 引用信息必须排在 JSON 前面，保证被宿主预览截断时仍能看到 refId。
+ */
+function withLeadingMeta(value, leading, body, extraWarnings) {
+    const base = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : { data: value };
+    const reserved = new Set([...Object.keys(leading), 'warnings']);
+    const safeBody = Object.fromEntries(Object.entries(body).filter(([key]) => !reserved.has(key)));
+    const compactWarnings = Object.prototype.hasOwnProperty.call(body, 'warnings')
+        ? (Array.isArray(body.warnings) ? body.warnings : [body.warnings])
+        : warningsOf(base);
+    return {
+        ...leading,
+        ...safeBody,
+        warnings: [...compactWarnings, ...extraWarnings],
+    };
+}
+function slimmedBody(value, threshold, hasRef) {
+    const base = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : { data: value };
+    const compacted = compactRecord(base, threshold, ENVELOPE_KEEP_KEYS);
+    if (bytesOf(compacted) <= threshold)
+        return compacted;
+    return skeletonOf(base, ENVELOPE_KEEP_KEYS, hasRef);
+}
+function fitEnvelope(value, leading, extraWarnings, budgetBytes) {
+    const hasRef = leading.resultPersisted === true;
+    const body = slimmedBody(value, budgetBytes, hasRef);
+    let envelope = withLeadingMeta(value, leading, body, extraWarnings);
+    if (bytesOf(envelope) <= budgetBytes)
+        return envelope;
+    const base = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : { data: value };
+    envelope = withLeadingMeta(value, leading, skeletonOf(base, ENVELOPE_KEEP_KEYS, leading.resultPersisted === true), extraWarnings);
+    if (bytesOf(envelope) <= budgetBytes)
+        return envelope;
+    const persisted = leading.resultPersisted === true;
+    const refId = String(leading.refId ?? '').slice(0, 80);
+    return {
+        ...(persisted ? { refId } : {}),
+        resultPersisted: persisted,
+        outputBytes: Number(leading.outputBytes) || 0,
+        largeOutputNotice: persisted
+            ? `结果已精简，使用 --input-ref ${refId} 读取。`
+            : '结果无法暂存；stdout 仅保留精简内容，完整结果不可恢复。',
+        previewTruncated: true,
+        schemaVersion: typeof base.schemaVersion === 'number' || typeof base.schemaVersion === 'string'
+            ? String(base.schemaVersion).slice(0, 20)
+            : 1,
+        ok: typeof base.ok === 'boolean' ? base.ok : true,
+        ...(typeof base.operation === 'string' ? { operation: base.operation.slice(0, 80) } : {}),
+        ...(base.error === undefined ? {} : { error: compactError(base.error) }),
+        data: persisted
+            ? '<omitted: use --input-ref>'
+            : '<omitted: full result unavailable>',
+        warnings: [...extraWarnings, 'stdout_compacted'],
+    };
+}
 export class Output {
     ctx;
     constructor(ctx) {
@@ -13,11 +240,79 @@ export class Output {
     }
     write(value, options = {}) {
         const globalOptions = this.ctx.getGlobalOptions();
-        if (globalOptions.json || options.json || !options.text) {
-            console.log(JSON.stringify(value, null, 2));
+        const useJson = globalOptions.json || options.json || !options.text;
+        if (!useJson) {
+            console.log(options.text);
             return;
         }
-        console.log(options.text);
+        console.log(JSON.stringify(this.prepare(value, options), null, 2));
+    }
+    prepare(value, options) {
+        const threshold = resultThresholdBytes(this.ctx);
+        if (options.persist === false || threshold <= 0)
+            return value;
+        const finalBudget = Math.max(1024, threshold - 1024);
+        const bytes = bytesOf(value);
+        if (bytes <= threshold)
+            return value;
+        const limits = { maxCount: refMaxCount(this.ctx), maxBytes: refMaxBytes(this.ctx) };
+        const warnings = [];
+        try {
+            try {
+                pruneRefs(this.ctx, limits);
+            }
+            catch {
+                warnings.push('ref_gc_failed');
+            }
+            const meta = writeRef(this.ctx, { value, operation: operationOf(value), ttlMs: refTtlMs(this.ctx) });
+            let retention;
+            try {
+                retention = pruneRefs(this.ctx, { ...limits, preserveRefIds: [meta.refId] });
+            }
+            catch {
+                warnings.push('ref_gc_failed');
+            }
+            if (retention?.overLimit)
+                warnings.push('ref_store_over_limit');
+            if (retention?.cleanupIncomplete)
+                warnings.push('ref_gc_incomplete');
+            return fitEnvelope(value, this.leadingFor(meta, bytes, retention), warnings, finalBudget);
+        }
+        catch (error) {
+            // 落盘失败绝不静默截断：标注 degraded，让调用方知道这份结果不完整。
+            const code = error && typeof error === 'object' && 'code' in error
+                ? String(error.code)
+                : '';
+            const message = code === 'ENOSPC'
+                ? '磁盘空间不足'
+                : code === 'EACCES' || code === 'EPERM'
+                    ? 'CLI 暂存目录无写入权限'
+                    : '无法写入 CLI 暂存目录';
+            process.stderr.write(`[weaver-work-cli] 结果 ${bytes} 字节超过 stdout 预算 ${threshold} 字节且落盘失败，输出已精简：${message}\n`);
+            return fitEnvelope(value, {
+                outputBytes: bytes,
+                resultPersisted: false,
+                largeOutputNotice: `结果超过 stdout 限制且无法暂存；当前内容已精简，可能不完整：${message.slice(0, 160)}`,
+            }, ['result_persist_failed'], finalBudget);
+        }
+    }
+    leadingFor(meta, bytes, retention) {
+        const retentionNotice = retention?.cleanupIncomplete
+            ? ' 部分旧引用暂时无法删除，CLI 会在后续命令重试。'
+            : retention?.overLimit
+                ? ' 本结果超过暂存容量上限，已保留本次结果并淘汰旧结果。'
+                : '';
+        return {
+            refId: meta.refId,
+            resultPersisted: true,
+            outputBytes: bytes,
+            sha256: meta.sha256,
+            expiresAt: meta.expiresAt,
+            previewTruncated: true,
+            largeOutputNotice: `结果 ${bytes} 字节已暂存。使用 --input-ref ${meta.refId} 引用；`
+                + `取单个字段时加 --pick-as <字段名>。`
+                + retentionNotice,
+        };
     }
     raw(message) {
         console.log(message);