minimal-vibe-coding-kit 0.4.2 → 0.5.0

package/.claude/skills/tutien/scripts/command.mjs

@@ -0,0 +1,107 @@
+// Parses a /tutien invocation. The skill is user-invoked only
+// (disable-model-invocation: true), so nothing here runs unless the user
+// typed /tutien. `off`/`on` toggle the session mode; a report action only
+// runs when the mode is on.
+
+const ACTIONS = new Set(['on', 'off', 'status', 'preview', 'analyze', 'compare', 'explain', 'classify']);
+const TONE_ALIASES = new Map([
+  ['serene', 'serene'],
+  ['spirited', 'spirited'],
+  ['neutral', 'neutral'],
+  // Backward-compatible aliases. They are accepted but no longer advertised,
+  // keeping the public vocabulary calm and unambiguous across agent surfaces.
+  ['gentle', 'serene'],
+  ['spicy', 'spirited']
+]);
+
+export const TUTIEN_EXPERIENCE = Object.freeze({
+  kind: 'wholesome-coding-classification-game',
+  purpose: 'stress-relief-and-mindful-reflection',
+  narrativeStyle: 'refined-mystical-xianxia',
+  semanticNamespace: 'tutien-coding-cultivation-v1'
+});
+
+const STOP_REQUESTS = [
+  /^(?:(?:please\s+)|(?:(?:can|could|would)\s+you\s+(?:please\s+)?))?(?:off|stop|end|exit|disable)(?:\s+(?:now|please))?[.!]?$/i,
+  /^(?:(?:please\s+)|(?:(?:can|could|would)\s+you\s+(?:please\s+)?))?(?:stop|end|exit|disable)\s+(?:\/?tutien|tu\s+tien)(?:\s+mode)?(?:\s+(?:now|please))?[.!]?$/i,
+  /^(?:(?:vui\s+lòng|hãy|giúp\s+tôi)\s+)?(?:dừng|tắt|kết\s+thúc|thoát)(?:\s+(?:nhé|ngay))?[.!]?$/iu,
+  /^(?:(?:vui\s+lòng|hãy|giúp\s+tôi)\s+)?(?:dừng|tắt|kết\s+thúc|thoát)\s+(?:\/?tutien|tu\s+tiên)(?:\s+(?:mode|chế\s+độ))?(?:\s+(?:nhé|ngay))?[.!]?$/iu
+];
+
+export function normalizeTone(value) {
+  return TONE_ALIASES.get(String(value ?? '').toLowerCase()) ?? 'serene';
+}
+
+export function isStopRequest(argsString = '') {
+  const normalized = String(argsString).trim().replace(/\s+/g, ' ');
+  return STOP_REQUESTS.some((re) => re.test(normalized));
+}
+
+export function parseInvocation(argsString = '') {
+  const tokens = String(argsString).trim().split(/\s+/).filter(Boolean);
+  const options = {
+    scope: 'repo',
+    privacy: 'aggregate-only',
+    language: 'auto',
+    tone: 'serene',
+    villains: 'on',
+    score: 'hidden',
+    includeExcerpts: false,
+    range: 'all',
+    sources: []
+  };
+  let action = null;
+
+  // A direct request to end the experience always wins over report parsing.
+  // This keeps prose mode and approval state from lingering after the user
+  // asks to return to the kit's normal voice.
+  if (isStopRequest(argsString)) {
+    return { action: 'off', isModeToggle: true, explicitAction: true, options };
+  }
+
+  for (const tok of tokens) {
+    const eq = tok.indexOf('=');
+    if (eq === -1) {
+      if (!action && ACTIONS.has(tok)) action = tok;
+      continue;
+    }
+    const key = tok.slice(0, eq);
+    const value = tok.slice(eq + 1);
+    switch (key) {
+      case 'language': options.language = value; break;
+      case 'tone': options.tone = normalizeTone(value); break;
+      case 'villains': options.villains = value === 'off' ? 'off' : 'on'; break;
+      case 'score': options.score = value === 'show' ? 'show' : 'hidden'; break;
+      case 'scope': options.scope = value; break;
+      case 'privacy': options.privacy = value; break;
+      case 'range': options.range = value; break;
+      case 'include-excerpts': options.includeExcerpts = value === 'true'; break;
+      case 'sources': options.sources = value.split(',').filter(Boolean); break;
+      case 'previous': options.previous = value; break;
+      case 'metric': options.metric = value; break;
+      case 'approve': options.approve = value; break;
+      case 'snapshot': options.snapshot = value === 'true'; break;
+      case 'faction': options.faction = value; break;
+      case 'affiliation': options.affiliation = value; break;
+      case 'paths': options.paths = value.split(',').filter(Boolean); break;
+      case 'domains': options.domains = value.split(',').filter(Boolean); break;
+      case 'authorization': options.authorization = value; break;
+      default: break;
+    }
+  }
+
+  // Default action when the user typed only `/tutien`: a safe preview. A bare
+  // invocation (no explicit action word) also re-activates the mode; an
+  // explicit report action while the mode is off is refused by the runner.
+  const explicitAction = action !== null;
+  if (!action) action = 'preview';
+  const isModeToggle = action === 'on' || action === 'off' || action === 'status';
+  return { action, isModeToggle, explicitAction, options };
+}
+
+// The livelier `spirited` voice is explicit opt-in. Safety-sensitive contexts
+// always use neutral prose. Legacy tone names normalize to the new namespace.
+export function resolveTone(requestedTone, { sensitive = false } = {}) {
+  if (sensitive) return 'neutral';
+  return normalizeTone(requestedTone);
+}

package/.claude/skills/tutien/scripts/compare.mjs

@@ -0,0 +1,41 @@
+// Phase 4 comparison + schema migration. Compares two aggregate snapshots and
+// reports deltas and a trend. Never fabricates a change from missing data.
+
+import { SNAPSHOT_SCHEMA } from './snapshot.mjs';
+
+// Forward-migrate an older snapshot so comparisons don't crash on new fields.
+export function migrateSnapshot(snap) {
+  if (!snap || typeof snap !== 'object') throw new Error('snapshot is not an object');
+  const s = { ...snap };
+  if ((s.snapshotSchema ?? 0) > SNAPSHOT_SCHEMA) {
+    throw new Error(`snapshot schema ${s.snapshotSchema} is newer than supported ${SNAPSHOT_SCHEMA}; upgrade tutien`);
+  }
+  s.counts = { exactRepeats: 0, nearRepeats: 0, retryLoops: 0, conflicts: 0, failures: 0, recoveries: 0, passes: 0, ...(s.counts ?? {}) };
+  s.tokens = { reportedTotal: 0, estimatedTotal: 0, unknownTurns: 0, ...(s.tokens ?? {}) };
+  s.villainState = s.villainState ?? [];
+  s.snapshotSchema = SNAPSHOT_SCHEMA;
+  return s;
+}
+
+const num = (x) => (typeof x === 'number' ? x : null);
+const diff = (a, b) => (num(a) == null || num(b) == null ? null : a - b);
+
+export function compareSnapshots(prevRaw, currRaw) {
+  const prev = migrateSnapshot(prevRaw);
+  const curr = migrateSnapshot(currRaw);
+  const scoreDelta = diff(curr.score, prev.score);
+  const countDeltas = {};
+  for (const k of Object.keys(curr.counts)) countDeltas[k] = (curr.counts[k] ?? 0) - (prev.counts[k] ?? 0);
+  return {
+    from: prev.createdAt,
+    to: curr.createdAt,
+    scoreDelta,
+    realmChange: { from: prev.realm?.name ?? null, to: curr.realm?.name ?? null },
+    tokenDeltas: {
+      reported: (curr.tokens.reportedTotal ?? 0) - (prev.tokens.reportedTotal ?? 0),
+      estimated: (curr.tokens.estimatedTotal ?? 0) - (prev.tokens.estimatedTotal ?? 0)
+    },
+    countDeltas,
+    trend: scoreDelta == null ? 'unknown' : scoreDelta > 0 ? 'improving' : scoreDelta < 0 ? 'worsening' : 'stable'
+  };
+}

package/.claude/skills/tutien/scripts/metrics.mjs

@@ -0,0 +1,306 @@
+import { sha16 } from './normalize-events.mjs';
+
+// Deterministic metric engine. Every function returns plain data derived only
+// from its inputs; no randomness, no timestamps of its own, no raw text.
+
+export function groupTasks(events, { gapMinutes = 60 } = {}) {
+  const tasks = new Map();
+  const counters = new Map();
+  const lastTs = new Map();
+  for (const ev of events) {
+    if (ev.eventType === 'commit') continue;
+    const session = ev.sessionId ?? 'unknown';
+    let key, grouping, confidence;
+    if (ev.taskId) {
+      key = `explicit:${session}:${ev.taskId}`;
+      grouping = 'explicit';
+      confidence = 'high';
+    } else {
+      if (!counters.has(session)) counters.set(session, 0);
+      let idx = counters.get(session);
+      const t = ev.timestamp ? Date.parse(ev.timestamp) : NaN;
+      const last = lastTs.get(session);
+      if (last != null && Number.isFinite(t) && t - last > gapMinutes * 60000) {
+        idx += 1;
+        counters.set(session, idx);
+      }
+      if (Number.isFinite(t)) lastTs.set(session, t);
+      key = `derived:${session}:${idx}`;
+      grouping = 'derived';
+      confidence = 'medium';
+    }
+    if (!tasks.has(key)) tasks.set(key, { taskId: key, sessionId: session, grouping, confidence, eventIds: [] });
+    tasks.get(key).eventIds.push(ev.eventId);
+  }
+  return [...tasks.values()];
+}
+
+export function normalizeExact(text) {
+  return text.normalize('NFC').replace(/\r\n/g, '\n').trim();
+}
+
+// Loose form for near-repeat comparison: lowercase and collapse whitespace
+// outside fenced code blocks; strip a leading slash-command token.
+export function normalizeLoose(text) {
+  return normalizeExact(text)
+    .replace(/^\/[\w-]+\s+/, '')
+    .split(/(```[\s\S]*?```)/)
+    .map((seg, i) => (i % 2 === 1 ? seg : seg.toLowerCase().replace(/\s+/g, ' ')))
+    .join('')
+    .trim();
+}
+
+function trigrams(s) {
+  const out = new Set();
+  for (let i = 0; i <= s.length - 3; i++) out.add(s.slice(i, i + 3));
+  return out;
+}
+
+export function diceSimilarity(a, b) {
+  const ta = trigrams(a);
+  const tb = trigrams(b);
+  if (!ta.size || !tb.size) return 0;
+  let inter = 0;
+  for (const g of ta) if (tb.has(g)) inter += 1;
+  return (2 * inter) / (ta.size + tb.size);
+}
+
+export function repetitionMetrics(events, tasks, { nearThreshold = 0.9, minLength = 30 } = {}) {
+  const byId = new Map(events.map((e) => [e.eventId, e]));
+  const order = new Map(events.map((e, i) => [e.eventId, i]));
+  const exactRepeats = [];
+  const nearRepeats = [];
+  const retryLoopCandidates = [];
+
+  for (const task of tasks) {
+    const users = task.eventIds
+      .map((id) => byId.get(id))
+      .filter((e) => e.role === 'user' && e.eventType === 'message' && e.text);
+    if (users.length < 2) continue;
+
+    const parent = new Map(users.map((e) => [e.eventId, e.eventId]));
+    const find = (x) => {
+      while (parent.get(x) !== x) {
+        parent.set(x, parent.get(parent.get(x)));
+        x = parent.get(x);
+      }
+      return x;
+    };
+    const union = (a, b) => parent.set(find(a), find(b));
+
+    const exactGroups = new Map();
+    for (const e of users) {
+      const key = normalizeExact(e.text);
+      if (!exactGroups.has(key)) exactGroups.set(key, []);
+      exactGroups.get(key).push(e);
+    }
+    for (const group of exactGroups.values()) {
+      for (let i = 1; i < group.length; i++) union(group[i].eventId, group[0].eventId);
+      if (group.length >= 2) {
+        exactRepeats.push({
+          taskId: task.taskId,
+          count: group.length,
+          eventIds: group.map((e) => e.eventId),
+          textDigest: sha16(normalizeExact(group[0].text))
+        });
+      }
+    }
+
+    for (let i = 0; i < users.length; i++) {
+      for (let j = i + 1; j < users.length; j++) {
+        const a = users[i];
+        const b = users[j];
+        if (normalizeExact(a.text) === normalizeExact(b.text)) continue;
+        const la = normalizeLoose(a.text);
+        const lb = normalizeLoose(b.text);
+        if (la.length < minLength || lb.length < minLength) continue;
+        const sim = diceSimilarity(la, lb);
+        if (sim >= nearThreshold) {
+          nearRepeats.push({
+            taskId: task.taskId,
+            eventIds: [a.eventId, b.eventId],
+            similarity: Math.round(sim * 1000) / 1000
+          });
+          union(a.eventId, b.eventId);
+        }
+      }
+    }
+
+    let run = [users[0]];
+    const flush = () => {
+      if (run.length >= 3) {
+        retryLoopCandidates.push({
+          taskId: task.taskId,
+          count: run.length,
+          eventIds: run.map((e) => e.eventId),
+          confidence: task.grouping === 'explicit' ? 0.85 : 0.6
+        });
+      }
+    };
+    for (let i = 1; i < users.length; i++) {
+      const prev = run[run.length - 1];
+      const cur = users[i];
+      const sameClass = find(prev.eventId) === find(cur.eventId);
+      const between = events
+        .slice(order.get(prev.eventId) + 1, order.get(cur.eventId))
+        .some((e) => e.role !== 'user');
+      if (sameClass && between) run.push(cur);
+      else {
+        flush();
+        run = [cur];
+      }
+    }
+    flush();
+  }
+  return { exactRepeats, nearRepeats, retryLoopCandidates };
+}
+
+const NEGATION_RE = /\b(?:do not|don't|never)\s+([a-z][\w\s/-]{2,60})/gi;
+const STOPWORDS = new Set(['the', 'a', 'an', 'to', 'this', 'that', 'of', 'in', 'on', 'for', 'any']);
+
+// Conservative lexical detector: only a "never/do not X" instruction followed
+// in the same task by a later prompt requesting X. Candidates only, with
+// confidence — a later correction that replaces the earlier instruction is a
+// revision, which is why confidence stays at 0.6 and review is expected.
+export function conflictCandidates(events, tasks) {
+  const byId = new Map(events.map((e) => [e.eventId, e]));
+  const out = [];
+  for (const task of tasks) {
+    const users = task.eventIds
+      .map((id) => byId.get(id))
+      .filter((e) => e.role === 'user' && e.eventType === 'message' && e.text);
+    for (let i = 0; i < users.length; i++) {
+      for (const match of users[i].text.matchAll(NEGATION_RE)) {
+        const words = match[1]
+          .toLowerCase()
+          .split(/[^\w/-]+/)
+          .filter((w) => w && !STOPWORDS.has(w))
+          .slice(0, 2);
+        if (words.length < 2) continue;
+        for (let j = i + 1; j < users.length; j++) {
+          const later = users[j].text.toLowerCase();
+          if (words.every((w) => later.includes(w)) && !/(?:do not|don't|never)\s/.test(later)) {
+            out.push({
+              category: 'user-user',
+              taskId: task.taskId,
+              eventIds: [users[i].eventId, users[j].eventId],
+              phraseDigest: sha16(words.join(' ')),
+              confidence: 0.6
+            });
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
+
+export function issueMetrics(events, taskKeyByEvent = new Map()) {
+  const failures = [];
+  const recoveries = [];
+  const revertCandidates = [];
+  const failEvents = [];
+  const passEventIds = [];
+  let passes = 0;
+  events.forEach((e, idx) => {
+    if (e.eventType === 'test' || e.eventType === 'tool_result') {
+      if (e.outcome === 'fail') {
+        failures.push({ eventId: e.eventId, label: e.label ?? null, taskId: taskKeyByEvent.get(e.eventId) ?? null });
+        failEvents.push({ e, idx });
+      } else if (e.outcome === 'pass') {
+        passes += 1;
+        passEventIds.push(e.eventId);
+      }
+    }
+    if (e.eventType === 'commit' && e.commit?.isRevert) {
+      revertCandidates.push({ eventId: e.eventId, hash: e.commit.hash ?? null, confidence: 0.5 });
+    }
+  });
+  for (const { e: failEv, idx } of failEvents) {
+    const rec = events
+      .slice(idx + 1)
+      .find(
+        (e) =>
+          (e.eventType === 'test' || e.eventType === 'tool_result') &&
+          e.outcome === 'pass' &&
+          (e.label ?? null) === (failEv.label ?? null)
+      );
+    if (rec) {
+      recoveries.push({
+        issueEventId: failEv.eventId,
+        recoveryEventId: rec.eventId,
+        taskId: taskKeyByEvent.get(failEv.eventId) ?? null
+      });
+    }
+  }
+  return { passes, passEventIds, failures, recoveries, revertCandidates };
+}
+
+// Reported, estimated, and unknown usage stay disjoint. Only records marked
+// cumulative are streaming counters (keep the last one); independent chunks
+// that merely share a requestId are summed. Totals come from the normalized
+// usableTotal, so unusable usage records can never contribute.
+export function tokenMetrics(events) {
+  const byRequest = new Map();
+  const singles = [];
+  let dedupedStreamUpdates = 0;
+  for (const e of events) {
+    if (!e.usage) continue;
+    const rid = e.usage.requestId;
+    if (rid) {
+      if (!byRequest.has(rid)) byRequest.set(rid, []);
+      byRequest.get(rid).push(e);
+    } else {
+      singles.push(e);
+    }
+  }
+  const counted = [];
+  for (const group of byRequest.values()) {
+    if (group.some((e) => e.usage.cumulative)) {
+      counted.push(group[group.length - 1]);
+      dedupedStreamUpdates += group.length - 1;
+    } else {
+      counted.push(...group);
+    }
+  }
+  counted.push(...singles);
+  let reportedTotal = 0;
+  let estimatedTotal = 0;
+  for (const e of counted) {
+    const total = e.usage.usableTotal;
+    if (total == null) continue;
+    if (e.usage.accuracy === 'reported') reportedTotal += total;
+    else if (e.usage.accuracy === 'estimated') estimatedTotal += total;
+  }
+  const unknownTurns = events.filter(
+    (e) =>
+      e.eventType === 'message' &&
+      e.role === 'assistant' &&
+      (!e.usage || !['reported', 'estimated'].includes(e.usage.accuracy))
+  ).length;
+  return { reportedTotal, estimatedTotal, unknownTurns, countedRequests: counted.length, dedupedStreamUpdates };
+}
+
+export function coverageMetrics(events, tasks, tokens) {
+  const sessions = new Set(
+    events.filter((e) => e.eventType !== 'commit' && e.sessionId).map((e) => e.sessionId)
+  );
+  const userPrompts = events.filter((e) => e.eventType === 'message' && e.role === 'user').length;
+  const commits = events.filter((e) => e.eventType === 'commit').length;
+  const ts = events.map((e) => e.timestamp).filter(Boolean).sort();
+  const assistant = events.filter((e) => e.eventType === 'message' && e.role === 'assistant');
+  const pct = (n, d) => (d ? Math.round((n / d) * 1000) / 1000 : 0);
+  const reportedPct = pct(assistant.filter((e) => e.usage?.accuracy === 'reported').length, assistant.length);
+  const estimatedPct = pct(assistant.filter((e) => e.usage?.accuracy === 'estimated').length, assistant.length);
+  const explicitPct = pct(tasks.filter((t) => t.grouping === 'explicit').length, tasks.length);
+  const confidence =
+    reportedPct >= 0.7 && explicitPct >= 0.5 ? 'high' : reportedPct >= 0.4 || explicitPct >= 0.5 ? 'medium' : 'low';
+  return {
+    sessions: sessions.size,
+    userPrompts,
+    commits,
+    window: { start: ts[0] ?? null, end: ts[ts.length - 1] ?? null },
+    tokenCoverage: { reportedTurnsPct: reportedPct, estimatedTurnsPct: estimatedPct, unknownTurns: tokens.unknownTurns },
+    confidence
+  };
+}

package/.claude/skills/tutien/scripts/normalize-events.mjs

@@ -0,0 +1,68 @@
+import crypto from 'node:crypto';
+import { redactText } from './redact.mjs';
+
+export const sha16 = (s) => crypto.createHash('sha256').update(s).digest('hex').slice(0, 16);
+
+const digestOrNull = (v) => (v == null ? null : sha16(String(v)));
+
+// Timestamps are canonicalized to UTC ISO or dropped; free-form strings never
+// pass through as metadata.
+function canonicalTimestamp(ts) {
+  if (ts == null) return null;
+  const t = Date.parse(ts);
+  return Number.isFinite(t) ? new Date(t).toISOString() : null;
+}
+
+// A usage record is usable only when a positive, finite total can be
+// computed. An export claiming accuracy=reported with no numbers must not
+// unlock token coverage or a realm score.
+function usableTotal(u) {
+  if (Number.isFinite(u.total) && u.total > 0) return u.total;
+  const sum = (u.input ?? 0) + (u.output ?? 0) + (u.reasoning ?? 0);
+  return Number.isFinite(sum) && sum > 0 ? sum : null;
+}
+
+// Raw adapter events -> normalized events. The event source is owned by the
+// caller (analyze overwrites `__source` per adapter batch), never by the
+// export content. Free text is redacted once and kept in memory only.
+// Session, task, and label identifiers are digested so metadata fields can
+// never carry raw content into analysis output; commit subjects are dropped
+// (their redacted form already travels as event text).
+export function normalizeEvents(rawEvents) {
+  return rawEvents.map((raw, i) => {
+    const source = raw.__source ?? 'generic-jsonl';
+    const text = raw.text != null ? redactText(raw.text) : null;
+    const sessionId = digestOrNull(raw.session);
+    let usage = null;
+    if (raw.usage) {
+      const total = usableTotal(raw.usage);
+      usage = {
+        input: raw.usage.input ?? null,
+        cachedInput: raw.usage.cachedInput ?? null,
+        output: raw.usage.output ?? null,
+        reasoning: raw.usage.reasoning ?? null,
+        total: raw.usage.total ?? null,
+        usableTotal: total,
+        accuracy: total == null ? 'unknown' : (raw.usage.accuracy ?? 'unknown'),
+        requestId: raw.usage.requestId ?? null,
+        cumulative: raw.usage.cumulative === true
+      };
+    }
+    return {
+      eventId: sha16(`${source}:${sessionId ?? ''}:${i}:${raw.type}:${text ?? ''}`),
+      source,
+      sessionId,
+      taskId: digestOrNull(raw.task),
+      timestamp: canonicalTimestamp(raw.ts),
+      role: raw.role ?? (raw.type === 'commit' ? 'git' : raw.type === 'message' ? null : 'tool'),
+      eventType: raw.type,
+      text,
+      textDigest: text ? sha16(text) : null,
+      textLength: text ? text.length : 0,
+      usage,
+      outcome: raw.outcome ?? null,
+      label: digestOrNull(raw.label),
+      commit: raw.commit ? { hash: raw.commit.hash ?? null, isRevert: raw.commit.isRevert === true } : null
+    };
+  });
+}

package/.claude/skills/tutien/scripts/redact.mjs

@@ -0,0 +1,30 @@
+// Redaction layer: every piece of ingested text passes through here before
+// any other module sees it. Raw secret-bearing input never leaves this file.
+
+const SENSITIVE_QUERY_KEY = /^(token|key|secret|password|passwd|pwd|auth|authorization|signature|sig|code|apikey|api_key|access_token|session)$/i;
+
+export function sanitizeUrl(url) {
+  try {
+    const u = new URL(url);
+    u.username = '';
+    u.password = '';
+    for (const k of [...u.searchParams.keys()]) {
+      if (SENSITIVE_QUERY_KEY.test(k)) u.searchParams.set(k, 'REDACTED');
+    }
+    u.hash = '';
+    return u.toString();
+  } catch {
+    return '[unparseable-url-redacted]';
+  }
+}
+
+const URL_RE = /\bhttps?:\/\/[^\s<>"')\]]+/gi;
+const BEARER_RE = /\b(bearer|token|apikey|api[-_]key|authorization)([:=]\s*)\S+/gi;
+const AWS_KEY_RE = /\bAKIA[0-9A-Z]{16}\b/g;
+
+export function redactText(text) {
+  return String(text)
+    .replace(URL_RE, (m) => sanitizeUrl(m))
+    .replace(BEARER_RE, (_m, k, sep) => `${k}${sep}[REDACTED]`)
+    .replace(AWS_KEY_RE, '[REDACTED]');
+}