@globalmpc/nomore 0.0.0-stage → 0.2.0

package/dist/detect.js

@@ -0,0 +1,165 @@
+import { normalize, tokens } from "./normalize.js";
+// Spec › Correction signals.
+const LOOKAHEAD = 3;
+const MAX_PHRASE = 400;
+const STARTS = /^(no|nope|don'?t|do not|stop|wrong|not that|instead|undo|revert|i said|i told you)\b/i;
+const CONTAINS = /\b(instead of|i said|i told you|don'?t|do not|never)\b/i;
+const isCorrectionPhrase = (text) => {
+    const t = text.trim();
+    return t.length <= MAX_PHRASE && (STARTS.test(t) || CONTAINS.test(t.slice(0, 80)));
+};
+export function detectCorrections(events) {
+    const signals = new Map(); // index of a user_text event → its signals
+    const add = (i, s) => (signals.get(i) ?? signals.set(i, new Set()).get(i)).add(s);
+    const nextTyped = (i) => {
+        for (let j = i + 1; j <= i + LOOKAHEAD && j < events.length; j++)
+            if (events[j].kind === "user_text")
+                return j;
+        return -1;
+    };
+    const edits = [];
+    events.forEach((e, i) => {
+        if (e.kind === "tool_rejected" || e.kind === "user_marker") {
+            const j = nextTyped(i);
+            if (j >= 0)
+                add(j, e.kind === "tool_rejected" ? "rejected" : "interrupt");
+        }
+        if (e.kind === "user_text" && i > 0 && events[i - 1].kind.startsWith("assistant") && isCorrectionPhrase(e.text ?? ""))
+            add(i, "phrase");
+        if (e.kind === "assistant_tool_use" && e.tool === "Edit") {
+            const { file_path, old_string, new_string } = e.input ?? {};
+            if (edits.some((x) => x.file === file_path && x.old === new_string)) {
+                for (let j = i - 1; j >= 0; j--)
+                    if (events[j].kind === "user_text") {
+                        add(j, "revert");
+                        break;
+                    }
+            }
+            edits.push({ file: file_path, old: old_string });
+        }
+    });
+    return [...signals.keys()].sort((a, b) => a - b).map((i) => {
+        const e = events[i];
+        const text = e.text ?? "";
+        return { uuid: e.uuid, sessionId: e.sessionId, cwd: e.cwd, ts: e.ts, text, norm: normalize(text), signals: [...signals.get(i)].sort() };
+    });
+}
+// Spec › Repeated instructions: every typed message becomes clauses; clauses that can't be a lasting preference are
+// dropped. Each clause keeps its message's correction signals for display.
+const MAX_CLAUSE = 120;
+const ACK = new Set("yes ok okay okey proceed go ahead continue sure thanks thank lets let start now then good great fine done next step right cool nice pls plz yea yeah yep keep going oke sip siap ya yuk lanjut terus teruskan ayo gas mantap aja saja silakan".split(" ")); // + Indonesian
+const PLACEHOLDER = /^<(url|file|id|n)>$/;
+const clean = (text) => text
+    .replace(/<pasted_content[^>]*>[\s\S]*?<\/pasted_content[^>]*>/g, "\n")
+    .replace(/<([\w-]+)[^>]*>[\s\S]*?<\/\1>/g, "\n")
+    .replace(/<\/?[\w-]+[^>]*>/g, "\n");
+// Pasted content is judged line by line, before clause splitting, so a log line can't leave a harmless-looking
+// fragment ("…limit reached, retry later" → "retry later"). Spec › Repeated instructions.
+const PASTED = [
+    /^\+/, // diff line
+    /[{}[\];]|=>|\(['"]/, // code punctuation
+    /^[\w$.]+\s*=\s*\S/, // name = value
+    /^[\w$.]+:\s*['"`]/, // name: 'value'
+    /^import\s+([\w$]+\s*$|.*\bfrom\b)/i, // import json / import x from 'y'
+    /^from\s+\S+\s+import\b/i,
+    /^(const|let|var)\s+\w+\s*=/,
+    /^(def|class|function)\s+\w+\s*[(:{]/,
+    /\w\([^)]*\)/, // call: openDb(), load(cfg)
+    /^(error|warning|warn|fatal|exception|traceback)\b/i,
+    /^at\s+\S+\s+\(/, // stack frame
+    /\berror:|exception|traceback|limit (reached|exceeded)/i,
+    /:$/, // heading that introduces pasted content
+];
+const isIdentifier = (line) => /^[A-Za-z_$][\w$]*$/.test(line) && /_|[a-z][A-Z]/.test(line);
+// A typed shell command: a known command and only ASCII arguments, short or with a flag or path, so sentences that
+// start with a command name ("git push only after review", "npm 말고 pnpm 써") are kept.
+const SHELL = /^(git|pnpm|npm|npx|yarn|node|python3?|pip3?|docker|kubectl|curl|wget|cd|ls|rm|mkdir|bash|sh|cargo|brew|gh|tsx|bun|deno|uv|ssh|sudo)(\s+[-\w./@:=~'"&|>]+)*\s*$/i;
+const isShellCommand = (line) => SHELL.test(line) && (line.split(/\s+/).length <= 3 || /\s-{1,2}\w|[/\\]|\.\w/.test(line));
+const isPasted = (line) => isIdentifier(line) || isShellCommand(line) || PASTED.some((re) => re.test(line));
+// One-off requests and questions recur because the task recurs, not because they are lasting preferences.
+const QUESTION = /^(what|whats|what's|how|why|when|where|which|who|can you|could you|would you|do you|is it|are you|should we|apa|apakah|bagaimana|gimana|berapa|kenapa|mengapa|kapan|di mana|dimana|siapa)\b/i;
+const REQUEST = /^(review|check|update|provide|crawl|seed|recommend|let me|lets|let's|then|and|fix|commit|push|continue|implement|create|give|add|retry|redo|try|run|double|do (it|this|that|the)|lanjut|lanjutkan|coba|cek|periksa|perbaiki|benerin|buat|buatkan|bikin|jalankan|tambahkan|hapus|kirim)\b/i;
+// A task verb can still open a lasting preference ("run tests before saying done"); these words keep it.
+const PREFERENCE_CUE = /\b(always|never|every|each|before|after|first|only|myself|by default|from now on|one by one|step by step|instead|selalu|jangan|tanpa|hanya|cuma|sebelum|sesudah|setelah|mulai sekarang|sendiri)\b/i;
+const FILLER = /^((pls|plz|please|yea|yeah|yep|yes|ok|okay|okey|now|so|just|also|tolong|mohon|oke|sip|siap|ya|yuk|silakan|ayo)\b[\s,]*)+/i;
+// A negated instruction ("do not use npm") must never join its positive form ("use npm"); grouping runs per polarity.
+const NEGATION = /\b(not|no|never|don'?t|doesn'?t|didn'?t|isn'?t|aren'?t|won'?t|can'?t|cannot|shouldn'?t|without|jangan|tidak|bukan|tanpa)\b|지\s?마|말고|않|못/i;
+// A contrast tail ("use pnpm, not npm") qualifies a positive instruction; it doesn't negate it.
+const CONTRAST = /^(not|instead of|rather than)\b/i;
+// Without the comma too, but only after a choice verb ("use pnpm not npm", "prefer tabs not spaces"): a bare
+// "X not Y" is usually an evaluation ("force pushes not ok", "do it not now") and stays negated. One word after
+// "not", two or more before, no auxiliary ("use what is not needed"), participle tail or evaluative/adverb tail.
+// ponytail: choice verbs and one-word tails only, so "run vitest not jest" and "use pnpm not the npm cli" stay negated.
+// EVAL_TAIL is not exhaustive: a missed word merges opposites ("use it not now"); extend it when one shows up.
+const CHOICE = /^(use|prefer|pick|choose|write|reply|respond|answer|install|go with|stick (with|to))\b/i;
+const EVAL_TAIL = /^(ok|okay|good|fine|bad|great|now|yet|again|anymore|always|ever|never|much|more|less|later|here|there|yes|no|it|this|that|me|you|them|flaky|needed|allowed|acceptable|ideal|welcome|useful|nice|cool|wise|appropriate|necessary|mandatory|helpful|safe|correct|right|wrong|true|today|tomorrow|first|twice|often|everywhere|anywhere|too|so|really|properly)\W*$/i;
+const AUX = /^(do|does|did|is|are|was|were|am|be|been|can|could|should|would|will|must|may|might|shall|have|has|had|need|try|\w+['’](s|re|m|ve|ll|d))$/i;
+const choiceBody = (text) => text.trim().replace(FILLER, "").replace(/^(always|i said)\s+/i, "");
+const isContrastWord = (w) => !/(ed|ing)\W*$/i.test(w) && !EVAL_TAIL.test(w);
+const dropBareContrast = (text) => {
+    const body = choiceBody(text);
+    const w = body.split(/\s+/);
+    const i = w.length - 2; // where "not" would be
+    return CHOICE.test(body) && i >= 2 && /^not$/i.test(w[i]) && !AUX.test(w[i - 1]) && isContrastWord(w[i + 1]) ? w.slice(0, i).join(" ") : text;
+};
+// A ", never …" tail is a contrast too (issue #18) before a description ("…, never an instruction") or, after a
+// tool-choice verb, before one word that isn't a common verb ("use pnpm, never npm"). Any other ", never …" stays
+// an instruction ("commit often, never amend", "answer briefly, never ramble", "use the API, never guess").
+// ponytail: NEVER_VERB is not exhaustive; a missed verb merges ("use X, never <verb>"); extend it when one shows up.
+const TOOL_CHOICE = /^(use|prefer|pick|choose|install|go with|stick (with|to))\b/i;
+const NEVER_VERB = /^(guess|assume|ask|skip|stop|wait|ramble|apologi[sz]e|lie|invent|hardcode|mock|retry|rewrite|refactor|rename|delete|remove|overwrite|force|amend|rebase|squash|merge|push|commit|deploy|publish|release|edit|change|touch|modify|comment|explain|summari[sz]e|speculate|hallucinate|loop|repeat|truncate|ignore)\W*$/i;
+const isContrastTail = (head, tail) => {
+    if (CONTRAST.test(tail) || /^never\s+(a|an|the)\s/i.test(tail))
+        return true;
+    const word = tail.match(/^never\s+(\S+)$/i)?.[1];
+    return word !== undefined && TOOL_CHOICE.test(choiceBody(head)) && isContrastWord(word) && !NEVER_VERB.test(word);
+};
+// The text without its ", never …" contrast tails, and those tails ("use pnpm, never npm, never yarn").
+const splitNeverTails = (text) => {
+    const tails = [];
+    for (let m = text.match(/^(.*),\s*(never\b.*)$/i); m && isContrastTail(m[1], m[2]); m = text.match(/^(.*),\s*(never\b.*)$/i)) {
+        tails.unshift(m[2]);
+        text = m[1];
+    }
+    return { head: text, tails };
+};
+export const isNegated = (text) => NEGATION.test(dropBareContrast(splitNeverTails(text.replace(/,\s*(not|instead of|rather than)\b.*$/i, "")).head));
+// Korean (spec › Repeated instructions): Hangul has no \b word boundaries, so these match as substrings.
+const KO_QUESTION = /뭐|무엇|뭔|어떻게|어떤|어디|언제|왜|얼마|몇|누구|어때|어떨까|(나요|까요|까|니|냐|습니까)[?？.!~]*$/;
+const KO_REQUEST = /(해\s?줘|주세요|줘|해\s?봐|하자|보자|부탁(해|합니다|드려요)?)[.!~]*$/;
+const KO_PREFERENCE = /항상|절대|지\s?마|말고|없이|금지|대신|앞으로|매번|무조건|먼저|전에|후에|다음부터|직접|자세히|간단히|짧게|쉽게/;
+const keep = (clause, question) => {
+    if (clause.length > MAX_CLAUSE || /^([-*#`|>]|\d+\.)/.test(clause))
+        return false;
+    const body = clause.replace(FILLER, "");
+    if (question || QUESTION.test(body) || (REQUEST.test(body) && !PREFERENCE_CUE.test(body)))
+        return false;
+    if ((KO_QUESTION.test(body) || KO_REQUEST.test(body)) && !KO_PREFERENCE.test(body))
+        return false;
+    const t = tokens(normalize(clause));
+    const words = t.filter((x) => !PLACEHOLDER.test(x) && x.length > 1);
+    return !t.includes("<url>") && words.length >= 2 && (t.length - words.length) * 2 <= t.length && !words.every((x) => ACK.has(x));
+};
+// Grouping tokens: plain plurals are singularised so "words" and "word" match. A contrast "never" counts like the
+// stopword "not", so "use pnpm, never npm" groups with "use pnpm, not npm".
+export const clauseTokens = (text) => {
+    const { head, tails } = splitNeverTails(text);
+    const asNot = head + tails.map((t) => `, not${t.slice("never".length)}`).join("");
+    return tokens(normalize(asNot)).map((t) => (t.length > 3 && t.endsWith("s") && !t.endsWith("ss") ? t.slice(0, -1) : t));
+};
+export function extractInstructions(events) {
+    const signals = new Map(detectCorrections(events).map((c) => [c.uuid, c.signals]));
+    return events.flatMap((e) => {
+        if (e.kind !== "user_text")
+            return [];
+        return clean(e.text ?? "")
+            .split("\n")
+            .filter((line) => !isPasted(line.trim()))
+            .join("\n")
+            .split(/\n+|(?<=[.;!?？])\s+|,\s+|\s+(?:and|but)\s+/i)
+            .reduce((parts, p) => (parts.length && isContrastTail(parts.at(-1), p.trim()) ? [...parts.slice(0, -1), `${parts.at(-1)}, ${p.trim()}`] : [...parts, p]), [])
+            .map((raw, i) => ({ c: raw.trim().replace(/[.;!?？]+$/, "").trim(), q: /[?？]\s*$/.test(raw), i }))
+            .filter(({ c, q }) => keep(c, q))
+            .map(({ c, i }) => ({ uuid: `${e.uuid}:${i}`, sessionId: e.sessionId, cwd: e.cwd, ts: e.ts, text: c, norm: normalize(c), signals: signals.get(e.uuid) ?? [] }));
+    });
+}

package/dist/group.js

@@ -0,0 +1,109 @@
+import { createHash } from "node:crypto";
+export function idf(docs) {
+    const df = new Map();
+    for (const d of docs)
+        for (const t of new Set(d))
+            df.set(t, (df.get(t) ?? 0) + 1);
+    return new Map([...df].map(([t, n]) => [t, Math.log(1 + docs.length / n)]));
+}
+const sortedSet = (ts) => [...new Set(ts)].sort();
+// Merge over sorted token sets: the sums run in token order, so the result is the same bit for bit both ways.
+function simSorted(a, b, w) {
+    let inter = 0, union = 0, i = 0, j = 0;
+    while (i < a.length || j < b.length) {
+        if (a[i] === b[j]) {
+            const x = w.get(a[i]) ?? 0;
+            inter += x;
+            union += x;
+            i++, j++;
+        }
+        else if (j >= b.length || (i < a.length && a[i] < b[j]))
+            union += w.get(a[i++]) ?? 0;
+        else
+            union += w.get(b[j++]) ?? 0;
+    }
+    return union === 0 ? 0 : inter / union;
+}
+export function similarity(a, b, w) {
+    return simSorted(sortedSet(a), sortedSet(b), w);
+}
+const byId = (a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+// Items with no tokens (e.g. a bare "no") can't be compared or turned into a rule, so they are left out.
+export function groupItems(items, tokensOf, threshold) {
+    const xs = items.map((x) => ({ x, t: sortedSet(tokensOf(x)) })).filter((e) => e.t.length > 0);
+    xs.sort((a, b) => byId(a.x, b.x));
+    const toks = xs.map((e) => e.t);
+    const w = idf(toks);
+    const parent = xs.map((_, i) => i);
+    const find = (i) => {
+        while (parent[i] !== i)
+            i = parent[i] = parent[parent[i]];
+        return i;
+    };
+    const push = (m, k, v) => (m.get(k) ?? m.set(k, []).get(k)).push(v);
+    // Identical token sets always join (similarity 1), so only one item per distinct set takes part in the join.
+    const byKey = new Map();
+    toks.forEach((ts, i) => push(byKey, ts.join(" "), i));
+    const uniq = [...byKey.values()].map((same) => {
+        same.forEach((i) => (parent[find(i)] = find(same[0])));
+        return same[0];
+    });
+    // Exact prefix filtering. With tokens in a global order (rarest first), any pair with weighted Jaccard ≥ t shares a
+    // token within each one's prefix: the leading tokens while the remaining weight could still hold t × its total
+    // weight. Common tokens end up in suffixes, so they no longer make every pair a candidate.
+    const order = (a, b) => w.get(b) - w.get(a) || (a < b ? -1 : a > b ? 1 : 0);
+    const index = new Map();
+    const prefixes = uniq.map((i) => {
+        const total = toks[i].reduce((s, t) => s + w.get(t), 0);
+        let rest = total;
+        const prefix = [];
+        for (const t of [...toks[i]].sort(order)) {
+            if (rest < threshold * total - 1e-9)
+                break;
+            prefix.push(t);
+            rest -= w.get(t);
+        }
+        return prefix;
+    });
+    prefixes.forEach((p, u) => p.forEach((t) => push(index, t, u)));
+    prefixes.forEach((p, u) => {
+        const cands = new Set();
+        for (const t of p)
+            for (const v of index.get(t))
+                if (v > u)
+                    cands.add(v);
+        for (const v of cands) {
+            const [i, j] = [uniq[u], uniq[v]];
+            if (find(i) !== find(j) && simSorted(toks[i], toks[j], w) >= threshold)
+                parent[find(i)] = find(j);
+        }
+    });
+    const comps = new Map();
+    xs.forEach((_, i) => push(comps, find(i), i));
+    return [...comps.values()]
+        .map((idx) => {
+        // Score = summed similarity to the other members (pairs without a shared token score 0). Members with the same
+        // token set share a score, so it is computed once per distinct set: (copies − 1) × 1 + Σ copies × similarity.
+        // Rounded so float noise in the sums can't beat the ts tie-break.
+        const keys = new Map();
+        idx.forEach((i) => push(keys, toks[i].join(" "), i));
+        const reps = [...keys.values()];
+        const local = new Map();
+        reps.forEach((r, k) => toks[r[0]].forEach((t) => push(local, t, k)));
+        const keyScore = reps.map((r, k) => {
+            const others = new Set(toks[r[0]].flatMap((t) => local.get(t)).filter((m) => m !== k));
+            return Math.round(([...others].reduce((s, m) => s + reps[m].length * simSorted(toks[r[0]], toks[reps[m][0]], w), 0) + r.length - 1) * 1e9);
+        });
+        const scoreOf = new Map(reps.flatMap((r, k) => r.map((i) => [i, keyScore[k]])));
+        const score = (i) => scoreOf.get(i);
+        const best = idx
+            .map((i) => ({ i, s: score(i) }))
+            .sort((a, b) => b.s - a.s || (xs[a.i].x.ts < xs[b.i].x.ts ? -1 : xs[a.i].x.ts > xs[b.i].x.ts ? 1 : a.i - b.i))[0].i;
+        return {
+            id: createHash("sha1").update(toks[best].join(" ")).digest("hex").slice(0, 8),
+            members: idx.map((i) => xs[i].x),
+            representative: xs[best].x,
+        };
+    })
+        .sort((a, b) => byId(a.representative, b.representative));
+}

package/dist/issues.js

@@ -0,0 +1,59 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+export const Issue = z.object({
+    id: z.string(),
+    title: z.string(),
+    url: z.string(),
+    reactions: z.number(),
+    ts: z.string(),
+    labels: z.array(z.string()),
+    state: z.string(), // "open", or the close reason: "completed", "not_planned", …
+});
+// Only the fields we use; the body is never read.
+const RawIssue = z.object({
+    number: z.number(),
+    title: z.string().nullable(),
+    html_url: z.string(),
+    created_at: z.string(),
+    labels: z.array(z.object({ name: z.string() })),
+    reactions: z.object({ total_count: z.number() }).optional(),
+    pull_request: z.unknown().optional(),
+    state: z.string(),
+    state_reason: z.string().nullable().optional(),
+});
+const EXCLUDED = new Set(["duplicate", "invalid"]);
+// The whole title is a retraction: "Withdrawn by the author", "[withdrawn]", "[Bug] (withdrawn)",
+// "[withdrawn] filed in error". A title that merely starts with the word ("Withdrawn API key …") is kept.
+const WITHDRAWN = /^\s*(?:\[[^\]]{0,30}\]\s*)?[\s\p{P}]*withdrawn(?:[\s\p{P}]+(?:by (?:the )?author|filed in error)\b.*)?[\s\p{P}]*$/iu;
+export function loadIssues(files) {
+    // First copy of each issue, with the labels of every copy, so an exclusion label in any file counts.
+    const byNumber = new Map();
+    for (const file of files) {
+        let raw;
+        try {
+            raw = z.array(RawIssue).parse(JSON.parse(readFileSync(file, "utf8")));
+        }
+        catch (e) {
+            throw new Error(`can't load issues from ${file}: ${e.message}`);
+        }
+        for (const r of raw) {
+            const seen = byNumber.get(r.number) ?? byNumber.set(r.number, { r, labels: new Set() }).get(r.number);
+            r.labels.forEach((l) => seen.labels.add(l.name));
+        }
+    }
+    return [...byNumber.keys()]
+        .sort((a, b) => a - b)
+        .map((n) => byNumber.get(n))
+        .filter(({ r, labels }) => r.pull_request === undefined && ![...labels].some((l) => EXCLUDED.has(l)) && !WITHDRAWN.test(r.title ?? ""))
+        .map(({ r, labels }) => Issue.parse({
+        id: String(r.number),
+        title: r.title ?? "",
+        url: r.html_url,
+        reactions: r.reactions?.total_count ?? 0,
+        ts: r.created_at,
+        labels: [...labels],
+        state: r.state === "open" ? "open" : (r.state_reason ?? r.state),
+    }));
+}
+// Strips short leading tags ("[BUG]", "[Feature Request]"); a title written entirely in brackets is kept.
+export const cleanTitle = (title) => title.replace(/^(\s*\[[^\]]{0,30}\])+/, "").trim();

package/dist/mine.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { groupItems } from "./group.js";
+import { cleanTitle } from "./issues.js";
+import { normalize, tokens } from "./normalize.js";
+export const IssueGroup = z.object({
+    id: z.string(),
+    weight: z.number(),
+    issues: z.number(),
+    reactions: z.number(),
+    representative: z.object({ id: z.string(), title: z.string(), url: z.string() }),
+    top: z.array(z.object({ id: z.string(), title: z.string(), url: z.string(), reactions: z.number(), state: z.string() })).max(5),
+});
+// Spec › Part 0: titles join at ≥ 0.5; weight = Σ(1 + reactions); ranked by weight, ties by group id.
+export function mineGroups(issues, threshold = 0.5) {
+    return groupItems(issues, (i) => tokens(normalize(cleanTitle(i.title))), threshold)
+        .map((g) => IssueGroup.parse({
+        id: g.id,
+        weight: g.members.reduce((s, i) => s + 1 + i.reactions, 0),
+        issues: g.members.length,
+        reactions: g.members.reduce((s, i) => s + i.reactions, 0),
+        representative: { id: g.representative.id, title: cleanTitle(g.representative.title), url: g.representative.url },
+        top: [...g.members]
+            .sort((a, b) => b.reactions - a.reactions || Number(a.id) - Number(b.id))
+            .slice(0, 5)
+            .map((i) => ({ id: i.id, title: i.title, url: i.url, reactions: i.reactions, state: i.state })),
+    }))
+        .sort((a, b) => b.weight - a.weight || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+// Titles are untrusted: escape markdown and HTML punctuation so they render as plain link text.
+const text = (s) => s.replace(/\s+/g, " ").replace(/[\\`*_[\]()<>#!|~]/g, "\\$&");
+export function renderTopGroups(gs, n) {
+    const rows = gs.slice(0, n).map((g, i) => {
+        const links = g.top.slice(0, 3).map((t) => `[#${t.id}](${t.url})`).join(" ");
+        return `| ${i + 1} | ${g.weight} | ${g.issues} | ${g.reactions} | [${text(g.representative.title)}](${g.representative.url}) | ${links} |`;
+    });
+    return ["| # | Weight | Issues | Reactions | Representative title | Top issues |", "|---|---|---|---|---|---|", ...rows, ""].join("\n");
+}

package/dist/normalize.js

@@ -0,0 +1,18 @@
+const STOPWORDS = new Set(("a an the and or but if then so to of in on at by for from with about as into is are was were be been am " +
+    "it its this that these those i me my we us our you your he she they them their do does did don t s " +
+    "not no please here there just very can will would should could have has had").split(" "));
+export function normalize(text) {
+    return text
+        .toLowerCase()
+        .replace(/https?:\/\/\S+/g, "<url>")
+        // name.ext needs a name of 2+ chars with a letter, so "e.g." and "24.x" stay text.
+        .replace(/\S*[/\\]\S*|\b(?=[\w-]*[a-z])[\w-]{2,}\.[a-z][a-z0-9]{0,4}\b/g, "<file>")
+        .replace(/\b[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\b|\b(?=[0-9a-f]*[a-f])(?=[0-9a-f]*\d)[0-9a-f]{7,}\b/g, "<id>")
+        .replace(/\d+/g, "<n>")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function tokens(norm) {
+    // Placeholders stay whole ("<file>"), so they never match the word "file".
+    return (norm.match(/<(?:url|file|id|n)>|[\p{L}\p{N}]+/gu) ?? []).filter((t) => !STOPWORDS.has(t));
+}

package/dist/pipeline.js

@@ -0,0 +1,58 @@
+import { join, sep } from "node:path";
+import { codexRuleFile, listRollouts, parseRollout } from "./codex.js";
+import { clauseTokens, extractInstructions, isNegated } from "./detect.js";
+import { groupItems } from "./group.js";
+import { rankGroups } from "./rank.js";
+import { readRuleLines, toSuggestions } from "./rules.js";
+import { listSessionFiles, parseSession } from "./sessions.js";
+import { Report } from "./types.js";
+const GROUP_THRESHOLD = 0.6; // spec › Grouping (clauses)
+export async function runPipeline(opts) {
+    const codex = opts.agent === "codex";
+    const [list, parse] = codex ? [listRollouts, parseRollout] : [listSessionFiles, parseSession];
+    const files = await list(opts.configDir, { sinceMs: opts.nowMs - opts.days * 86_400_000, project: opts.project });
+    const corrections = [];
+    let skippedLines = 0;
+    let scanned = files.length; // codex: only rollouts that yielded events (subagent/exec ones are skipped); claude keeps every file
+    let skippedFiles = 0;
+    for (const f of files) {
+        const s = await parse(f);
+        if (codex && s.events.length === 0 && !s.unreadable)
+            scanned--; // an unreadable file still counts, as for Claude (#26)
+        skippedLines += s.skippedLines;
+        if (s.unreadable)
+            skippedFiles++;
+        corrections.push(...extractInstructions(s.events));
+    }
+    // Two project paths can share one encoded folder (/tmp/a-b, /tmp/a_b): keep only instructions from inside the project.
+    if (opts.project) {
+        const root = opts.project;
+        corrections.splice(0, corrections.length, ...corrections.filter((c) => c.cwd === root || c.cwd.startsWith(root + sep) || c.cwd.startsWith(root + "/")));
+    }
+    // Grouping runs per polarity, and negated clauses carry a "<not>" token, so ids never collide across the two.
+    const byPolarity = [corrections.filter((c) => !isNegated(c.text)), corrections.filter((c) => isNegated(c.text))];
+    const grouped = byPolarity.flatMap((cs, negated) => groupItems(cs.map((c) => ({ id: c.uuid, ts: c.ts, c })), (x) => [...clauseTokens(x.c.text), ...(negated ? ["<not>"] : [])], GROUP_THRESHOLD));
+    const groups = grouped.map((g) => {
+        const members = g.members.map((m) => m.c);
+        return {
+            id: g.id,
+            members,
+            representative: g.representative.c,
+            count: members.length,
+            sessions: new Set(members.map((m) => m.sessionId)).size,
+            projects: new Set(members.map((m) => m.cwd)).size,
+            days: new Set(members.map((m) => m.ts.slice(0, 10))).size,
+            lastSeen: members.map((m) => m.ts).sort().at(-1),
+            signals: [...new Set(members.flatMap((m) => m.signals))].sort(),
+        };
+    });
+    const ruleFile = async (dir) => (codex ? codexRuleFile(dir) : join(dir, "CLAUDE.md"));
+    const rules = await readRuleLines([...(opts.project ? [await ruleFile(opts.project)] : []), await ruleFile(opts.configDir)], { imports: !codex });
+    return Report.parse({
+        scannedSessions: scanned,
+        skippedLines,
+        skippedFiles,
+        corrections: corrections.length,
+        suggestions: toSuggestions(rankGroups(groups, opts.nowMs), rules),
+    });
+}

package/dist/rank.js

@@ -0,0 +1,18 @@
+const DAY_MS = 86_400_000;
+const HALF_LIFE_DAYS = 14;
+// Tasks repeat more often than preferences; a preference word in any clause triples a group's score. Korean has no
+// \b word boundaries, so its words are matched as plain substrings.
+const PREFERENCE = /\b(never|don'?t|do not|without|instead|always|only|stop|avoid|prefer|myself|too|selalu|jangan|tanpa|hanya|terlalu)\b|지 ?마|말고|없이|항상|절대|금지|대신|너무/i;
+const BOOST = 3;
+// Spec › Ranking: score = count × sessions × 0.5^(days since last / 14) × boost; shown if sessions ≥ 2.
+export function rankGroups(gs, nowMs) {
+    return gs
+        .filter((g) => g.sessions >= 2)
+        .map((g) => ({
+        ...g,
+        signals: g.sessions >= 3 && !g.signals.includes("repeated") ? [...g.signals, "repeated"] : g.signals,
+        score: g.count * g.sessions * 0.5 ** ((nowMs - Date.parse(g.lastSeen)) / DAY_MS / HALF_LIFE_DAYS) *
+            (g.members.some((m) => PREFERENCE.test(m.text)) ? BOOST : 1),
+    }))
+        .sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}

package/dist/report.js

@@ -0,0 +1,29 @@
+// The public repo; change to the org's repo at handover (README's install link too).
+export const REPO_URL = "https://github.com/globalmpc/nomore";
+const pack = (file) => `Meanwhile, start with the 20-rule pack: ${REPO_URL}/blob/main/rules/${file}`;
+const nothingYet = (p) => `No instructions repeated across sessions yet.\n${p}`;
+export const RULE_PACK = pack("CLAUDE.md");
+export const NOTHING_YET = nothingYet(RULE_PACK);
+export const RULE_PACK_CODEX = pack("AGENTS.md");
+export const NOTHING_YET_CODEX = nothingYet(RULE_PACK_CODEX);
+export const skippedFilesNote = (r) => `${r.skippedFiles} unreadable ${r.skippedFiles === 1 ? "file" : "files"} skipped`;
+const line = (s) => `● ${s.text}\n  ${s.count}× in ${s.sessions} sessions, last ${s.lastSeen.slice(0, 10)}\n` +
+    s.examples.map((e) => `  “${e.length > 80 ? e.slice(0, 79) + "…" : e}”`).join("\n");
+export function renderReport(r, nothing = NOTHING_YET) {
+    const head = `nomore · ${r.scannedSessions} sessions · ${r.corrections} instructions` + (r.skippedLines ? ` · ${r.skippedLines} unreadable lines skipped` : "") +
+        (r.skippedFiles ? ` · ${skippedFilesNote(r)}` : "");
+    const fresh = r.suggestions.filter((s) => s.status === "new");
+    const ignored = r.suggestions.filter((s) => s.status === "ignored");
+    if (r.suggestions.length === 0)
+        return `${head}\n\n${nothing}\n`;
+    return [
+        head,
+        ...(fresh.length ? ["", "Repeated instructions", "", ...fresh.map(line)] : []),
+        ...(ignored.length ? ["", "Rules you have, but the agent ignores", "", ...ignored.map((s) => `${line(s)}\n  rule: ${s.matchedRule}`)] : []),
+        "",
+    ].join("\n");
+}
+// Safe to share: totals only. Suggestion text can hold private words, so it never appears here.
+export function renderCard(r) {
+    return `nomore: ${r.scannedSessions} sessions, ${r.corrections} instructions, ${r.suggestions.length} repeated.\n`;
+}

package/dist/rules.js

@@ -0,0 +1,69 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { isNegated } from "./detect.js";
+import { idf, similarity } from "./group.js";
+import { normalize, tokens } from "./normalize.js";
+import { Suggestion } from "./types.js";
+const RULE_MATCH = 0.3; // spec › Rule check
+// Bullet or sentence lines of the rules files; headings, blanks and missing files are skipped. A line "@path"
+// imports another file in its place (Claude Code's CLAUDE.md imports: relative to the file, or ~/), once each.
+// AGENTS.md has no imports (Codex), so callers pass imports: false and an "@x" line stays plain text.
+export async function readRuleLines(paths, { imports = true } = {}) {
+    const seen = new Set();
+    const read = async (path) => {
+        if (seen.has(path))
+            return [];
+        seen.add(path);
+        const text = await readFile(path, "utf8").catch(() => "");
+        const out = [];
+        for (const raw of text.split("\n")) {
+            const line = raw.trim();
+            const imp = imports ? line.match(/^@(\S+)$/) : null;
+            if (imp)
+                out.push(...(await read(imp[1].startsWith("~/") ? join(homedir(), imp[1].slice(2)) : resolve(dirname(path), imp[1]))));
+            else if (line !== "" && !line.startsWith("#"))
+                out.push(line.replace(/^([-*]|\d+\.)\s+/, ""));
+        }
+        return out;
+    };
+    const lines = [];
+    for (const p of paths)
+        lines.push(...(await read(resolve(p))));
+    return lines;
+}
+const template = (text) => {
+    const t = text.trim().replace(/^(no|nope)[,.!]*\s+|^don'?t do that[,.!]*\s+/i, "");
+    return t.charAt(0).toUpperCase() + t.slice(1);
+};
+export function toSuggestions(groups, ruleLines) {
+    const ruleToks = ruleLines.map((l) => tokens(normalize(l)));
+    const repToks = groups.map((g) => tokens(g.representative.norm));
+    const w = idf([...ruleToks, ...repToks]);
+    return groups.map((g, gi) => {
+        let best = -1, bestSim = 0;
+        const negated = isNegated(g.representative.text);
+        ruleToks.forEach((rt, ri) => {
+            if (isNegated(ruleLines[ri]) !== negated)
+                return; // "Use npm" doesn't cover "don't use npm"
+            const s = similarity(repToks[gi], rt, w);
+            if (s > bestSim)
+                [best, bestSim] = [ri, s];
+        });
+        const ignored = best >= 0 && bestSim >= RULE_MATCH;
+        return Suggestion.parse({
+            id: g.id,
+            text: template(g.representative.text),
+            status: ignored ? "ignored" : "new",
+            ...(ignored ? { matchedRule: ruleLines[best] } : {}),
+            count: g.count,
+            sessions: g.sessions,
+            projects: g.projects,
+            days: g.days,
+            score: g.score,
+            lastSeen: g.lastSeen,
+            examples: [...new Set(g.members.map((m) => m.text.trim()))].slice(0, 3),
+            signals: g.signals,
+        });
+    });
+}