peaks-loop 4.0.15 → 4.0.16

package/dist/services/lint/detect-eslint.d.ts

@@ -0,0 +1,10 @@
+import { ESLINT_PACKAGE_PINS } from './eslint-runner.js';
+export type EslintDetectState = 'ready' | 'eslint-missing' | 'config-error' | 'npx-failed' | 'detection-failed';
+export type EslintDetectResult = {
+    readonly state: EslintDetectState;
+    readonly npxAvailable: boolean;
+    readonly pinnedVersions: typeof ESLINT_PACKAGE_PINS;
+    readonly warnings: readonly string[];
+    readonly nextActions: readonly string[];
+};
+export declare function detectEslint(): EslintDetectResult;

package/dist/services/lint/detect-eslint.js

@@ -0,0 +1,59 @@
+/**
+ * 5-state ESLint detect — soft-fail when the toolchain is missing.
+ * Mirrors the ECC bridge detect shape so peaks-rd can compose a
+ * unified Gate B5 verdict.
+ */
+import { spawnSync } from 'node:child_process';
+import { ESLINT_PACKAGE_PINS } from './eslint-runner.js';
+const PACKAGES_TO_PROBE = [
+    'eslint',
+    'typescriptEslintParser',
+    'typescriptEslintPlugin',
+    'importPlugin'
+];
+function packageNameFor(key) {
+    switch (key) {
+        case 'eslint': return 'eslint';
+        case 'typescriptEslintParser': return '@typescript-eslint/parser';
+        case 'typescriptEslintPlugin': return '@typescript-eslint/eslint-plugin';
+        case 'importPlugin': return 'eslint-plugin-import';
+    }
+}
+function probeNpx() {
+    const probe = spawnSync('npx', ['--version'], { encoding: 'utf8' });
+    return probe.status === 0;
+}
+function probePackage(key) {
+    const pkg = packageNameFor(key);
+    const pin = ESLINT_PACKAGE_PINS[key];
+    const result = spawnSync('npm', ['view', `${pkg}@${pin}`, 'version'], { encoding: 'utf8' });
+    return result.status === 0;
+}
+export function detectEslint() {
+    const nextActions = [];
+    const warnings = [];
+    if (!probeNpx()) {
+        return {
+            state: 'npx-failed',
+            npxAvailable: false,
+            pinnedVersions: ESLINT_PACKAGE_PINS,
+            warnings: ['npx is not on PATH'],
+            nextActions: ['Install Node.js ≥ 20 with npm to enable `npx --package`.', 'Or run `peaks code lint --no-npx` (future slice).']
+        };
+    }
+    for (const key of PACKAGES_TO_PROBE) {
+        if (!probePackage(key)) {
+            warnings.push(`npm registry cannot resolve ${packageNameFor(key)}@${ESLINT_PACKAGE_PINS[key]}`);
+        }
+    }
+    if (warnings.length > 0) {
+        nextActions.push('Re-run `peaks code lint --json` after npm connectivity is restored.');
+    }
+    return {
+        state: 'ready',
+        npxAvailable: true,
+        pinnedVersions: ESLINT_PACKAGE_PINS,
+        warnings,
+        nextActions
+    };
+}

package/dist/services/lint/detect-ocr-18.d.ts

@@ -0,0 +1,10 @@
+import { OCR_18_PACKAGE } from './ocr-multilang-adapter.js';
+export type Ocr18DetectState = 'ready' | 'ocr18-missing' | 'binary-missing' | 'llm-config-missing' | 'detection-failed';
+export type Ocr18DetectResult = {
+    readonly state: Ocr18DetectState;
+    readonly npxAvailable: boolean;
+    readonly package: typeof OCR_18_PACKAGE;
+    readonly warnings: readonly string[];
+    readonly nextActions: readonly string[];
+};
+export declare function detectOcr18(): Ocr18DetectResult;

package/dist/services/lint/detect-ocr-18.js

@@ -0,0 +1,40 @@
+/**
+ * 5-state OCR 1.8.x detect. Mirrors the ECC detect shape.
+ */
+import { spawnSync } from 'node:child_process';
+import { OCR_18_PACKAGE } from './ocr-multilang-adapter.js';
+function probeNpx() {
+    const probe = spawnSync('npx', ['--version'], { encoding: 'utf8' });
+    return probe.status === 0;
+}
+function probeOcr18() {
+    const result = spawnSync('npx', ['--package', OCR_18_PACKAGE, '--', 'ocr', 'version'], { encoding: 'utf8' });
+    return result.status === 0;
+}
+export function detectOcr18() {
+    if (!probeNpx()) {
+        return {
+            state: 'ocr18-missing',
+            npxAvailable: false,
+            package: OCR_18_PACKAGE,
+            warnings: ['npx is not on PATH'],
+            nextActions: ['Install Node.js ≥ 20 with npm to enable `npx --package`.']
+        };
+    }
+    if (!probeOcr18()) {
+        return {
+            state: 'ocr18-missing',
+            npxAvailable: true,
+            package: OCR_18_PACKAGE,
+            warnings: [`could not resolve ${OCR_18_PACKAGE}`],
+            nextActions: ['Run `npm i @alibaba-group/open-code-review@1.8.9` to install the reviewer.']
+        };
+    }
+    return {
+        state: 'ready',
+        npxAvailable: true,
+        package: OCR_18_PACKAGE,
+        warnings: [],
+        nextActions: []
+    };
+}

package/dist/services/lint/eslint-runner.d.ts

@@ -0,0 +1,58 @@
+export declare const ESLINT_PACKAGE_PINS: {
+    readonly eslint: "10.8.0";
+    readonly typescriptEslintParser: "8.66.0";
+    readonly typescriptEslintPlugin: "8.66.0";
+    readonly importPlugin: "2.32.0";
+};
+export type RedLineMode = 'none' | 'baseline-aware';
+export type EslintState = 'ok' | 'eslint-missing' | 'npx-failed' | 'execution-failed' | 'baseline-missing';
+export type EslintFinding = {
+    readonly filePath: string;
+    readonly line: number;
+    readonly column: number;
+    readonly ruleId: string | null;
+    readonly severity: 'error' | 'warn' | 'info';
+    readonly message: string;
+};
+export type EslintSummary = {
+    readonly error: number;
+    readonly warn: number;
+    readonly info: number;
+};
+export type BaselineViolation = {
+    readonly ruleId: string;
+    readonly file: string;
+    readonly line: number;
+    readonly severity: 'error' | 'warn' | 'info';
+    readonly message: string;
+};
+export type RedLineEntry = {
+    readonly ruleId: string;
+    readonly count: number;
+    readonly topFiles: ReadonlyArray<{
+        readonly file: string;
+        readonly count: number;
+    }>;
+};
+export type EslintRunResult = {
+    readonly state: EslintState;
+    readonly findings: readonly EslintFinding[];
+    readonly summary: EslintSummary;
+    readonly durationMs: number;
+    readonly rawOutput: string;
+    readonly baselineWaived: readonly EslintFinding[];
+    readonly redLine: readonly RedLineEntry[];
+};
+export type EslintRunOptions = {
+    readonly cwd: string;
+    readonly scope?: string;
+    readonly configPath?: string;
+    readonly fix?: boolean;
+    readonly write?: boolean;
+    readonly timeoutMs?: number;
+    readonly diffOnly?: boolean;
+    readonly baselineFile?: string;
+    readonly redLineMode?: RedLineMode;
+};
+export declare function buildEslintArgs(options: EslintRunOptions): string[];
+export declare function runEslint(options: EslintRunOptions): EslintRunResult;

package/dist/services/lint/eslint-runner.js

@@ -0,0 +1,307 @@
+/**
+ * ESLint runner — read-only verifier for peaks code lint.
+ * Pins the 4 toolchain packages to the same major versions
+ * `config/eslint/.peaks-rules.cjs` requires; the runner loads them
+ * via `npx --package` so peaks-loop devDeps do not grow. Per the
+ * G-lint-2 red line, --fix / --write are FORBIDDEN.
+ *
+ * PRD-002b slice: three new options enforce the
+ * incremental-first / no-touch-stockcode / project-aware baseline
+ * invariants:
+ *
+ *   - diffOnly (default true): filter findings to git-diff hunks;
+ *    存量违规 silently skipped. Enforces D4 + D5.
+ *   - baselineFile (default '.peaks/lint/baseline.json'): waiver
+ *     matching findings (ruleId + file + line). Enforces D5.
+ *   - redLineMode (default 'baseline-aware'): aggregate baseline
+ *     violations by ruleId so the envelope carries an LLM-readable
+ *     red-line. Enforces D6 + supplementary S2.
+ */
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const ESLINT_PACKAGE_PINS = {
+    eslint: '10.8.0',
+    typescriptEslintParser: '8.66.0',
+    typescriptEslintPlugin: '8.66.0',
+    importPlugin: '2.32.0'
+};
+function severityFor(value) {
+    if (value === 2)
+        return 'error';
+    if (value === 1)
+        return 'warn';
+    return 'info';
+}
+function summarize(findings) {
+    let error = 0;
+    let warn = 0;
+    let info = 0;
+    for (const f of findings) {
+        if (f.severity === 'error')
+            error++;
+        else if (f.severity === 'warn')
+            warn++;
+        else
+            info++;
+    }
+    return { error, warn, info };
+}
+/**
+ * Read `git diff HEAD --unified=0` and parse every `+` line as a
+ * touched line number. Falls back to [] on any parse error so the
+ * caller treats all findings as out-of-diff (no silent zero-result).
+ */
+function loadDiffRanges(cwd) {
+    const ranges = [];
+    try {
+        const result = spawnSync('git', ['diff', 'HEAD', '--unified=0', '--no-color'], {
+            cwd,
+            encoding: 'utf8',
+            maxBuffer: 16 * 1024 * 1024
+        });
+        if (result.status !== 0 || typeof result.stdout !== 'string')
+            return [];
+        const stdout = result.stdout;
+        let currentFile = null;
+        let currentLine = 0;
+        for (const raw of stdout.split('\n')) {
+            const line = raw;
+            if (line.startsWith('+++ ')) {
+                const path = line.slice(4).split('\t')[0] ?? '';
+                currentFile = path.startsWith('b/') ? path.slice(2) : path;
+                continue;
+            }
+            if (line.startsWith('--- ')) {
+                continue;
+            }
+            const hunk = /^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@/.exec(line);
+            if (hunk !== null) {
+                currentLine = Number.parseInt(hunk[1] ?? '0', 10);
+                continue;
+            }
+            if (currentFile !== null && line.startsWith('+') && !line.startsWith('+++')) {
+                if (Number.isFinite(currentLine) && currentLine > 0) {
+                    ranges.push({ file: currentFile, lines: [currentLine] });
+                }
+                currentLine += 1;
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return ranges;
+}
+function inDiff(filePath, line, ranges) {
+    if (ranges.length === 0)
+        return false;
+    for (const r of ranges) {
+        if (r.file !== filePath)
+            continue;
+        for (const ln of r.lines) {
+            if (Math.abs(ln - line) <= 0)
+                return true;
+        }
+    }
+    return false;
+}
+function loadBaseline(cwd, baselineFile) {
+    const fullPath = join(cwd, baselineFile);
+    let raw;
+    try {
+        raw = readFileSync(fullPath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const violations = Array.isArray(parsed.violations) ? parsed.violations : [];
+    const out = [];
+    for (const v of violations) {
+        if (typeof v.ruleId !== 'string' || typeof v.file !== 'string' || typeof v.line !== 'number')
+            continue;
+        out.push({
+            ruleId: v.ruleId,
+            file: v.file,
+            line: v.line,
+            severity: severityFor(v.severity),
+            message: typeof v.message === 'string' ? v.message : ''
+        });
+    }
+    return out;
+}
+function matchBaseline(finding, baseline) {
+    for (const v of baseline) {
+        if (v.ruleId !== finding.ruleId)
+            continue;
+        if (v.file !== finding.filePath)
+            continue;
+        if (v.line !== finding.line)
+            continue;
+        return true;
+    }
+    return false;
+}
+function aggregateRedLine(baseline) {
+    const byRule = new Map();
+    for (const v of baseline) {
+        const existing = byRule.get(v.ruleId);
+        if (existing === undefined) {
+            const fileCounts = new Map();
+            fileCounts.set(v.file, 1);
+            byRule.set(v.ruleId, { count: 1, fileCounts });
+        }
+        else {
+            existing.count += 1;
+            existing.fileCounts.set(v.file, (existing.fileCounts.get(v.file) ?? 0) + 1);
+        }
+    }
+    const out = [];
+    for (const [ruleId, agg] of byRule.entries()) {
+        const topFiles = [...agg.fileCounts.entries()]
+            .map(([file, count]) => ({ file, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 5);
+        out.push({ ruleId, count: agg.count, topFiles });
+    }
+    out.sort((a, b) => b.count - a.count);
+    return out;
+}
+const EMPTY_DIFF_RANGE = [];
+const EMPTY_REDLINE = [];
+function emptyResult(state, start, rawOutput) {
+    return {
+        state,
+        findings: [],
+        summary: { error: 0, warn: 0, info: 0 },
+        durationMs: Date.now() - start,
+        rawOutput,
+        baselineWaived: [],
+        redLine: EMPTY_REDLINE
+    };
+}
+export function buildEslintArgs(options) {
+    if (options.fix === true || options.write === true) {
+        throw Object.assign(new Error('peaks code lint is read-only; --fix and --write are forbidden'), {
+            code: 'LINT_FIX_FORBIDDEN'
+        });
+    }
+    const args = [
+        '--package', `eslint@${ESLINT_PACKAGE_PINS.eslint}`,
+        '--package', `@typescript-eslint/parser@${ESLINT_PACKAGE_PINS.typescriptEslintParser}`,
+        '--package', `@typescript-eslint/eslint-plugin@${ESLINT_PACKAGE_PINS.typescriptEslintPlugin}`,
+        '--package', `eslint-plugin-import@${ESLINT_PACKAGE_PINS.importPlugin}`,
+        '--', 'eslint', '--no-warn-ignored', '--format', 'json'
+    ];
+    if (options.configPath !== undefined) {
+        args.push('--config', options.configPath);
+    }
+    args.push(...(options.scope !== undefined && options.scope.length > 0 ? [options.scope] : ['.']));
+    return args;
+}
+export function runEslint(options) {
+    const start = Date.now();
+    let args;
+    try {
+        args = buildEslintArgs(options);
+    }
+    catch (error) {
+        return emptyResult('execution-failed', start, error instanceof Error ? error.message : String(error));
+    }
+    const spawnOptions = {
+        cwd: options.cwd,
+        encoding: 'utf8',
+        timeout: options.timeoutMs ?? 60_000,
+        maxBuffer: 32 * 1024 * 1024
+    };
+    const result = spawnSync('npx', args, spawnOptions);
+    if (result.error !== undefined && result.error !== null) {
+        const message = result.error.message;
+        const state = /ENOENT/.test(message) ? 'npx-failed' : 'execution-failed';
+        return emptyResult(state, start, typeof result.stdout === 'string' ? result.stdout : '');
+    }
+    if (result.signal !== null && result.signal !== undefined) {
+        return emptyResult('execution-failed', start, typeof result.stdout === 'string' ? result.stdout : '');
+    }
+    const stdout = typeof result.stdout === 'string' ? result.stdout : '';
+    let findings = [];
+    if (stdout.trim().length > 0) {
+        try {
+            const parsed = JSON.parse(stdout);
+            for (const entry of parsed) {
+                if (typeof entry !== 'object' || entry === null)
+                    continue;
+                const parentFile = typeof entry.filePath === 'string'
+                    ? entry.filePath
+                    : '';
+                const messages = Array.isArray(entry.messages)
+                    ? entry.messages
+                    : [];
+                for (const m of messages) {
+                    if (m === null || typeof m !== 'object')
+                        continue;
+                    findings.push({
+                        filePath: typeof m.filePath === 'string' && m.filePath.length > 0 ? m.filePath : parentFile,
+                        line: typeof m.line === 'number' ? m.line : 0,
+                        column: typeof m.column === 'number' ? m.column : 0,
+                        ruleId: typeof m.ruleId === 'string' ? m.ruleId : null,
+                        severity: severityFor(m.severity),
+                        message: typeof m.message === 'string' ? m.message : ''
+                    });
+                }
+            }
+        }
+        catch {
+            return emptyResult('execution-failed', start, stdout);
+        }
+    }
+    if (result.status !== 0 && findings.length === 0) {
+        return emptyResult('eslint-missing', start, typeof result.stderr === 'string' ? result.stderr : stdout);
+    }
+    // PRD-002b slice: incremental-first / no-touch-stockcode filters.
+    // PRD-002b D6: baselineFile is project-level; if missing we surface
+    // state='baseline-missing' so the caller can re-run `peaks lint baseline`.
+    const diffOnly = options.diffOnly !== false;
+    const redLineMode = options.redLineMode ?? 'baseline-aware';
+    const baselinePath = options.baselineFile ?? '.peaks/lint/baseline.json';
+    const baseline = loadBaseline(options.cwd, baselinePath);
+    const diffRanges = diffOnly ? loadDiffRanges(options.cwd) : EMPTY_DIFF_RANGE;
+    let activeFindings = findings;
+    let waived = [];
+    if (diffOnly) {
+        activeFindings = findings.filter((f) => inDiff(f.filePath, f.line, diffRanges));
+    }
+    if (baseline.length > 0) {
+        const next = [];
+        waived = [];
+        for (const f of activeFindings) {
+            if (matchBaseline(f, baseline)) {
+                waived.push(f);
+            }
+            else {
+                next.push(f);
+            }
+        }
+        activeFindings = next;
+    }
+    const redLine = redLineMode === 'baseline-aware' ? aggregateRedLine(baseline) : EMPTY_REDLINE;
+    const finalState = baseline.length === 0 && diffOnly && options.baselineFile !== undefined
+        ? 'baseline-missing'
+        : 'ok';
+    return {
+        state: finalState,
+        findings: activeFindings,
+        summary: summarize(activeFindings),
+        durationMs: Date.now() - start,
+        rawOutput: stdout,
+        baselineWaived: waived,
+        redLine
+    };
+}

package/dist/services/lint/ocr-multilang-adapter.d.ts

@@ -0,0 +1,34 @@
+export declare const OCR_18_PACKAGE = "@alibaba-group/open-code-review@1.8.9";
+export declare const OCR_18_LANGUAGES: readonly ["python", "go", "java", "rust", "cpp", "csharp", "ruby", "php"];
+export type Ocr18Language = (typeof OCR_18_LANGUAGES)[number];
+export type Ocr18State = 'ok' | 'ocr18-missing' | 'binary-missing' | 'llm-config-missing' | 'execution-failed' | 'language-unsupported';
+export type Ocr18Finding = {
+    readonly filePath: string;
+    readonly line: number;
+    readonly ruleId: string | null;
+    readonly severity: 'error' | 'warn' | 'info';
+    readonly message: string;
+};
+export type Ocr18Summary = {
+    readonly total: number;
+    readonly bySeverity: Readonly<Record<'error' | 'warn' | 'info', number>>;
+    readonly byLanguage: Readonly<Record<Ocr18Language, number>>;
+};
+export type Ocr18RunResult = {
+    readonly state: Ocr18State;
+    readonly findings: readonly Ocr18Finding[];
+    readonly summary: Ocr18Summary | null;
+    readonly durationMs: number;
+    readonly rawOutput: string;
+};
+export type Ocr18RunOptions = {
+    readonly cwd: string;
+    readonly language: string;
+    readonly from?: string;
+    readonly to?: string;
+    readonly commit?: string;
+    readonly delegate?: boolean;
+    readonly timeoutMs?: number;
+};
+export declare function buildOcr18Args(options: Ocr18RunOptions): string[];
+export declare function runOcr18(options: Ocr18RunOptions): Ocr18RunResult;

package/dist/services/lint/ocr-multilang-adapter.js

@@ -0,0 +1,143 @@
+/**
+ * OCR 1.8.x multi-language reviewer adapter. Routes one of the
+ * 8 supported languages to the corresponding `ocr review` filter.
+ */
+import { spawnSync } from 'node:child_process';
+export const OCR_18_PACKAGE = '@alibaba-group/open-code-review@1.8.9';
+export const OCR_18_LANGUAGES = [
+    'python',
+    'go',
+    'java',
+    'rust',
+    'cpp',
+    'csharp',
+    'ruby',
+    'php'
+];
+function isSupportedLanguage(value) {
+    return OCR_18_LANGUAGES.includes(value);
+}
+function severityFor(value) {
+    if (value === 'error' || value === 'critical' || value === 2)
+        return 'error';
+    if (value === 'warn' || value === 'warning' || value === 1)
+        return 'warn';
+    return 'info';
+}
+function emptyByLanguage() {
+    const out = {};
+    for (const lang of OCR_18_LANGUAGES) {
+        out[lang] = 0;
+    }
+    return out;
+}
+export function buildOcr18Args(options) {
+    if (!isSupportedLanguage(options.language)) {
+        throw Object.assign(new Error(`unsupported language: ${options.language}`), { code: 'LANGUAGE_UNSUPPORTED' });
+    }
+    const args = [
+        '--package', OCR_18_PACKAGE,
+        '--', 'ocr'
+    ];
+    if (options.delegate === true) {
+        args.push('delegate', 'preview');
+        if (options.from !== undefined)
+            args.push('--from', options.from);
+        if (options.to !== undefined)
+            args.push('--to', options.to);
+        if (options.commit !== undefined)
+            args.push('--commit', options.commit);
+    }
+    else {
+        args.push('review', '--filter-language', options.language);
+        if (options.from !== undefined)
+            args.push('--from', options.from);
+        if (options.to !== undefined)
+            args.push('--to', options.to);
+        if (options.commit !== undefined)
+            args.push('--commit', options.commit);
+        args.push('--format', 'json');
+    }
+    return args;
+}
+export function runOcr18(options) {
+    const start = Date.now();
+    if (!isSupportedLanguage(options.language)) {
+        return {
+            state: 'language-unsupported',
+            findings: [],
+            summary: null,
+            durationMs: Date.now() - start,
+            rawOutput: `unsupported language: ${options.language}`
+        };
+    }
+    const args = buildOcr18Args(options);
+    const spawnOptions = {
+        cwd: options.cwd,
+        encoding: 'utf8',
+        timeout: options.timeoutMs ?? 60_000,
+        maxBuffer: 32 * 1024 * 1024
+    };
+    const result = spawnSync('npx', args, spawnOptions);
+    const stdout = typeof result.stdout === 'string' ? result.stdout : '';
+    const stderr = typeof result.stderr === 'string' ? result.stderr : '';
+    if (result.error !== undefined && result.error !== null) {
+        return {
+            state: 'ocr18-missing',
+            findings: [],
+            summary: null,
+            durationMs: Date.now() - start,
+            rawOutput: stderr || stdout
+        };
+    }
+    if (result.status !== 0) {
+        return {
+            state: 'execution-failed',
+            findings: [],
+            summary: null,
+            durationMs: Date.now() - start,
+            rawOutput: stderr || stdout
+        };
+    }
+    let findings = [];
+    if (stdout.trim().length > 0) {
+        try {
+            const parsed = JSON.parse(stdout);
+            if (Array.isArray(parsed.findings)) {
+                for (const entry of parsed.findings) {
+                    if (entry === null || typeof entry !== 'object')
+                        continue;
+                    const f = entry;
+                    findings.push({
+                        filePath: typeof f.file === 'string' ? f.file : '',
+                        line: typeof f.line === 'number' ? f.line : 0,
+                        ruleId: typeof f.rule === 'string' ? f.rule : null,
+                        severity: severityFor(f.severity),
+                        message: typeof f.message === 'string' ? f.message : ''
+                    });
+                }
+            }
+        }
+        catch {
+            return {
+                state: 'execution-failed',
+                findings: [],
+                summary: null,
+                durationMs: Date.now() - start,
+                rawOutput: stderr || stdout
+            };
+        }
+    }
+    const bySeverity = { error: 0, warn: 0, info: 0 };
+    for (const f of findings)
+        bySeverity[f.severity]++;
+    const byLanguageMut = { ...emptyByLanguage() };
+    byLanguageMut[options.language] = findings.length;
+    return {
+        state: 'ok',
+        findings,
+        summary: { total: findings.length, bySeverity, byLanguage: byLanguageMut },
+        durationMs: Date.now() - start,
+        rawOutput: stdout
+    };
+}