ygl-trees 0.77.3 → 0.79.1

package/dist/packages/research/pipeline/src/predict.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Prediction backtest pipeline (spec: pred-val/backtest-pipeline).
+ *
+ * Predictions are claims whose text starts with `[预测·<horizon>]` and contains
+ * a deadline (`YYYY-MM-DD 前`) plus one or more criteria separated by ` 或 `.
+ * The audit parses those locally-measurable criteria, measures the current
+ * actual from the workspace DB (or a fast registry probe for npm counts), and
+ * reports hit / miss / pending / manual — it NEVER auto-resolves; resolution
+ * stays a human arbitration (frozen contract).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrediction = parsePrediction;
+exports.loadStateSource = loadStateSource;
+exports.measureCriterion = measureCriterion;
+exports.measureNpmVersions = measureNpmVersions;
+exports.auditPredictions = auditPredictions;
+/** Extract `[预测·X]` horizon + deadline. Explicit `YYYY-MM-DD 前` wins;
+ *  otherwise derive from claim creation date + horizon days (7天/90天). */
+function parsePrediction(text, created) {
+    const h = text.match(/\[预测·([^\]]+)\]/);
+    const horizon = h ? h[1] : "";
+    const d = text.match(/(\d{4}-\d{2}-\d{2})\s*前/);
+    if (d)
+        return { horizon, deadline: d[1] };
+    const days = horizon.match(/(\d+)\s*天/);
+    if (days && created) {
+        const t = Date.parse(created.replace(" ", "T"));
+        if (!Number.isNaN(t)) {
+            return { horizon, deadline: new Date(t + +days[1] * 86400000).toISOString().slice(0, 10) };
+        }
+    }
+    return { horizon, deadline: "" };
+}
+/** 0.79.1 --state bridge: load a flat counter map from a JSON file path or an
+ *  http(s) URL (e.g. a DSH API endpoint). Nested objects flatten to dot keys
+ *  ({counts:{y:12}} → "counts.y"); only finite numbers are kept. Null on any
+ *  failure — the audit degrades those criteria back to manual. */
+async function loadStateSource(src, fetchImpl = fetch) {
+    try {
+        let text;
+        if (/^https?:\/\//.test(src)) {
+            const ctl = new AbortController();
+            const t = setTimeout(() => ctl.abort(), 3000);
+            const r = await fetchImpl(src, { signal: ctl.signal });
+            clearTimeout(t);
+            if (!r.ok)
+                return null;
+            text = await r.text();
+        }
+        else {
+            text = require("node:fs").readFileSync(src, "utf8");
+        }
+        const flat = {};
+        const walk = (obj, prefix) => {
+            if (!obj || typeof obj !== "object")
+                return;
+            for (const [k, v] of Object.entries(obj)) {
+                const key = prefix ? `${prefix}.${k}` : k;
+                if (typeof v === "number" && Number.isFinite(v))
+                    flat[key] = v;
+                else if (v && typeof v === "object" && !Array.isArray(v))
+                    walk(v, key);
+            }
+        };
+        walk(JSON.parse(text), "");
+        return flat;
+    }
+    catch {
+        return null;
+    }
+}
+/** Locally measurable criterion matchers. Null → manual.
+ *  Precedence: 树/kb workspace counts (local truth) → any `key≥N` whose key
+ *  exists in the optional --state counter map (external truth, 0.79.1). */
+function measureCriterion(crit, db, state) {
+    const parts = [];
+    const hits = [];
+    const tree = crit.match(/树\s*≥\s*(\d+)/);
+    if (tree) {
+        const n = db.get("SELECT COUNT(*) c FROM trees").c;
+        parts.push(`trees=${n}/${tree[1]}`);
+        hits.push(n >= +tree[1]);
+    }
+    const kb = crit.match(/kb\s*≥\s*(\d+)/);
+    if (kb) {
+        const n = db.get("SELECT COUNT(*) c FROM kb_notes").c;
+        parts.push(`kb=${n}/${kb[1]}`);
+        hits.push(n >= +kb[1]);
+    }
+    if (state) {
+        const seen = new Set();
+        for (const m of crit.matchAll(/([\w\u4e00-\u9fa5][\w\u4e00-\u9fa5.-]*)\s*≥\s*(\d+)/g)) {
+            const key = m[1], need = +m[2];
+            if (key === "树" || key === "kb" || seen.has(key))
+                continue;
+            // 0.79.1: suffix match — a bare criterion key (`y_imported`) binds to a
+            // nested flattened state key (`counts.y_imported`) so users don't have
+            // to know the state file's shape. Exact match wins; else the SHALLOWEST
+            // `.*.<key>` (fewest dots) keeps resolution deterministic.
+            let stateKey = key in state ? key : null;
+            if (!stateKey) {
+                const cands = Object.keys(state).filter((sk) => sk.endsWith("." + key) && Number.isFinite(state[sk]));
+                if (cands.length) {
+                    cands.sort((a, b) => (a.split(".").length - b.split(".").length) || a.localeCompare(b));
+                    stateKey = cands[0];
+                }
+            }
+            if (!stateKey || !Number.isFinite(state[stateKey]))
+                continue;
+            seen.add(key);
+            parts.push(`${key}=${state[stateKey]}/${need}${stateKey !== key ? ` (${stateKey})` : ""}`);
+            hits.push(state[stateKey] >= need);
+        }
+    }
+    if (!parts.length)
+        return null;
+    const hasOr = crit.includes(" 或 ");
+    const hit = hasOr ? hits.some(Boolean) : hits.every(Boolean);
+    return { actual: parts.join(" · "), hit };
+}
+/** npm version count since a date — registry probe with a hard 3s timeout,
+ *  offline-safe fallback to manual. */
+async function measureNpmVersions(pkg, since, fetchImpl) {
+    try {
+        const ctl = new AbortController();
+        const t = setTimeout(() => ctl.abort(), 3000);
+        const r = await fetchImpl(`https://registry.npmjs.org/${pkg}`, { signal: ctl.signal });
+        clearTimeout(t);
+        if (!r.ok)
+            return null;
+        const meta = await r.json();
+        const times = meta.time || {};
+        const versions = Object.entries(times)
+            .filter(([v, ts]) => v !== "created" && v !== "modified" && String(ts) >= since)
+            .map(([v]) => v);
+        return { actual: `npm versions since ${since}: ${versions.length} (${versions.slice(-3).join(",")})`, hit: versions.length > 0 };
+    }
+    catch {
+        return null;
+    }
+}
+async function auditPredictions(inp) {
+    const today = inp.today || new Date().toISOString().slice(0, 10);
+    const rows = [];
+    for (const c of inp.claims) {
+        if (!c.text.startsWith("[预测·"))
+            continue;
+        const { horizon, deadline } = parsePrediction(c.text, c.created);
+        // criterion: prefer the "DATE 前" anchor; fall back to "] " (no-date texts)
+        const m = c.text.match(/\d{4}-\d{2}-\d{2}\s*前\s*(.+?)(?:——|$)/) || c.text.match(/\]\s*(.+?)(?:——|$)/);
+        const criterion = m ? m[1].trim() : "";
+        const daysLeft = deadline ? Math.round((Date.parse(deadline) - Date.parse(today)) / 86400000) : null;
+        // 0.79.1 (user report): a claim the human already arbitrated (supported /
+        // refuted) is CLOSED — the audit reports the terminal state instead of
+        // re-judging it, so the backtest table stops accumulating settled rows.
+        const resolved = c.status === "supported" || c.status === "refuted";
+        let measure = measureCriterion(criterion, inp.db, inp.state);
+        // npm version criterion → registry probe (opt-out for offline/tests)
+        if (!measure && /npm 再发\s*≥\s*(\d+)\s*个版本/.test(criterion)) {
+            const need = +criterion.match(/npm 再发\s*≥\s*(\d+)/)[1];
+            const base = c.text.match(/基线\s*\S*?@?(\d{4}-\d{2}-\d{2})/);
+            const since = base ? base[1] : (c.created || today).slice(0, 10);
+            if (inp.npmProbe !== false) {
+                const v = await measureNpmVersions("ygl-trees", since, inp.fetchImpl || fetch);
+                if (v) {
+                    const n = +(v.actual.match(/:\s*(\d+)/) || [0, 0])[1];
+                    measure = { actual: `${v.actual} · need ≥${need}`, hit: n >= need };
+                }
+            }
+        }
+        let verdict;
+        let hint;
+        if (resolved) {
+            verdict = "resolved";
+            hint = `已人工仲裁：${c.status}（回测终态，不再复判）`;
+        }
+        else if (!measure) {
+            verdict = "manual";
+            hint = "外部世界判据——人工核验后 claim resolve";
+        }
+        else if (daysLeft !== null && daysLeft > 0)
+            verdict = "pending";
+        else
+            verdict = measure.hit ? "hit" : "miss";
+        rows.push({
+            claim_id: c.id, horizon, deadline, criterion,
+            actual: measure ? measure.actual + (!resolved && verdict === "pending" && measure.hit ? " · 已达标" : "") : "—",
+            verdict, days_left: daysLeft, hint,
+        });
+    }
+    return rows;
+}

package/dist/packages/research/produce/src/produce-cmds.js

@@ -133,6 +133,12 @@ function run(env, action, rest, args) {
         case "spec": {
             const title = rest[0] || String(args.flags.title || "");
             const body = readBody();
+            // Feedback confirmation ①: --design-type is a produce design flag; spec
+            // silently swallowing it let a decision record land as a plain spec.
+            if (args.flags["design-type"] !== undefined) {
+                (0, fmt_1.bad)(ctx, "--design-type belongs to 'produce design' (spec does not take it; if this is a design decision, use: produce design <title> --design-type decision)");
+                return 2;
+            }
             if (!title || !body) {
                 (0, fmt_1.bad)(ctx, "usage: produce spec <title> --body|-f <file>");
                 return 2;

package/dist/packages/research/produce/src/project-cmds.js

@@ -41,6 +41,23 @@ const entities_1 = require("../../pipeline/src/entities");
 function run(env, action, rest, args) {
     const { ctx, store } = env;
     const name = rest[0];
+    /** Report ③-3: selection changes are events (session-tagged) — see the
+     *  twin helper in techtree/model/src/cmds.ts for the rationale. */
+    function logSelectionEvent(kind, projName) {
+        try {
+            store.db.run("INSERT INTO events(id,ts,actor,kind,entity,entity_id,payload,level) VALUES(?,?,?,?,?,?,?,?)", [
+                `ev${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`,
+                new Date().toISOString(),
+                process.env.YGL_SESSION || "cli",
+                kind,
+                "project",
+                projName,
+                JSON.stringify({ name: projName, session: process.env.YGL_SESSION || "cli" }),
+                "info",
+            ]);
+        }
+        catch { /* telemetry only */ }
+    }
     switch (action) {
         case "new": {
             if (!name) {
@@ -48,12 +65,19 @@ function run(env, action, rest, args) {
                 return 2;
             }
             const question = String(args.flags.q || args.flags.question || "");
+            // Feedback confirmation ②: auto-selecting the new project silently
+            // re-points every flag-less command away from prior work — say so.
+            const prior = store.db.metaGet("current_project");
+            const priorHint = prior && prior !== name
+                ? `  (prior project '${prior}' is no longer selected — project use ${prior} to switch back)`
+                : "";
             return (0, orm_1.getOrm)(env.db.path)
                 .then((ds) => writes.projectCreate(ds, name, question))
                 .then((p) => {
+                logSelectionEvent("project.use", p.name);
                 (0, fmt_1.ack)(ctx, p, p?.duplicate === true
-                    ? `project exists, selected: ${p.name}  (duplicate, not re-created)`
-                    : `project created and selected: ${p.name}`);
+                    ? `project exists, selected: ${p.name}  (duplicate, not re-created)${priorHint}`
+                    : `project created and selected: ${p.name}${priorHint}`);
                 return 0;
             })
                 .catch((e) => {
@@ -86,6 +110,7 @@ function run(env, action, rest, args) {
                 return 1;
             }
             store.db.metaSet("current_project", name);
+            logSelectionEvent("project.use", name);
             (0, fmt_1.ack)(ctx, { project: name }, `now using: ${name}`);
             return 0;
         }