@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.1

package/dist/skills/bundled/remember.js

@@ -1,383 +0,0 @@
-/**
- * `pugi remember` — proposal-first memory curator.
- *
- * Bundled skill, batch 1 (backlog). Today `pugi memory write` (and
- * the auto-extractor that fires from MEMORY: markers in chat) writes
- * silently — operators occasionally find unwanted facts persisted with
- * no chance to veto. This skill flips the surface: it inspects recent
- * memory candidates, classifies each as project / personal / temp, and
- * presents EVERY proposed write to the operator BEFORE persisting.
- * Nothing is queued or sent to the admin-api until the operator
- * approves it.
- *
- * # Three classification buckets
- *
- *  - project  — codebase / ADR / architecture / convention.
- *                Targets `kind` = `architecture` | `pattern` | `bug`.
- *  - personal — operator-specific preference, workflow, identity.
- *                Targets `kind` = `preference` | `workflow` | `fact`.
- *  - temp     — short-lived note, scheduled for `forgetAfter`.
- *                Pugi heuristic: anything that looks transient
- *                (timestamps, log paste, single-session note).
- *
- * # Surface
- *
- * Two flows:
- *
- *  1. **Auto-classify** an inline list of candidate strings (CLI args
- *     or `--input <path>`). For each one Pugi emits a structured
- *     proposal. Operator answers `y`/`n`/`s` (yes / no / skip) per
- *     proposal. `y` enqueues via the existing `enqueueMemoryOp` API.
- *
- *  2. **Review queue** (`pugi remember review`) — walks any pending
- *     memory queue lines and lets the operator drop entries before
- *     `pugi memory sync` ships them.
- *
- * # Opt-in
- *
- * `pugi memory write …` keeps its current behaviour (immediate enqueue,
- * no prompt). The proposal-first mode requires either:
- *
- *  - explicit `pugi remember <text>...` invocation, OR
- *  - `pugi memory write --curate` flag (added in this batch; the
- *    curator runs in proposal-first mode).
- *
- * # Provenance
- *
- * Inspired by the the upstream tool bundled-skills pattern (intel from
- * leak-research memos, independent implementation TS). No upstream code reused.
- */
-import { readFileSync } from 'node:fs';
-import { PERSONA_MEMORY_KINDS, enqueueMemoryOp, } from '../../core/memory-sync/queue.js';
-const DEFAULT_PERSONA = 'pugi';
-function parseFlags(args) {
-    const flags = {
-        json: false,
-        personaSlug: DEFAULT_PERSONA,
-        inputPath: null,
-    };
-    const positionals = [];
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === undefined)
-            continue;
-        if (arg === '--json') {
-            flags.json = true;
-            continue;
-        }
-        if (arg === '--persona') {
-            const next = args[i + 1];
-            if (next === undefined)
-                return { flags, positionals, error: '--persona requires a value' };
-            flags.personaSlug = next;
-            i += 1;
-            continue;
-        }
-        if (arg === '--input') {
-            const next = args[i + 1];
-            if (next === undefined)
-                return { flags, positionals, error: '--input requires a path' };
-            flags.inputPath = next;
-            i += 1;
-            continue;
-        }
-        if (arg === '--help' || arg === '-h') {
-            return { flags, positionals, error: 'help' };
-        }
-        if (arg.startsWith('--')) {
-            return { flags, positionals, error: `unknown flag: ${arg}` };
-        }
-        positionals.push(arg);
-    }
-    return { flags, positionals, error: null };
-}
-/**
- * Single-line classifier. The signal is intentionally crude (regex +
- * keyword bags) so the behaviour is deterministic and explainable —
- * the operator approves each proposal anyway. Edge cases land in
- * `personal` by default because a stray project fact persisting under
- * the operator's profile is less corrosive than a stray personal note
- * leaking into a project's memory.
- *
- * Public for direct test coverage.
- */
-export function classifyMemoryCandidate(raw, now) {
-    const trimmed = raw.trim();
-    if (trimmed === '')
-        return null;
-    if (trimmed.length > 4000)
-        return null;
-    const lower = trimmed.toLowerCase();
-    const projectSignals = [
-        /\badr-?\d+\b/,
-        /\bmigration\b/,
-        /\bschema\b/,
-        /\bendpoint\b/,
-        /\barchitecture\b/,
-        /\bconvention\b/,
-        /\bbug\b/,
-        /\bbroken\b/,
-        /\bpattern\b/,
-        /\bworkspace\b/,
-        /\bpackage\b/,
-        /\bmodule\b/,
-    ];
-    const personalSignals = [
-        /\bi (prefer|like|hate|always|never)\b/,
-        /\bmy (workflow|setup|laptop|terminal|editor)\b/,
-        /\bin russian\b/,
-        /\bin ukrainian\b/,
-        /\bdo not ask\b/,
-        /\bdon't ask\b/,
-    ];
-    const tempSignals = [
-        /\btoday\b/,
-        /\btomorrow\b/,
-        /\bnow\b/,
-        /\btemporary\b/,
-        /\bfor now\b/,
-        /\bremind me\b/,
-        /\bthis session\b/,
-    ];
-    const matchedProject = projectSignals.some((rx) => rx.test(lower));
-    const matchedPersonal = personalSignals.some((rx) => rx.test(lower));
-    const matchedTemp = tempSignals.some((rx) => rx.test(lower));
-    let bucket;
-    let rationale;
-    let kind;
-    let forgetAfter;
-    if (matchedTemp) {
-        bucket = 'temp';
-        rationale = 'looks transient (timing keyword)';
-        kind = 'fact';
-        forgetAfter = new Date(now.getTime() + 24 * 60 * 60 * 1000).toISOString();
-    }
-    else if (matchedProject && !matchedPersonal) {
-        bucket = 'project';
-        rationale = 'codebase / architecture keyword present';
-        if (/\bbug\b|\bbroken\b/.test(lower)) {
-            kind = 'bug';
-        }
-        else if (/\bpattern\b/.test(lower)) {
-            kind = 'pattern';
-        }
-        else {
-            kind = 'architecture';
-        }
-        forgetAfter = null;
-    }
-    else if (matchedPersonal && !matchedProject) {
-        bucket = 'personal';
-        rationale = 'operator preference / workflow keyword present';
-        if (/\bworkflow\b|\bsetup\b/.test(lower)) {
-            kind = 'workflow';
-        }
-        else if (/prefer|like|hate|always|never/.test(lower)) {
-            kind = 'preference';
-        }
-        else {
-            kind = 'fact';
-        }
-        forgetAfter = null;
-    }
-    else if (matchedProject && matchedPersonal) {
-        bucket = 'personal';
-        rationale = 'mixed signals; defaulting to personal (safer)';
-        kind = 'preference';
-        forgetAfter = null;
-    }
-    else {
-        bucket = 'personal';
-        rationale = 'no strong signal; defaulting to personal';
-        kind = 'fact';
-        forgetAfter = null;
-    }
-    return {
-        bucket,
-        personaSlug: DEFAULT_PERSONA,
-        kind,
-        content: trimmed,
-        forgetAfter,
-        rationale,
-    };
-}
-/**
- * Default decide hook — reject everything. Encodes the safety invariant
- * that NOTHING is written when the runtime forgets to pass a real
- * approval gate. Tests assert this behaviour explicitly.
- */
-async function defaultDecide() {
-    return 'reject';
-}
-/**
- * Default persistence sink — append to the on-disk pending-write queue
- * via the existing `enqueueMemoryOp` API. `pugi memory sync` is what
- * actually ships these to the admin-api; the curator only enqueues.
- */
-async function defaultPersist(proposal) {
-    enqueueMemoryOp({
-        op: 'write',
-        personaSlug: proposal.personaSlug,
-        kind: proposal.kind,
-        content: proposal.content,
-        forgetAfter: proposal.forgetAfter,
-    });
-}
-function loadCandidates(positionals, inputPath) {
-    const inline = positionals.length > 0 ? [positionals.join(' ')] : [];
-    if (inputPath === null)
-        return inline;
-    try {
-        const raw = readFileSync(inputPath, 'utf8');
-        const lines = raw
-            .split('\n')
-            .map((l) => l.trim())
-            .filter((l) => l !== '' && !l.startsWith('#'));
-        return [...inline, ...lines];
-    }
-    catch {
-        return inline;
-    }
-}
-function renderHumanReport(result) {
-    const lines = [];
-    lines.push(`pugi remember — proposal-first memory curator`);
-    lines.push(`proposals: ${result.proposals.length} accepted: ${result.accepted} rejected: ${result.rejected} skipped: ${result.skipped}`);
-    if (result.decisions.length === 0) {
-        lines.push('');
-        lines.push('No proposals to review.');
-        return lines.join('\n');
-    }
-    for (const entry of result.decisions) {
-        const tag = entry.decision === 'accept' ? '[ACCEPTED]' : entry.decision === 'reject' ? '[REJECTED]' : '[SKIPPED]';
-        lines.push('');
-        lines.push(`${tag} (${entry.proposal.bucket} / ${entry.proposal.kind})`);
-        lines.push(` ${entry.proposal.content}`);
-        lines.push(` rationale: ${entry.proposal.rationale}`);
-        if (entry.proposal.forgetAfter !== null) {
-            lines.push(` forget-after: ${entry.proposal.forgetAfter}`);
-        }
-    }
-    return lines.join('\n');
-}
-export async function runRememberCommand(args, ctx) {
-    const { flags, positionals, error } = parseFlags(args);
-    if (error === 'help') {
-        ctx.writeOutput({ ok: true, command: 'remember', usage: REMEMBER_USAGE }, REMEMBER_USAGE);
-        return {
-            proposals: [],
-            decisions: [],
-            accepted: 0,
-            rejected: 0,
-            skipped: 0,
-            exitCode: 0,
-        };
-    }
-    if (error !== null) {
-        ctx.writeOutput({ ok: false, command: 'remember', error }, `pugi remember: ${error}`);
-        return {
-            proposals: [],
-            decisions: [],
-            accepted: 0,
-            rejected: 0,
-            skipped: 0,
-            exitCode: 2,
-        };
-    }
-    const candidates = loadCandidates(positionals, flags.inputPath);
-    const proposals = [];
-    for (const cand of candidates) {
-        const proposal = classifyMemoryCandidate(cand, ctx.now());
-        if (proposal === null)
-            continue;
-        // Carry the operator-overridden persona slug through. The classifier
-        // hard-codes the default so callers can swap it here without
-        // touching the heuristic.
-        proposals.push({ ...proposal, personaSlug: flags.personaSlug });
-    }
-    // Guard rail: the schema enum is the source of truth for kinds. If
-    // anyone widens the classifier without widening PERSONA_MEMORY_KINDS,
-    // we surface that drift instead of writing an unknown kind to disk.
-    for (const proposal of proposals) {
-        if (!PERSONA_MEMORY_KINDS.includes(proposal.kind)) {
-            ctx.writeOutput({
-                ok: false,
-                command: 'remember',
-                error: `internal: classifier produced unknown kind '${proposal.kind}'`,
-            }, `pugi remember: internal classifier drift on '${proposal.kind}'.`);
-            return {
-                proposals,
-                decisions: [],
-                accepted: 0,
-                rejected: 0,
-                skipped: 0,
-                exitCode: 2,
-            };
-        }
-    }
-    const decide = ctx.decide ?? defaultDecide;
-    const persist = ctx.persist ?? defaultPersist;
-    const decisions = [];
-    let accepted = 0;
-    let rejected = 0;
-    let skipped = 0;
-    for (const proposal of proposals) {
-        const decision = await decide(proposal);
-        decisions.push({ proposal, decision });
-        if (decision === 'accept') {
-            try {
-                await persist(proposal);
-                accepted += 1;
-            }
-            catch (err) {
-                // Backlog: the memory-queue secret scanner can refuse a
-                // persist call even after operator approval (defense-in-depth).
-                // Surface the rejection as a `reject` outcome so the operator
-                // sees what was blocked without crashing the curator loop.
-                const message = err instanceof Error ? err.message : String(err);
-                ctx.writeOutput({
-                    ok: false,
-                    command: 'remember',
-                    error: 'persist_blocked',
-                    proposal,
-                    message,
-                }, `pugi remember: persist blocked — ${message}`);
-                decisions[decisions.length - 1] = { proposal, decision: 'reject' };
-                rejected += 1;
-            }
-        }
-        else if (decision === 'reject') {
-            rejected += 1;
-        }
-        else {
-            skipped += 1;
-        }
-    }
-    const result = {
-        proposals,
-        decisions,
-        accepted,
-        rejected,
-        skipped,
-        exitCode: 0,
-    };
-    ctx.writeOutput({ ok: true, command: 'remember', result }, renderHumanReport(result));
-    return result;
-}
-const REMEMBER_USAGE = [
-    'pugi remember — proposal-first memory curator.',
-    '',
-    'Usage:',
-    ' pugi remember [--json] [--persona <slug>] [--input <path>] <text>...',
-    '',
-    'Flags:',
-    ' --json                Emit a JSON envelope instead of human text.',
-    ' --persona <slug>      Persona slug to attribute the memory to (default: pugi).',
-    ' --input <path>        Read newline-separated candidates from a file.',
-    '',
-    'Every proposal is shown to the operator BEFORE persisting; nothing is',
-    'written without explicit approval. Unlike `pugi memory write` (silent),',
-    'this surface is curate-first and exists to keep automatic memory drift',
-    'in check.',
-].join('\n');
-//# sourceMappingURL=remember.js.map

package/dist/skills/bundled/simplify.js

@@ -1,289 +0,0 @@
-/**
- * `pugi simplify` — local 3-agent parallel code review + auto-fix loop.
- *
- * Bundled skill, batch 1 (backlog). Distinct from `/triple-review`,
- * which is the pre-push consensus gate; `simplify` is the inner-loop
- * companion that examines the current `git diff` from three orthogonal
- * dimensions (reuse, quality, efficiency), aggregates findings, and
- * hands the merged review to `pugi fix` so the operator does not need
- * to scroll through three separate reports + paste suggestions back
- * into the engine by hand.
- *
- * # Three review dimensions
- *
- *  1. reuse     — does the diff duplicate logic that already exists in
- *                  the codebase? Prefer extraction + import over copy.
- *  2. quality   — does the diff respect Pugi conventions: strict TS,
- *                  no `any`, naming, error handling, test coverage?
- *  3. efficiency — does the diff introduce avoidable allocations, sync
- *                  I/O in hot paths, or N+1 patterns?
- *
- * # Flow
- *
- *  1. Capture `git diff` against the configured base ref (default
- *     `origin/main`).
- *  2. Fan out to three parallel review prompts. Each prompt is sent
- *     through the provided `reviewerInvoker` injection point — the
- *     real CLI wires this to `pugi fix --review-only --persona <slug>`,
- *     tests inject a stub.
- *  3. Collect findings. Each finding carries a dimension tag + severity
- *     ([P1] / [P2] / [P3]) + free-form text.
- *  4. Optionally hand the aggregated findings to `pugi fix` to apply
- *     fixes automatically. `--review-only` skips the fix step and just
- *     prints the merged report.
- *
- * # Non-goals
- *
- *  - **Not** a pre-push gate. Use `/triple-review` for that — it spans
- *    three model families across paid OAuth subscriptions and is the
- *    production-grade gate.
- *  - **Not** a new dispatcher. The fix step delegates to the existing
- *    `pugi fix` engine task; this skill only shapes inputs + outputs.
- *
- * # Provenance
- *
- * Inspired by the the upstream tool bundled-skills pattern (intel from
- * leak-research memos, independent implementation TS). No upstream code reused.
- */
-import { execFileSync } from 'node:child_process';
-const DEFAULT_BASE_REF = 'origin/main';
-function parseFlags(args) {
-    const flags = {
-        json: false,
-        reviewOnly: false,
-        baseRef: DEFAULT_BASE_REF,
-        sequential: false,
-    };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === undefined)
-            continue;
-        if (arg === '--json') {
-            flags.json = true;
-            continue;
-        }
-        if (arg === '--review-only') {
-            flags.reviewOnly = true;
-            continue;
-        }
-        if (arg === '--sequential') {
-            flags.sequential = true;
-            continue;
-        }
-        if (arg === '--base') {
-            const next = args[i + 1];
-            if (next === undefined)
-                return { flags, error: '--base requires a ref' };
-            flags.baseRef = next;
-            i += 1;
-            continue;
-        }
-        if (arg === '--help' || arg === '-h') {
-            return { flags, error: 'help' };
-        }
-        return { flags, error: `unknown argument: ${arg}` };
-    }
-    return { flags, error: null };
-}
-/**
- * Default `git diff` capture. Lives separate from the runner so tests
- * can stub by injecting `captureDiff`.
- */
-export function defaultCaptureDiff(baseRef, cwd) {
-    try {
-        return execFileSync('git', ['diff', `${baseRef}...HEAD`, '--unified=3'], {
-            cwd,
-            encoding: 'utf8',
-            maxBuffer: 32 * 1024 * 1024,
-            timeout: 10_000,
-        });
-    }
-    catch {
-        return '';
-    }
-}
-const DIMENSION_PROMPTS = {
-    reuse: [
-        'You are reviewing a git diff for code reuse opportunities.',
-        'For every block that duplicates existing utilities in the workspace,',
-        'or that re-implements a helper that should be extracted, emit a',
-        'finding line. Format each finding as:',
-        ' [P1|P2|P3] <relative/path>: <one-sentence summary>',
-        'Severity rubric:',
-        ' P1 — clear duplicate of an in-repo helper.',
-        ' P2 — copy-paste of a similar block that should be extracted.',
-        ' P3 — opportunity worth noting but not blocking.',
-    ].join('\n'),
-    quality: [
-        'You are reviewing a git diff for code quality vs. Pugi conventions:',
-        'strict TypeScript (no `any`, no `// @ts-ignore`), explicit error handling,',
-        'naming consistency, test coverage for new code paths.',
-        'For every violation, emit:',
-        ' [P1|P2|P3] <relative/path>: <one-sentence summary>',
-        'Severity rubric:',
-        ' P1 — strict-mode violation or missing critical error path.',
-        ' P2 — convention drift (naming, return shape, missing test).',
-        ' P3 — style nit worth surfacing.',
-    ].join('\n'),
-    efficiency: [
-        'You are reviewing a git diff for runtime efficiency.',
-        'Flag avoidable allocations, sync I/O in hot paths, N+1 query patterns,',
-        'unbounded recursion, or accidental quadratic loops.',
-        'For every issue, emit:',
-        ' [P1|P2|P3] <relative/path>: <one-sentence summary>',
-        'Severity rubric:',
-        ' P1 — algorithmic regression or sync I/O in a hot loop.',
-        ' P2 — avoidable allocation or per-row query.',
-        ' P3 — minor optimisation worth tracking.',
-    ].join('\n'),
-};
-const FINDING_LINE = /^\[(P1|P2|P3)\]\s+([^:]+):\s+(.+)$/;
-/**
- * Parse a free-form reviewer response into structured findings. Lines
- * that don't match the expected `[P1] file: summary` shape are ignored
- * so a reviewer can emit free-form commentary alongside its findings
- * without polluting the aggregator. Exposed for test coverage of the
- * grammar.
- */
-export function parseReviewerFindings(dimension, raw) {
-    const findings = [];
-    for (const line of raw.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith('[P'))
-            continue;
-        const match = FINDING_LINE.exec(trimmed);
-        if (match === null)
-            continue;
-        const [, severity, file, summary] = match;
-        if (severity === undefined || file === undefined || summary === undefined)
-            continue;
-        findings.push({
-            dimension,
-            severity: severity,
-            file: file.trim() === '-' ? null : file.trim(),
-            summary: summary.trim(),
-        });
-    }
-    return findings;
-}
-/**
- * Run the three dimensions in parallel (or sequentially when
- * `--sequential` is set) and aggregate. The aggregator is the only
- * piece of "real" work in this skill; everything else is plumbing.
- */
-export async function aggregateReviewerResults(diff, baseRef, invoker, options = { sequential: false }) {
-    const dimensions = ['reuse', 'quality', 'efficiency'];
-    const runOne = async (dimension) => {
-        const prompt = DIMENSION_PROMPTS[dimension];
-        const raw = await invoker({ dimension, prompt, diff, baseRef });
-        const findings = parseReviewerFindings(dimension, raw);
-        return { dimension, findings, raw };
-    };
-    const results = [];
-    if (options.sequential) {
-        for (const dim of dimensions) {
-            results.push(await runOne(dim));
-        }
-    }
-    else {
-        const settled = await Promise.all(dimensions.map(runOne));
-        results.push(...settled);
-    }
-    const flat = [];
-    const summary = { P1: 0, P2: 0, P3: 0 };
-    for (const r of results) {
-        for (const f of r.findings) {
-            flat.push(f);
-            summary[f.severity] += 1;
-        }
-    }
-    return {
-        diffBytes: Buffer.byteLength(diff, 'utf8'),
-        baseRef,
-        dimensions: results,
-        findings: flat,
-        summaryBySeverity: summary,
-    };
-}
-function renderHumanReport(report, applied) {
-    const lines = [];
-    lines.push(`pugi simplify — 3-agent review @ base=${report.baseRef}`);
-    lines.push(`diff: ${report.diffBytes} bytes`);
-    lines.push(`findings: P1=${report.summaryBySeverity.P1} P2=${report.summaryBySeverity.P2} P3=${report.summaryBySeverity.P3}`);
-    lines.push('');
-    for (const reviewer of report.dimensions) {
-        lines.push(`-- ${reviewer.dimension} (${reviewer.findings.length} findings) --`);
-        if (reviewer.findings.length === 0) {
-            lines.push(' (clean)');
-        }
-        else {
-            for (const finding of reviewer.findings) {
-                lines.push(` [${finding.severity}] ${finding.file ?? '-'}: ${finding.summary}`);
-            }
-        }
-    }
-    if (applied !== null) {
-        lines.push('');
-        lines.push(`pugi fix: applied=${applied.applied} skipped=${applied.skipped}`);
-    }
-    return lines.join('\n');
-}
-export async function runSimplifyCommand(args, ctx) {
-    const { flags, error } = parseFlags(args);
-    if (error === 'help') {
-        ctx.writeOutput({ ok: true, command: 'simplify', usage: SIMPLIFY_USAGE }, SIMPLIFY_USAGE);
-        return {
-            report: emptyReport(flags.baseRef),
-            applied: null,
-            exitCode: 0,
-        };
-    }
-    if (error !== null) {
-        ctx.writeOutput({ ok: false, command: 'simplify', error }, `pugi simplify: ${error}`);
-        return { report: emptyReport(flags.baseRef), applied: null, exitCode: 2 };
-    }
-    const capture = ctx.captureDiff ?? defaultCaptureDiff;
-    const diff = capture(flags.baseRef, ctx.cwd);
-    if (diff.trim() === '') {
-        const empty = emptyReport(flags.baseRef);
-        ctx.writeOutput({
-            ok: true,
-            command: 'simplify',
-            report: empty,
-            note: `No diff against ${flags.baseRef}.`,
-        }, `pugi simplify: no diff against ${flags.baseRef}. Nothing to review.`);
-        return { report: empty, applied: null, exitCode: 0 };
-    }
-    const report = await aggregateReviewerResults(diff, flags.baseRef, ctx.reviewerInvoker, { sequential: flags.sequential });
-    let applied = null;
-    if (!flags.reviewOnly && ctx.fixer !== undefined && report.findings.length > 0) {
-        applied = await ctx.fixer(report.findings);
-    }
-    ctx.writeOutput({ ok: true, command: 'simplify', report, applied }, renderHumanReport(report, applied));
-    const exitCode = report.findings.length === 0 ? 0 : 1;
-    return { report, applied, exitCode };
-}
-function emptyReport(baseRef) {
-    return {
-        diffBytes: 0,
-        baseRef,
-        dimensions: [],
-        findings: [],
-        summaryBySeverity: { P1: 0, P2: 0, P3: 0 },
-    };
-}
-const SIMPLIFY_USAGE = [
-    'pugi simplify — local 3-agent diff review (reuse / quality / efficiency).',
-    '',
-    'Usage:',
-    ' pugi simplify [--json] [--review-only] [--sequential] [--base <ref>]',
-    '',
-    'Flags:',
-    ' --json            Emit a JSON envelope instead of human text.',
-    ' --review-only     Skip the auto-fix step; print the merged report only.',
-    ' --sequential      Run the three reviewers in series (low-quota mode).',
-    ' --base <ref>      Diff base ref (default: origin/main).',
-    '',
-    'Not a pre-push gate — for that, use /triple-review.',
-].join('\n');
-//# sourceMappingURL=simplify.js.map