@event4u/agent-config 16.2.0 → 16.3.0

package/dist/cli-delegate/chunk-ULQRUR23.js

@@ -0,0 +1,208 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/gitignore_block.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var SECTION_HEADER = "# event4u/agent-config";
+var SECTION_FOOTER = "# event4u/agent-config \u2014 END";
+var DEFAULT_GITIGNORE = ".gitignore";
+var _HERE = fileURLToPath(import.meta.url);
+var DEFAULT_TEMPLATE = path.join(
+  path.dirname(_HERE),
+  "..",
+  "..",
+  "..",
+  "src",
+  "config",
+  "gitignore-block.txt"
+);
+var LEGACY_PATTERNS = [
+  ".agent-chat-history",
+  ".agent-chat-history.bak",
+  ".agent-chat-history.*.bak",
+  ".agent-prices.md",
+  ".council-tmp/",
+  // 2.x intermediate: prices cache lived directly under agents/ before
+  // consolidating under agents/runtime/.
+  "agents/.agent-prices.md",
+  // Budget history JSONLs — previously listed explicitly at project
+  // root or under agents/; now covered by the /agents/runtime/
+  // catch-all in the managed block.
+  ".augment-budget-history.jsonl",
+  ".rule-budget-history.jsonl",
+  "agents/.augment-budget-history.jsonl",
+  "agents/.rule-budget-history.jsonl"
+];
+function _strip(ln) {
+  return ln.replace(/\n+$/, "").replace(/\s+$/, "");
+}
+function _is_entry(ln) {
+  const s = _strip(ln).replace(/^\s+/, "");
+  return Boolean(s) && !s.startsWith("#");
+}
+var TemplateNotFoundError = class extends Error {
+  constructor(p) {
+    super(`template not found: ${p}`);
+    this.name = "TemplateNotFoundError";
+  }
+};
+function _isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _splitlines(text) {
+  if (text === "") return [];
+  const parts = text.split(/\r\n|\r|\n/);
+  if (parts.length > 0 && parts[parts.length - 1] === "") parts.pop();
+  return parts;
+}
+function load_template(p) {
+  if (!_isFile(p)) {
+    throw new TemplateNotFoundError(p);
+  }
+  const text = fs.readFileSync(p, "utf-8");
+  return _splitlines(text).map(_strip);
+}
+function find_block(lines) {
+  for (let i = 0; i < lines.length; i += 1) {
+    if (_strip(lines[i]) === SECTION_HEADER) {
+      const start = i;
+      for (let j = i + 1; j < lines.length; j += 1) {
+        if (_strip(lines[j]) === SECTION_FOOTER) {
+          return [start, j + 1];
+        }
+      }
+      let end = lines.length;
+      for (let j = i + 1; j < lines.length; j += 1) {
+        const s = _strip(lines[j]).replace(/^\s+/, "");
+        if (s.startsWith("#") && !s.startsWith("# Agent config") && s !== SECTION_HEADER) {
+          end = j;
+          while (end > i + 1 && _strip(lines[end - 1]) === "") {
+            end -= 1;
+          }
+          break;
+        }
+      }
+      return [start, end];
+    }
+  }
+  return null;
+}
+function block_entries(block_lines) {
+  return block_lines.filter((ln) => _is_entry(ln)).map((ln) => _strip(ln).replace(/^\s+/, ""));
+}
+function template_entries(template_lines) {
+  return template_lines.filter((ln) => _is_entry(ln)).map((ln) => ln.replace(/^\s+/, ""));
+}
+function build_fresh_block(template_lines) {
+  return [SECTION_HEADER, ...template_lines, SECTION_FOOTER];
+}
+function sync_block(existing_lines, template_lines, options = {}) {
+  const replace = options.replace ?? false;
+  const loc = find_block(existing_lines);
+  const fresh = build_fresh_block(template_lines);
+  if (loc === null) {
+    const newLines = [...existing_lines];
+    if (newLines.length > 0 && _strip(newLines[newLines.length - 1]) !== "") {
+      newLines.push("");
+    }
+    newLines.push(...fresh);
+    return [newLines, template_entries(template_lines)];
+  }
+  const [start, end] = loc;
+  const head = existing_lines.slice(0, start);
+  let block = existing_lines.slice(start, end);
+  const tail = existing_lines.slice(end);
+  if (replace) {
+    const existing = new Set(block_entries(block));
+    const added = template_entries(template_lines).filter((e) => !existing.has(e));
+    return [[...head, ...fresh, ...tail], added];
+  }
+  const existing_entries = new Set(block_entries(block));
+  const missing = template_entries(template_lines).filter((e) => !existing_entries.has(e));
+  if (missing.length === 0) {
+    return [[...existing_lines], []];
+  }
+  let insert_at;
+  if (block.length > 0 && _strip(block[block.length - 1]) === SECTION_FOOTER) {
+    insert_at = block.length - 1;
+  } else {
+    block = [...block, SECTION_FOOTER];
+    insert_at = block.length - 1;
+  }
+  const new_block = [...block.slice(0, insert_at), ...missing, ...block.slice(insert_at)];
+  return [[...head, ...new_block, ...tail], missing];
+}
+function cleanup_legacy(lines) {
+  const legacy = new Set(LEGACY_PATTERNS);
+  const kept = [];
+  const removed = [];
+  for (const ln of lines) {
+    const s = _strip(ln).replace(/^\s+/, "");
+    if (legacy.has(s) || s.startsWith("/") && legacy.has(s.slice(1))) {
+      removed.push(s);
+      continue;
+    }
+    kept.push(ln);
+  }
+  return [kept, removed];
+}
+function format_file(lines) {
+  const text = lines.join("\n");
+  return text.replace(/\n+$/, "") + "\n";
+}
+function write_managed_block(project_root, dry_run) {
+  const target = path.join(project_root, DEFAULT_GITIGNORE);
+  let template;
+  try {
+    template = load_template(DEFAULT_TEMPLATE);
+  } catch {
+    return 0;
+  }
+  let existing = [];
+  if (_isFile(target)) {
+    existing = _splitlines(fs.readFileSync(target, "utf-8"));
+  } else if (!_isFile(path.join(project_root, ".git")) && !_isDir(path.join(project_root, ".git"))) {
+    return 0;
+  }
+  const [lines, added] = sync_block(existing, template);
+  if (added.length === 0 || dry_run) return added.length;
+  try {
+    fs.writeFileSync(target, format_file(lines), "utf-8");
+  } catch {
+    return 0;
+  }
+  return added.length;
+}
+function _isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export {
+  SECTION_HEADER,
+  SECTION_FOOTER,
+  DEFAULT_GITIGNORE,
+  DEFAULT_TEMPLATE,
+  LEGACY_PATTERNS,
+  _strip,
+  TemplateNotFoundError,
+  _isFile,
+  _splitlines,
+  load_template,
+  find_block,
+  block_entries,
+  template_entries,
+  build_fresh_block,
+  sync_block,
+  cleanup_legacy,
+  format_file,
+  write_managed_block
+};

package/dist/cli-delegate/{chunk-NUHLI2RX.js → chunk-YCU3TIXH.js}

@@ -28,6 +28,7 @@ function _deriveRoots(root) {
   };
 }
 var _roots = _deriveRoots(_DEFAULT_ROOT);
+var SRC_SKILLS = () => _roots.SRC_SKILLS;
 function _isDir(p) {
   try {
     return fs.statSync(p).isDirectory();
@@ -76,5 +77,6 @@ function artefact_roots() {
 }
 
 export {
+  SRC_SKILLS,
   artefact_roots
 };

package/dist/cli-delegate/chunk-ZBZV2G5R.js

@@ -0,0 +1,210 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/lexical_index.ts
+var BM25_K1 = 1.5;
+var BM25_B = 0.75;
+var MIN_TOKEN_LEN = 2;
+function tokenize(s) {
+  const out = [];
+  for (const raw of s.toLowerCase().split(/[^a-z0-9]+/)) {
+    if (raw.length >= MIN_TOKEN_LEN) out.push(raw);
+  }
+  return out;
+}
+function trigrams(s) {
+  const norm = s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  const out = /* @__PURE__ */ new Set();
+  if (norm.length < 3) {
+    if (norm.length > 0) out.add(norm);
+    return out;
+  }
+  for (let i = 0; i + 3 <= norm.length; i++) {
+    out.add(norm.slice(i, i + 3));
+  }
+  return out;
+}
+var LexicalIndex = class {
+  docs = /* @__PURE__ */ new Map();
+  df = /* @__PURE__ */ new Map();
+  n;
+  avgdl;
+  constructor(documents) {
+    let totalLen = 0;
+    for (const d of documents) {
+      const tokens = tokenize(d.text);
+      const tf = /* @__PURE__ */ new Map();
+      for (const t of tokens) tf.set(t, (tf.get(t) ?? 0) + 1);
+      for (const t of tf.keys()) this.df.set(t, (this.df.get(t) ?? 0) + 1);
+      this.docs.set(d.id, { id: d.id, len: tokens.length, tf, trigrams: trigrams(d.text) });
+      totalLen += tokens.length;
+    }
+    this.n = documents.length;
+    this.avgdl = this.n > 0 ? totalLen / this.n : 0;
+  }
+  /** Robertson–Spärck-Jones IDF, floored at 0 so common terms never subtract. */
+  idf(term) {
+    const df = this.df.get(term) ?? 0;
+    if (df === 0) return 0;
+    return Math.max(0, Math.log(1 + (this.n - df + 0.5) / (df + 0.5)));
+  }
+  /**
+   * BM25 score of one document against the tokenised query terms, weighted by
+   * **term coverage**: the raw BM25 sum is multiplied by `coverage²`, where
+   * `coverage = distinct-query-terms-matched / distinct-query-terms`. This
+   * stops a single generic, high-TF term match from outranking a document that
+   * matches several rarer query terms once each (Phase 1 refinement). A
+   * single-term query has `coverage == 1`, so its score is unchanged — the
+   * weighting only re-orders genuinely multi-term queries.
+   */
+  score(queryTerms, docId) {
+    const doc = this.docs.get(docId);
+    if (doc === void 0 || doc.len === 0) return 0;
+    let s = 0;
+    const matched = /* @__PURE__ */ new Set();
+    for (const term of queryTerms) {
+      const tf = doc.tf.get(term);
+      if (tf === void 0) continue;
+      const idf = this.idf(term);
+      if (idf === 0) continue;
+      const denom = tf + BM25_K1 * (1 - BM25_B + BM25_B * doc.len / (this.avgdl || 1));
+      s += idf * (tf * (BM25_K1 + 1)) / denom;
+      matched.add(term);
+    }
+    if (s === 0) return 0;
+    const distinctQuery = new Set(queryTerms).size;
+    const coverage = distinctQuery > 0 ? matched.size / distinctQuery : 1;
+    return s * coverage * coverage;
+  }
+  /**
+   * Rank documents for a set of query keys (phrases are tokenised). A
+   * character-trigram prefilter selects candidates cheaply; the guard keeps
+   * any doc sharing a query TOKEN even when no trigram overlaps, so the
+   * prefilter never drops a genuine lexical match. Ties break by id for a
+   * stable, deterministic order.
+   */
+  rank(queryKeys) {
+    const queryText = queryKeys.join(" ");
+    const qTerms = tokenize(queryText);
+    const qTermSet = new Set(qTerms);
+    const qTrigrams = trigrams(queryText);
+    const candidates = [];
+    for (const [id, doc] of this.docs) {
+      let hit = false;
+      for (const t of qTrigrams) {
+        if (doc.trigrams.has(t)) {
+          hit = true;
+          break;
+        }
+      }
+      if (!hit) {
+        for (const t of qTermSet) {
+          if (doc.tf.has(t)) {
+            hit = true;
+            break;
+          }
+        }
+      }
+      if (hit) candidates.push(id);
+    }
+    const scored = candidates.map((id) => ({ id, score: this.score(qTerms, id) })).filter((r) => r.score > 0);
+    scored.sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return scored;
+  }
+  /** Document count — for the caller's tripwire / diagnostics. */
+  get size() {
+    return this.n;
+  }
+};
+
+// src/scripts/_lib/sqlite_guard.ts
+import { createRequire } from "node:module";
+var SqliteUnavailableError = class extends Error {
+  constructor(callerName, cause) {
+    super(
+      `node:sqlite is unavailable in this runtime (${cause}). ${callerName} requires Node with the built-in SQLite module.`
+    );
+    this.name = "SqliteUnavailableError";
+  }
+};
+var _sqliteWarningSilenced = false;
+function _silenceSqliteExperimentalWarning() {
+  if (_sqliteWarningSilenced) return;
+  _sqliteWarningSilenced = true;
+  const orig = process.emitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    const text = typeof warning === "string" ? warning : warning?.message ?? "";
+    if (/SQLite is an experimental/i.test(text)) return;
+    orig(warning, ...rest);
+  });
+}
+var _require;
+function _syncRequire() {
+  if (_require === void 0) {
+    _require = createRequire(import.meta.url);
+  }
+  return _require;
+}
+function loadSqliteSync(callerName) {
+  _silenceSqliteExperimentalWarning();
+  try {
+    return _syncRequire()("node:sqlite");
+  } catch (exc) {
+    const message = exc instanceof Error ? exc.message : String(exc);
+    throw new SqliteUnavailableError(callerName, message);
+  }
+}
+function isSqliteAvailableSync() {
+  _silenceSqliteExperimentalWarning();
+  try {
+    _syncRequire()("node:sqlite");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function probeFts5Sync() {
+  let sqlite;
+  try {
+    sqlite = loadSqliteSync("sqlite_guard.probeFts5Sync");
+  } catch {
+    return false;
+  }
+  let conn = null;
+  try {
+    conn = new sqlite.DatabaseSync(":memory:");
+    conn.exec("CREATE VIRTUAL TABLE _fts5_probe USING fts5(body)");
+    conn.exec("INSERT INTO _fts5_probe(body) VALUES ('probe')");
+    const row = conn.prepare("SELECT body FROM _fts5_probe WHERE _fts5_probe MATCH 'probe'").get();
+    return row !== void 0;
+  } catch {
+    return false;
+  } finally {
+    try {
+      conn?.close();
+    } catch {
+    }
+  }
+}
+function readUserVersion(conn) {
+  const row = conn.prepare("PRAGMA user_version").get();
+  const v = row?.["user_version"];
+  if (typeof v === "bigint") return Number(v);
+  if (typeof v === "number") return v;
+  return 0;
+}
+function stampUserVersion(conn, version) {
+  if (!Number.isInteger(version) || version < 0 || version > 2 ** 31 - 1) {
+    throw new RangeError(`stampUserVersion: version out of range: ${version}`);
+  }
+  conn.exec(`PRAGMA user_version = ${version}`);
+}
+
+export {
+  tokenize,
+  LexicalIndex,
+  loadSqliteSync,
+  isSqliteAvailableSync,
+  probeFts5Sync,
+  readUserVersion,
+  stampUserVersion
+};

package/dist/cli-delegate/{chunk-WGXTVKCQ.js → chunk-ZUZKZYCN.js}

@@ -1,13 +1,15 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   buildInstallPlan,
-  classifyOwnership,
-  recordedHashesForRoot,
   sha256File
-} from "./chunk-YDPILCOL.js";
+} from "./chunk-523HCFYO.js";
 import {
   detectToolPresence
 } from "./chunk-A4QJ6ENT.js";
+import {
+  classifyOwnership,
+  recordedHashesForRoot
+} from "./chunk-OKJUIAPS.js";
 
 // src/install/preflight.ts
 import { accessSync, constants, existsSync as existsSync2, statSync } from "node:fs";

package/dist/cli-delegate/cmd_analyze_session.js

@@ -7,7 +7,7 @@ import {
 import {
   ProjectRootError,
   resolve_project_root
-} from "./chunk-FC75PGJE.js";
+} from "./chunk-JY2I2DXV.js";
 import "./chunk-NDJLNC6Q.js";
 import "./chunk-J55WI3RR.js";
 

package/dist/cli-delegate/cmd_brand_status.js

@@ -1,7 +1,7 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   resolve_project_root
-} from "./chunk-FC75PGJE.js";
+} from "./chunk-JY2I2DXV.js";
 import "./chunk-NDJLNC6Q.js";
 import "./chunk-J55WI3RR.js";