@nurix/etna 0.15.6 → 0.15.8

package/data/harnesses/code/hooks/session-stop.js

@@ -1,207 +0,0 @@
-// harness/code/hooks/session-stop.js — SessionEnd hook: append one cheap session-summary ledger entry.
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-const { execFileSync } = require("child_process");
-const { redact } = require("./lib/redact.js");
-
-// Read all of stdin synchronously; returns "" if nothing is piped.
-function readStdin() {
-  try {
-    return fs.readFileSync(0, "utf8");
-  } catch (e) {
-    return "";
-  }
-}
-
-// Resolve the project root: CLAUDE_PROJECT_DIR env, else payload cwd, else process cwd.
-function resolveProjectDir(payload) {
-  return process.env.CLAUDE_PROJECT_DIR || (payload && payload.cwd) || process.cwd();
-}
-
-// Run a git command in projectDir; returns trimmed stdout or fallback on any error.
-function git(projectDir, args, fallback) {
-  try {
-    return execFileSync("git", ["-C", projectDir, ...args], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim() || fallback;
-  } catch (e) {
-    return fallback;
-  }
-}
-
-// Slug a raw actor name into kebab-case ASCII.
-function slugActor(name) {
-  return String(name || "")
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-
-// Determine the actor: git user.name (slugged) → $USER → "agent".
-function resolveActor(projectDir) {
-  const fromGit = slugActor(git(projectDir, ["config", "user.name"], ""));
-  if (fromGit) return fromGit;
-  const fromEnv = slugActor(process.env.USER || "");
-  if (fromEnv) return fromEnv;
-  return "agent";
-}
-
-// Truncate a single line to n chars with an ellipsis marker.
-function truncate(text, n) {
-  const clean = String(text || "").replace(/\s+/g, " ").trim();
-  return clean.length > n ? clean.slice(0, n) + "…" : clean;
-}
-
-// Parse the JSONL transcript into a cheap mechanical summary.
-function summarizeTranscript(transcriptPath) {
-  const summary = { firstPrompt: "", assistantTurns: 0, files: new Set(), lastAssistant: "", sawCommit: false };
-  try {
-    if (!transcriptPath || !fs.existsSync(transcriptPath)) return summary;
-    const lines = fs.readFileSync(transcriptPath, "utf8").split("\n");
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      let row;
-      try {
-        row = JSON.parse(line);
-      } catch (e) {
-        continue;
-      }
-      const msg = row && row.message ? row.message : row;
-      const role = (msg && msg.role) || row.type;
-      if (role === "user" && !summary.firstPrompt) {
-        summary.firstPrompt = extractText(msg);
-      }
-      if (role === "assistant") {
-        summary.assistantTurns += 1;
-        const text = extractText(msg);
-        if (text) summary.lastAssistant = text;
-        collectToolUse(msg, summary);
-      }
-    }
-  } catch (e) {
-    // Best-effort summary; ignore parse issues.
-  }
-  return summary;
-}
-
-// Extract plain text from a message whose content is a string or content-block array.
-function extractText(msg) {
-  if (!msg || !msg.content) return "";
-  if (typeof msg.content === "string") return msg.content;
-  if (Array.isArray(msg.content)) {
-    return msg.content
-      .filter((b) => b && b.type === "text" && typeof b.text === "string")
-      .map((b) => b.text)
-      .join(" ");
-  }
-  return "";
-}
-
-// Scan an assistant message's tool_use blocks for edited files and git commits.
-function collectToolUse(msg, summary) {
-  if (!msg || !Array.isArray(msg.content)) return;
-  for (const block of msg.content) {
-    if (!block || block.type !== "tool_use") continue;
-    const name = block.name || "";
-    const input = block.input || {};
-    if (/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(name) && input.file_path) {
-      summary.files.add(input.file_path);
-    }
-    if (name === "Bash" && typeof input.command === "string" && /\bgit\s+commit\b/.test(input.command)) {
-      summary.sawCommit = true;
-    }
-  }
-}
-
-// Compute the ledger day-file path for a given actor and date.
-function ledgerPath(projectDir, date, actor) {
-  const dir = path.join(projectDir, "docs", "memory", "ledger");
-  return { dir, file: path.join(dir, `${date}--${actor}.md`) };
-}
-
-// Build the day-file header block.
-function header(date, actor) {
-  return `# Ledger — ${date} — ${actor}\nAppend-only event ledger. Raw input to distillation — see docs/memory/.\n`;
-}
-
-// Skip if the day-file's last entry was written by this session within the current minute.
-function isDuplicate(file, sessionId, hhmm) {
-  try {
-    if (!sessionId || !fs.existsSync(file)) return false;
-    const text = fs.readFileSync(file, "utf8");
-    const idx = text.lastIndexOf("\n## ");
-    const tail = idx >= 0 ? text.slice(idx) : text;
-    return tail.includes(`session ${sessionId}`) && tail.includes(`## ${hhmm} `);
-  } catch (e) {
-    return false;
-  }
-}
-
-// Main: assemble and append one session-summary entry, never blocking.
-function main() {
-  const raw = readStdin();
-  let payload = {};
-  try {
-    payload = raw ? JSON.parse(raw) : {};
-  } catch (e) {
-    payload = {};
-  }
-
-  const projectDir = resolveProjectDir(payload);
-  const actor = resolveActor(projectDir);
-  const repo = path.basename(projectDir);
-  const branch = git(projectDir, ["rev-parse", "--abbrev-ref", "HEAD"], "-");
-
-  const now = new Date();
-  const pad = (n) => String(n).padStart(2, "0");
-  const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
-  const hhmm = `${pad(now.getHours())}:${pad(now.getMinutes())}`;
-
-  const summary = summarizeTranscript(payload.transcript_path);
-  const sessionId = payload.session_id || "";
-
-  // Nothing meaningful to record (garbage/empty payload, unreadable transcript) → silent no-op.
-  if (summary.assistantTurns === 0 && !summary.firstPrompt) return;
-
-  const { dir, file } = ledgerPath(projectDir, date, actor);
-  if (isDuplicate(file, sessionId, hhmm)) return;
-
-  const type = summary.sawCommit ? "decision" : summary.assistantTurns > 0 ? "action" : "observation";
-  const fileCount = summary.files.size;
-  const whatBits = [];
-  if (summary.firstPrompt) whatBits.push(`task "${truncate(redact(summary.firstPrompt), 100)}"`);
-  whatBits.push(`${summary.assistantTurns} turns`);
-  if (fileCount) whatBits.push(`${fileCount} file${fileCount === 1 ? "" : "s"} edited`);
-  const what = whatBits.join(", ") || "session ended";
-
-  const lines = [`## ${hhmm} · ${actor} · ${repo}@${branch}`, `- type: ${type}`, `- what: ${redact(what)}`];
-  if (summary.lastAssistant) {
-    lines.push(`- why: ${truncate(redact(summary.lastAssistant), 100)}`);
-  }
-  const refs = [];
-  if (sessionId) refs.push(`session ${sessionId}`);
-  if (fileCount) refs.push(`${fileCount} files`);
-  if (refs.length) lines.push(`- refs: ${redact(refs.join(" · "))}`);
-
-  const exists = fs.existsSync(file);
-  fs.mkdirSync(dir, { recursive: true });
-  const block = (exists ? "\n" : header(date, actor) + "\n") + lines.join("\n") + "\n";
-  fs.appendFileSync(file, block, "utf8");
-}
-
-try {
-  main();
-} catch (e) {
-  try {
-    process.stderr.write(`session-stop hook: ${e && e.message ? e.message : e}\n`);
-  } catch (e2) {
-    // Nothing more we can do.
-  }
-} finally {
-  process.exit(0);
-}

package/data/harnesses/re/CLAUDE.md

@@ -1,146 +0,0 @@
-# Product Reverse-Engineering — Orchestrator
-
-This is the **policy** half of the `re` harness. The plugin ships the capabilities (11
-dimension-dumper agents + 3 `re-*` rules, one per pipeline phase); this file drives them. Together they reverse-engineer a
-product across every surface it exposes and dump a structured, provenance-tracked corpus into
-`research/<target>/`.
-
-A run is four modes, in order: **Discovery → Ingestion → Evaluation → Self-correction.** The main
-session drives all four — Ingestion and Evaluation fan out parallel sub-agents, and a sub-agent
-cannot spawn further sub-agents.
-
----
-
-## Access is a capability vector (the front gate)
-
-A target's access is four orthogonal axes, each `{value, confidence, evidence}` — and the vector
-decides which dimensions are reachable and which extraction method each uses:
-
-| Axis | Values | Unlocks | Case |
-|------|--------|---------|------|
-| **source** | full · partial · none | codebase, packages | open-source repo |
-| **runtime** | reachable · gated · none | deployed-client-bundle, api, infra-backend-fingerprint, wire-capture | deployed, no source |
-| **auth** | have-login · none | session | logged-in SaaS |
-| **presence** | rich · thin · none | docs, website, community | — |
-
-Targets light several axes at once. The full model + grade→method mapping is in
-`.claude/rules/re-discovery.md`.
-
----
-
-## The eleven dimensions → agents
-
-| Dimension / agent | | Dimension / agent |
-|---|--|---|
-| `codebase` | | `session` ⚠ |
-| `docs` | | `deployed-client-bundle` |
-| `packages` | | `infra-backend-fingerprint` |
-| `api` (+MCP) | | `wire-capture` ⚠ |
-| `website` | | `distribution-artifacts` |
-| `community` | | |
-
-Agent name = dimension name. ⚠ = gated (needs user authorization before dispatch). The catalog —
-detection signals + strategy + per-dimension artifacts — is in `.claude/rules/re-discovery.md`.
-
----
-
-## Mode 1 — Discovery
-
-Cheap, read-only. Scope the target, grade its access, detect which dimensions it exposes.
-
-1. **Scope-feasibility gate** — run the `.claude/rules/re-discovery.md` Part A (scope gate) algorithm: resolve
-   identity → ambiguity → ethics → suite-size → primitive → reachability. If the verdict isn't
-   `accept`, **halt** (present the narrowing/redirect prompt, or refuse). Write
-   `research/<target>/00-scope-verdict.md`.
-2. **Grade the access vector** (the four axes, with evidence) per `re-discovery` (Part B).
-3. **Probe each of the 11 dimensions** (cheap signals only); mark ✅ available / ⚠️ partial /
-   ❌ absent with evidence. An absent dimension is a finding.
-4. Write `research/<target>/00-recon-plan.md` — frontmatter carries `scope:` + the `access_grade`
-   vector; the body is the dimension-availability table + the per-dimension dump plan (warm entry
-   points) + the gating/ethics flags.
-
----
-
-## Mode 2 — Ingestion
-
-Dispatch one dumper per available dimension; dump exhaustively before context is lost. Every dumper
-writes `research/<target>/dimensions/<dim>/_summary.md` (with the **provenance frontmatter** —
-method · confidence · completeness · gaps) + `raw/`, obeying `.claude/rules/re-ingestion.md`.
-
-- **Run independents in parallel** — dispatch `docs`, `packages`, `api`, `website`, `community`,
-  `deployed-client-bundle`, `infra-backend-fingerprint`, `distribution-artifacts` together
-  (`subagent_type='<dimension>'`, one message, multiple Agent calls). Seed each dumper with **warm
-  entry points (URLs / repos / hosts), not claimed facts** — any fact carried from Discovery (a price,
-  a tier name, a version) is tagged `verify:may-be-stale` so the dumper re-derives it instead of
-  anchoring on a possibly-stale value. Only one dimension may drive the browser at a time (see
-  `re-ingestion` §7 rule 9): the parallel dumpers use WebFetch/curl, leaving Chrome to `session`.
-- **Codebase fan-out** — dispatch `codebase`; it clones + maps + returns a per-package work-list;
-  then the main session fans out one reader per substantial package.
-- **Gated dimensions** — `session` and `wire-capture` (rung ≥2) need explicit user authorization
-  first (see `re-ingestion` §7). `session` follows `.claude/rules/re-ingestion.md` §9. When `session`
-  is authorized, **dispatch the non-browser dumpers in the background (`run_in_background`) and drive
-  the gated browser session in the main session concurrently** — they don't contend (Chrome belongs to
-  the main session; the dumpers use WebFetch/curl), so the whole of Ingestion runs in parallel.
-- **Shared seam** — bundle/session/wire each contribute to the canonical `raw/api-path-catalog.md`
-  with a `source:` column; don't triplicate.
-
-Validate each return (`_summary.md` + provenance present). A `blocked`/`partial` return is recorded,
-not blindly re-run.
-
----
-
-## Mode 3 — Evaluation
-
-Reconcile the dumps into four cross-dimension rollups under `research/<target>/evaluation/`, plus
-the run `README.md`, **weighting every claim by how it was obtained**. Follow
-`.claude/rules/re-evaluation.md`: read each dimension's provenance frontmatter first; anchor +
-provenance-tag every claim `(api: raw/endpoint-catalog.md · openapi-verbatim · high)`; weight
-(max-of-sources, promote one band only on ≥2 *independent* dimensions, never average); present
-high→fact, low/single-source→tentative, conflict→flagged. The four rollups: `technology-architecture`,
-`product-features`, `data-model-api-surface`, `competitive-positioning`.
-
----
-
-## Mode 4 — Self-correction (the harness improves itself, never silently)
-
-Read the finished run (scope verdict, plan, every dimension `_summary.md`, the rollups) and detect
-where the harness under-delivered (method ≠ planned, missing artifacts, low completeness, blocked
-where predicted available). Write **one** file — `research/<target>/04-self-correction-proposal.md`
-— an ordered table of proposed fixes, each routed to its target file (`re-discovery` /
-`re-ingestion` / `re-evaluation` / an agent), with severity, an
-additive/structural flag, and a `research/<target>/…` evidence anchor.
-
-**Approval gate:** present the table and STOP — nothing is applied. The user accepts / rejects /
-defers per item. Then the **main session** (not a sub-agent) applies accepted items, flips each row
-to APPLIED, and logs the change. Promote only what the *next, different* target would also hit;
-prefer additive edits; structural edits are flagged, never auto-applied.
-
----
-
-## Ethics (non-negotiable)
-
-For spec-writing, integration planning, and competitive analysis — **not** credential theft,
-rate-limit bypass, or scraping. Full rules: `.claude/rules/re-ingestion.md` §7.
-
-- **Never enter credentials.** The user logs in; `session` and `wire-capture` rung 3 are opt-in.
-- **Redact every secret before writing `raw/`.** Cookies/tokens/JWT-signatures/API-keys never hit disk.
-- **wire-capture** climbs the 3-rung ladder (browser-tap → HAR → mitmproxy); rung 3 is user-run,
-  first-party traffic only. Wireshark is not used (TLS ciphertext).
-- **Confirm before any state change or cost.** **No destructive actions, no exfiltration.** Respect TOS/robots.
-
----
-
-## Output contract
-
-```
-research/<target>/
-├── 00-scope-verdict.md            ← Discovery: accept/narrow/redirect/refuse
-├── 00-recon-plan.md               ← Discovery: access_grade + scope + dimension plan
-├── dimensions/<dim>/{_summary.md, raw/}   ← Ingestion (session & wire-capture also: captures/, curls.md)
-├── evaluation/{technology-architecture, product-features, data-model-api-surface, competitive-positioning}.md
-├── README.md                      ← Evaluation: run story + headline findings
-└── 04-self-correction-proposal.md ← Self-correction: proposed harness fixes (approval-gated)
-```
-
-Cloned repos live in `source/<target>/`. Provenance is the "self-aware" layer: each dump records
-*how* it was obtained; Evaluation weights claims by it. Detailed shapes live in the `re-*` rules.

package/data/harnesses/re/harness.json

@@ -1,6 +0,0 @@
-{
-  "name": "re",
-  "version": "0.1.2",
-  "epoch": null,
-  "digest": "29a864bc5245"
-}