@zuzuucodes/cli 1.4.0 → 1.6.0

package/zuzuu/miners/instructions.mjs

@@ -1,157 +0,0 @@
-// zuzuu/miners/instructions.mjs
-// Instructions miner (WS5-T4) — detect recurring corrective user turns across
-// sessions and propose steering-amendment blocks for the Instructions faculty.
-//
-// Corrective turns are captured by mineTranscript as:
-//   correctionTurns: [{ text }]  — user turns following an assistant tool action
-//   that contain corrective lexicon (e.g. "always", "never", "don't", etc.)
-//
-// Shape: { faculty:'instructions', aggregate(sessions, opts), propose(agentDir, aggregated) }
-// Self-registers on import.
-
-import { join } from 'node:path';
-import { existsSync, readFileSync } from 'node:fs';
-import { makeProposal, writeProposal, listProposals, isArchivedResolved } from '../faculty/proposal.mjs';
-import { register } from './registry.mjs';
-
-// ---------------------------------------------------------------------------
-// helpers
-
-/**
- * Normalise a correction text for grouping:
- * lowercase, collapse whitespace, truncate to 200 chars.
- *
- * v1 grouping: near-identical normalised text (exact key match). Simple and
- * deterministic; a fuzzy grouper can be earned later.
- *
- * @param {string} text
- * @returns {string}
- */
-function normText(text) {
-  return String(text).toLowerCase().replace(/\s+/g, ' ').trim().slice(0, 200);
-}
-
-/**
- * Derive a proposal id fragment from a normalised text key.
- * Keep it stable, short, and filesystem-safe.
- */
-function instrId(normKey) {
-  // Use a slugified version of the first 60 chars of the normalised text,
-  // prefixed to make collisions with other faculties impossible.
-  const slug = normKey.slice(0, 60).replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50) || 'instr';
-  return 'instr-' + slug;
-}
-
-// ---------------------------------------------------------------------------
-// aggregate
-
-/**
- * Group correctionTurns from mined sessions; propose when a similar correction
- * recurs across ≥minSessions (default 2) distinct sessions.
- *
- * @param {Array<{sessionId:string, correctionTurns:{text:string}[]}>} sessions
- * @param {object} opts
- * @param {number} [opts.minSessions=2] min distinct sessions with the same normalised correction
- * @returns {Array<{payload:{text:string}, evidence:{occurrences:number, sessions:number}}>}
- */
-export function aggregate(sessions, { minSessions = 2 } = {}) {
-  // normalised text → { count, sessions: Set<sessionId>, rawText: string }
-  const stats = new Map();
-
-  for (const s of sessions) {
-    if (!Array.isArray(s.correctionTurns)) continue;
-    // Track distinct normalised texts per session to avoid double-counting
-    // the same session for the same correction text.
-    const seenInSession = new Set();
-    for (const { text } of s.correctionTurns) {
-      const key = normText(text);
-      if (!key) continue;
-      const st = stats.get(key) ?? { count: 0, sessions: new Set(), rawText: text };
-      st.count++;
-      st.sessions.add(s.sessionId);
-      seenInSession.add(key);
-      stats.set(key, st);
-    }
-  }
-
-  const candidates = [];
-  for (const [, st] of stats) {
-    if (st.sessions.size < minSessions) continue;
-
-    // Phrase the raw correction as an instruction for the steering amendment.
-    // The corrective turn text already reads like user guidance; use it directly
-    // (trimmed to 500 chars to match mineTranscript's cap).
-    const amendmentText = st.rawText.slice(0, 500).trim();
-    const id = instrId(normText(amendmentText));
-
-    candidates.push({
-      payload: { id, text: amendmentText },
-      evidence: { occurrences: st.count, sessions: st.sessions.size },
-    });
-  }
-
-  return candidates;
-}
-
-// ---------------------------------------------------------------------------
-// propose
-
-/**
- * Write an instructions proposal into .zuzuu/instructions/proposals/ for each
- * candidate.
- *
- * Idempotent:
- *   - skips if an instructions proposal with the same derived id already exists
- *   - skips if the text is already present in project.md
- *   - skips if the id is already resolved in proposals/archive/ — a rejection
- *     is remembered; re-distilling never resurrects it
- *
- * @param {string} agentDir
- * @param {ReturnType<typeof aggregate>} aggregated
- * @returns {number} count of new proposals written
- */
-export function propose(agentDir, aggregated) {
-  // Collect ids of existing pending proposals for this faculty.
-  const existing = listProposals(agentDir, 'instructions');
-  const existingIds = new Set(existing.map((p) => p.payload?.id).filter(Boolean));
-
-  // Read project.md to skip amendments already applied.
-  const projectMdPath = join(agentDir, 'instructions', 'project.md');
-  const projectMdContent = existsSync(projectMdPath)
-    ? readFileSync(projectMdPath, 'utf8')
-    : '';
-
-  let count = 0;
-  for (const c of aggregated) {
-    const { payload, evidence } = c;
-
-    // Idempotent: skip if already proposed.
-    if (existingIds.has(payload.id)) continue;
-
-    // Idempotent: skip if text already present in project.md.
-    if (projectMdContent.includes(payload.text)) continue;
-
-    const proposal = makeProposal({
-      faculty: 'instructions',
-      kind: 'block',
-      source: 'distill',
-      payload,
-      evidence,
-    });
-
-    // A rejection is remembered: never resurrect an archive-resolved id.
-    if (isArchivedResolved(agentDir, 'instructions', proposal.id)) continue;
-
-    writeProposal(agentDir, proposal);
-    count++;
-  }
-
-  return count;
-}
-
-// ---------------------------------------------------------------------------
-// self-register
-
-export const miner = { faculty: 'instructions', aggregate, propose };
-
-register(miner);

package/zuzuu/miners/knowledge.mjs

@@ -1,25 +0,0 @@
-// Knowledge miner (WS5-T1) — the existing source-A distill path, wrapped as a
-// registry miner. NO behavior change: `aggregate` is the same function the
-// golden distill test asserts on; `propose` mirrors `distillSessions` (one
-// `createProposal` per aggregated candidate). Self-registers on import.
-
-import { aggregate } from '../knowledge/distill.mjs';
-import { createProposal } from '../knowledge/proposals.mjs';
-import { register } from './registry.mjs';
-
-/** File one knowledge proposal per aggregated candidate; return the count of
- *  actually-filed proposals (archive-resolved ids are skipped, not re-filed). */
-export function propose(agentDir, aggregated) {
-  let count = 0;
-  for (const c of aggregated) {
-    const p = createProposal(agentDir, { candidate: c.candidate, source: 'distill', evidence: c.evidence });
-    if (p && p.status !== 'archived-skip') count++;
-  }
-  return count;
-}
-
-export const miner = { faculty: 'knowledge', aggregate, propose };
-
-register(miner);
-
-export { aggregate };

package/zuzuu/miners/memory.mjs

@@ -1,27 +0,0 @@
-// zuzuu/miners/memory.mjs
-// Memory miner STUB (WS5-T4) — registered no-op; deferred this pass.
-//
-// WHAT IT WOULD MINE (when implemented):
-//   Completed-session episodes — a Run that reached `completed` status in
-//   .zuzuu/sessions.json — would be distilled into curated episode entries at
-//   .zuzuu/memory/entries/<id>.md. Each entry captures: what was attempted,
-//   key decisions made, outcome, and a set of durable learnings. The miner
-//   would emit `memory` proposals of kind 'episode' into
-//   .zuzuu/memory/proposals/ for human review via `zuzuu review`. Deferred until
-//   the Memory substrate (off-edge Postgres/Neon or local Markdown) is
-//   established and the session lifecycle state machine is stable enough to
-//   reliably produce `completed` runs with rich enough trace data to distill.
-//
-// Shape: { faculty:'memory', aggregate, propose, stub:true }
-// Self-registers on import (no-op).
-
-import { register } from './registry.mjs';
-
-export const miner = {
-  faculty: 'memory',
-  stub: true,
-  aggregate: () => [],
-  propose: () => 0,
-};
-
-register(miner);

package/zuzuu/miners/registry.mjs

@@ -1,31 +0,0 @@
-// Miner registry (WS5-T1) — the faculty-mining plugin table.
-//
-// Each miner is `{ faculty, aggregate(sessions, opts) -> candidates,
-// propose(agentDir, candidates) -> count }`. The `--all-faculties` distill driver
-// mines every transcript once into a shared `sessions` array, then runs each
-// registered miner's aggregate + propose. Miners self-register on import.
-
-const miners = [];
-
-/** Register a miner. Re-registering the same faculty replaces it (idempotent import). */
-export function register(miner) {
-  const i = miners.findIndex((m) => m.faculty === miner.faculty);
-  if (i >= 0) miners[i] = miner;
-  else miners.push(miner);
-  return miner;
-}
-
-/** All registered miners. */
-export function all() {
-  return miners.slice();
-}
-
-/** The miner for a faculty, or undefined. */
-export function get(faculty) {
-  return miners.find((m) => m.faculty === faculty);
-}
-
-/** Clear the registry — tests only. */
-export function reset() {
-  miners.length = 0;
-}