u-foo 2.5.13 → 2.5.15

package/src/code/context/artifactGc.js

@@ -0,0 +1,292 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { getArtifactsDir, loadArtifact, saveArtifact } = require("./artifacts");
+
+const DEFAULT_MAX_ARTIFACTS = 200;
+const DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_MAX_SESSION_BYTES = 64 * 1024 * 1024;
+/** Minimum gap between automatic GC passes during session saves. */
+const DEFAULT_GC_MIN_INTERVAL_MS = 2 * 60 * 1000;
+const GC_STAMP_NAME = ".gc-stamp";
+
+function listArtifactFiles(workspaceRoot = process.cwd(), sessionId = "") {
+  const dir = getArtifactsDir(workspaceRoot, sessionId);
+  if (!fs.existsSync(dir)) return [];
+  try {
+    return fs.readdirSync(dir)
+      .filter((name) => name.endsWith(".json"))
+      .map((name) => {
+        const filePath = path.join(dir, name);
+        let stat = null;
+        try {
+          stat = fs.statSync(filePath);
+        } catch {
+          stat = null;
+        }
+        return {
+          artifactId: name.replace(/\.json$/, ""),
+          filePath,
+          sizeBytes: stat ? stat.size : 0,
+          mtimeMs: stat ? stat.mtimeMs : 0,
+        };
+      });
+  } catch {
+    return [];
+  }
+}
+
+function markArtifactCold(workspaceRoot = process.cwd(), sessionId = "", artifactId = "") {
+  const loaded = loadArtifact(workspaceRoot, sessionId, artifactId);
+  if (!loaded.ok || !loaded.artifact) {
+    return { ok: false, error: loaded.error || "artifact not found", artifact: null };
+  }
+  const artifact = { ...loaded.artifact };
+  if (artifact.cold === true) {
+    return { ok: true, error: "", artifact, alreadyCold: true };
+  }
+  const preview = String(artifact.summary || "").slice(0, 600);
+  artifact.cold = true;
+  artifact.coldAt = new Date().toISOString();
+  artifact.raw = {
+    ok: true,
+    cold: true,
+    preview,
+    note: "raw content evicted; use transcript preview or re-run tool",
+  };
+  // Preserve existing index; avoid rebuild from cold stub
+  const saved = saveArtifact(workspaceRoot, sessionId, {
+    ...artifact,
+    index: artifact.index || {},
+  });
+  return {
+    ok: saved.ok,
+    error: saved.error || "",
+    artifact: saved.artifact,
+    alreadyCold: false,
+  };
+}
+
+function resolveGcOptions(options = {}, env = process.env) {
+  const maxArtifacts = Number.isFinite(options.maxArtifacts)
+    ? Math.max(1, Math.floor(options.maxArtifacts))
+    : (Number.parseInt(String(env.UFOO_UCODE_ARTIFACT_MAX_COUNT || ""), 10) || DEFAULT_MAX_ARTIFACTS);
+  const maxAgeMs = Number.isFinite(options.maxAgeMs)
+    ? Math.max(1000, Math.floor(options.maxAgeMs))
+    : (Number.parseInt(String(env.UFOO_UCODE_ARTIFACT_MAX_AGE_MS || ""), 10) || DEFAULT_MAX_AGE_MS);
+  const maxSessionBytes = Number.isFinite(options.maxSessionBytes)
+    ? Math.max(1024, Math.floor(options.maxSessionBytes))
+    : (Number.parseInt(String(env.UFOO_UCODE_ARTIFACT_MAX_BYTES || ""), 10) || DEFAULT_MAX_SESSION_BYTES);
+  const minIntervalMs = Number.isFinite(options.minIntervalMs)
+    ? Math.max(0, Math.floor(options.minIntervalMs))
+    : (Number.parseInt(String(env.UFOO_UCODE_ARTIFACT_GC_INTERVAL_MS || ""), 10) || DEFAULT_GC_MIN_INTERVAL_MS);
+  return {
+    maxArtifacts,
+    maxAgeMs,
+    maxSessionBytes,
+    minIntervalMs,
+    nowMs: Number.isFinite(options.nowMs) ? options.nowMs : Date.now(),
+    dryRun: options.dryRun === true,
+    force: options.force === true,
+  };
+}
+
+function getGcStampPath(workspaceRoot = process.cwd(), sessionId = "") {
+  return path.join(getArtifactsDir(workspaceRoot, sessionId), GC_STAMP_NAME);
+}
+
+function countArtifactJsonFiles(workspaceRoot = process.cwd(), sessionId = "") {
+  const dir = getArtifactsDir(workspaceRoot, sessionId);
+  if (!fs.existsSync(dir)) return 0;
+  try {
+    return fs.readdirSync(dir).filter((name) => name.endsWith(".json")).length;
+  } catch {
+    return 0;
+  }
+}
+
+function touchGcStamp(workspaceRoot = process.cwd(), sessionId = "", nowMs = Date.now()) {
+  const stampPath = getGcStampPath(workspaceRoot, sessionId);
+  try {
+    fs.mkdirSync(path.dirname(stampPath), { recursive: true });
+    fs.writeFileSync(stampPath, `${nowMs}\n`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Throttled GC for session save / lifecycle hooks.
+ * Skips when a recent `.gc-stamp` exists, unless force=true or artifact
+ * count already exceeds maxArtifacts (cheap readdir pressure bypass).
+ */
+function maybeGcSessionArtifacts(workspaceRoot = process.cwd(), sessionId = "", options = {}) {
+  const id = String(sessionId || "").trim();
+  if (!id) {
+    return {
+      ok: false,
+      error: "invalid session id",
+      skipped: true,
+      reason: "invalid_session",
+      scanned: 0,
+      actions: [],
+    };
+  }
+
+  const opts = resolveGcOptions(options);
+  const artifactsDir = getArtifactsDir(workspaceRoot, id);
+  if (!fs.existsSync(artifactsDir)) {
+    return {
+      ok: true,
+      error: "",
+      skipped: true,
+      reason: "no_artifacts_dir",
+      scanned: 0,
+      actions: [],
+      dryRun: opts.dryRun,
+    };
+  }
+
+  const stampPath = getGcStampPath(workspaceRoot, id);
+
+  if (!opts.force && opts.minIntervalMs > 0) {
+    let stampAgeOk = false;
+    try {
+      if (fs.existsSync(stampPath)) {
+        const st = fs.statSync(stampPath);
+        stampAgeOk = opts.nowMs - st.mtimeMs < opts.minIntervalMs;
+      }
+    } catch {
+      stampAgeOk = false;
+    }
+    if (stampAgeOk) {
+      const count = countArtifactJsonFiles(workspaceRoot, id);
+      if (count <= opts.maxArtifacts) {
+        return {
+          ok: true,
+          error: "",
+          skipped: true,
+          reason: "throttled",
+          scanned: count,
+          actions: [],
+          dryRun: opts.dryRun,
+        };
+      }
+    }
+  }
+
+  const result = gcSessionArtifacts(workspaceRoot, id, options);
+  if (!opts.dryRun) touchGcStamp(workspaceRoot, id, opts.nowMs);
+  return {
+    ...result,
+    skipped: false,
+    reason: opts.force ? "forced" : "interval",
+  };
+}
+
+function gcSessionArtifacts(workspaceRoot = process.cwd(), sessionId = "", options = {}) {
+  const opts = resolveGcOptions(options);
+  const files = listArtifactFiles(workspaceRoot, sessionId)
+    .sort((a, b) => a.mtimeMs - b.mtimeMs);
+  const planned = [];
+  const deletedIds = new Set();
+
+  for (const item of files) {
+    if (opts.nowMs - item.mtimeMs > opts.maxAgeMs) {
+      planned.push({ action: "cold", artifactId: item.artifactId, reason: "age" });
+    }
+  }
+
+  let live = files.slice();
+  let totalBytes = live.reduce((sum, item) => sum + item.sizeBytes, 0);
+  while (live.length > opts.maxArtifacts || totalBytes > opts.maxSessionBytes) {
+    const oldest = live.shift();
+    if (!oldest) break;
+    if (deletedIds.has(oldest.artifactId)) continue;
+    planned.push({
+      action: "delete",
+      artifactId: oldest.artifactId,
+      reason: totalBytes > opts.maxSessionBytes ? "size" : "count",
+    });
+    deletedIds.add(oldest.artifactId);
+    totalBytes -= oldest.sizeBytes;
+  }
+
+  // Prefer delete over cold for the same id
+  const byId = new Map();
+  for (const entry of planned) {
+    const prev = byId.get(entry.artifactId);
+    if (!prev || entry.action === "delete") byId.set(entry.artifactId, entry);
+  }
+  const actions = Array.from(byId.values());
+
+  const applied = [];
+  if (!opts.dryRun) {
+    for (const entry of actions) {
+      if (entry.action === "cold") {
+        const result = markArtifactCold(workspaceRoot, sessionId, entry.artifactId);
+        applied.push({ ...entry, ok: result.ok, error: result.error || "" });
+      } else if (entry.action === "delete") {
+        const filePath = path.join(getArtifactsDir(workspaceRoot, sessionId), `${entry.artifactId}.json`);
+        try {
+          if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+          applied.push({ ...entry, ok: true, error: "" });
+        } catch (err) {
+          applied.push({
+            ...entry,
+            ok: false,
+            error: err && err.message ? err.message : "delete failed",
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    ok: true,
+    error: "",
+    scanned: files.length,
+    actions: opts.dryRun ? actions : applied,
+    dryRun: opts.dryRun,
+  };
+}
+
+function deleteSessionCommitLog(workspaceRoot = process.cwd(), sessionId = "") {
+  const id = String(sessionId || "").trim();
+  if (!id) return { ok: false, error: "invalid session id" };
+  const filePath = path.join(
+    path.resolve(workspaceRoot || process.cwd()),
+    ".ufoo",
+    "agent",
+    "ucode",
+    "commits",
+    `${id}.jsonl`,
+  );
+  try {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    return { ok: true, error: "", filePath };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "failed to delete commit log",
+      filePath,
+    };
+  }
+}
+
+module.exports = {
+  DEFAULT_MAX_ARTIFACTS,
+  DEFAULT_MAX_AGE_MS,
+  DEFAULT_MAX_SESSION_BYTES,
+  DEFAULT_GC_MIN_INTERVAL_MS,
+  listArtifactFiles,
+  markArtifactCold,
+  gcSessionArtifacts,
+  maybeGcSessionArtifacts,
+  deleteSessionCommitLog,
+  resolveGcOptions,
+  getGcStampPath,
+  countArtifactJsonFiles,
+};

package/src/code/context/artifactIndex.js

@@ -0,0 +1,161 @@
+"use strict";
+
+const MAX_SYMBOLS = 80;
+const MAX_REGIONS = 40;
+
+function buildSymbolsFromContent(content = "", pathHint = "") {
+  const text = String(content || "");
+  const lines = text.split(/\r?\n/);
+  const symbols = [];
+  const patterns = [
+    { kind: "function", re: /^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_$]+)/ },
+    { kind: "class", re: /^(?:export\s+)?class\s+([A-Za-z0-9_$]+)/ },
+    { kind: "const", re: /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z0-9_$]+)\s*=/ },
+    { kind: "method", re: /^\s*(?:async\s+)?([A-Za-z0-9_$]+)\s*\([^)]*\)\s*\{/ },
+    { kind: "rust_fn", re: /^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([A-Za-z0-9_]+)/ },
+    { kind: "python_def", re: /^(?:async\s+)?def\s+([A-Za-z0-9_]+)/ },
+  ];
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    for (const pattern of patterns) {
+      const match = line.match(pattern.re);
+      if (!match) continue;
+      const name = String(match[1] || "").trim();
+      if (!name || name === "if" || name === "for" || name === "while" || name === "switch") continue;
+      symbols.push({
+        name,
+        kind: pattern.kind,
+        line: i + 1,
+        path: pathHint || "",
+      });
+      break;
+    }
+    if (symbols.length >= MAX_SYMBOLS) break;
+  }
+  return symbols;
+}
+
+function buildRegionsFromContent(content = "", pathHint = "") {
+  const text = String(content || "");
+  const lines = text.split(/\r?\n/);
+  const regions = [];
+  let current = null;
+
+  const startRe = /^(?:export\s+)?(?:async\s+)?(?:function|class)\s+[A-Za-z0-9_$]+|^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+[A-Za-z0-9_]+|^(?:async\s+)?def\s+[A-Za-z0-9_]+/;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (startRe.test(line)) {
+      if (current) {
+        current.endLine = i;
+        regions.push(current);
+      }
+      current = {
+        path: pathHint || "",
+        startLine: i + 1,
+        endLine: i + 1,
+        label: line.trim().slice(0, 120),
+      };
+    }
+    if (regions.length >= MAX_REGIONS) break;
+  }
+  if (current && regions.length < MAX_REGIONS) {
+    current.endLine = lines.length;
+    regions.push(current);
+  }
+  return regions;
+}
+
+function buildArtifactIndex({
+  tool = "",
+  raw = null,
+  args = {},
+} = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  const source = raw && typeof raw === "object" ? raw : {};
+  const pathHint = String((args && args.path) || source.path || "").trim();
+
+  if (name === "read" || name === "skill") {
+    const content = String(source.content || "");
+    return {
+      symbols: buildSymbolsFromContent(content, pathHint),
+      regions: buildRegionsFromContent(content, pathHint),
+      path: pathHint,
+      totalLines: content ? content.split(/\r?\n/).length : 0,
+    };
+  }
+
+  if (name === "bash") {
+    const command = String((args && args.command) || source.command || "");
+    const stdout = String(source.stdout || "");
+    if (/\bgit\s+(?:diff|show)\b/i.test(command)) {
+      const { parseGitDiffFiles } = require("./reducers");
+      return {
+        kind: "git_diff",
+        files: parseGitDiffFiles(stdout),
+        path: pathHint,
+      };
+    }
+    if (/\b(rg|ripgrep|grep)\b/i.test(command)) {
+      const { parseSearchMatches } = require("./reducers");
+      const matches = parseSearchMatches(stdout);
+      return {
+        kind: "search",
+        matchCount: matches.length,
+        paths: Array.from(new Set(matches.map((m) => m.path))).slice(0, 40),
+      };
+    }
+    if (/\b(npm test|jest|vitest|pytest|cargo test)\b/i.test(command)) {
+      const { extractTestFailures } = require("./reducers");
+      return {
+        kind: "test",
+        failures: extractTestFailures(stdout, String(source.stderr || "")),
+      };
+    }
+  }
+
+  return {};
+}
+
+function findSymbolInIndex(index = {}, symbolName = "") {
+  const target = String(symbolName || "").trim().toLowerCase();
+  if (!target) return null;
+  const symbols = index && Array.isArray(index.symbols) ? index.symbols : [];
+  return symbols.find((entry) => String(entry.name || "").toLowerCase() === target) || null;
+}
+
+function findRegionInIndex(index = {}, labelOrLine = "") {
+  const regions = index && Array.isArray(index.regions) ? index.regions : [];
+  if (regions.length === 0) return null;
+  const asLine = Number(labelOrLine);
+  if (Number.isFinite(asLine) && asLine > 0) {
+    return regions.find((region) => region.startLine <= asLine && region.endLine >= asLine) || null;
+  }
+  const label = String(labelOrLine || "").trim().toLowerCase();
+  if (!label) return null;
+  return regions.find((region) => String(region.label || "").toLowerCase().includes(label)) || null;
+}
+
+function selectorFromSymbol(index = {}, symbolName = "", padLines = 8) {
+  const symbol = findSymbolInIndex(index, symbolName);
+  if (!symbol) return null;
+  const startLine = Math.max(1, Number(symbol.line) - Math.max(0, padLines));
+  const endLine = Number(symbol.line) + Math.max(0, padLines);
+  return {
+    startLine,
+    endLine,
+    symbol: symbol.name,
+    kind: symbol.kind,
+  };
+}
+
+module.exports = {
+  MAX_SYMBOLS,
+  MAX_REGIONS,
+  buildSymbolsFromContent,
+  buildRegionsFromContent,
+  buildArtifactIndex,
+  findSymbolInIndex,
+  findRegionInIndex,
+  selectorFromSymbol,
+};

package/src/code/context/artifacts.js

@@ -0,0 +1,183 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { randomUUID } = require("crypto");
+
+function getArtifactsDir(workspaceRoot = process.cwd(), sessionId = "") {
+  const root = path.resolve(workspaceRoot || process.cwd());
+  const id = String(sessionId || "").trim();
+  if (!id) return path.join(root, ".ufoo", "agent", "ucode", "artifacts");
+  return path.join(root, ".ufoo", "agent", "ucode", "artifacts", id);
+}
+
+function createArtifactId(prefix = "artifact") {
+  const safe = String(prefix || "artifact").trim().replace(/[^a-zA-Z0-9_-]+/g, "") || "artifact";
+  return `${safe}_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+}
+
+function hashContent(value = "") {
+  return crypto.createHash("sha256").update(String(value || ""), "utf8").digest("hex").slice(0, 16);
+}
+
+function getArtifactFilePath(workspaceRoot = process.cwd(), sessionId = "", artifactId = "") {
+  const id = String(artifactId || "").trim();
+  if (!id) return "";
+  return path.join(getArtifactsDir(workspaceRoot, sessionId), `${id}.json`);
+}
+
+function buildArtifactRecord({
+  artifactId = "",
+  type = "tool_result",
+  source = "",
+  tool = "",
+  args = {},
+  raw = null,
+  summary = "",
+  index = {},
+  createdBy = "",
+  cold = false,
+  coldAt = "",
+  createdAt = "",
+  hash = "",
+  sizeBytes = null,
+} = {}) {
+  const rawText = typeof raw === "string" ? raw : JSON.stringify(raw);
+  const { buildArtifactIndex } = require("./artifactIndex");
+  const computedIndex = index && typeof index === "object" && Object.keys(index).length > 0
+    ? index
+    : buildArtifactIndex({ tool, raw, args });
+  return {
+    artifactId: artifactId || createArtifactId(),
+    type: String(type || "tool_result"),
+    source: String(source || ""),
+    tool: String(tool || ""),
+    args: args && typeof args === "object" ? args : {},
+    hash: hash || hashContent(rawText),
+    sizeBytes: Number.isFinite(sizeBytes) ? sizeBytes : Buffer.byteLength(rawText, "utf8"),
+    createdAt: String(createdAt || "") || new Date().toISOString(),
+    createdBy: String(createdBy || tool || ""),
+    summary: String(summary || ""),
+    index: computedIndex && typeof computedIndex === "object" ? computedIndex : {},
+    cold: Boolean(cold),
+    coldAt: cold ? String(coldAt || new Date().toISOString()) : "",
+    raw,
+  };
+}
+
+function saveArtifact(workspaceRoot = process.cwd(), sessionId = "", record = {}) {
+  const payload = buildArtifactRecord(record);
+  const filePath = getArtifactFilePath(workspaceRoot, sessionId, payload.artifactId);
+  if (!filePath) {
+    return { ok: false, error: "invalid artifact id", artifact: null };
+  }
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    return { ok: true, error: "", artifact: payload, filePath };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "failed to save artifact",
+      artifact: payload,
+      filePath,
+    };
+  }
+}
+
+function loadArtifact(workspaceRoot = process.cwd(), sessionId = "", artifactId = "") {
+  const filePath = getArtifactFilePath(workspaceRoot, sessionId, artifactId);
+  if (!filePath || !fs.existsSync(filePath)) {
+    return { ok: false, error: `artifact not found: ${artifactId}`, artifact: null, filePath };
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return { ok: true, error: "", artifact: parsed, filePath };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "failed to load artifact",
+      artifact: null,
+      filePath,
+    };
+  }
+}
+
+function readArtifactSlice(artifact = null, selector = {}) {
+  const record = artifact && typeof artifact === "object" ? artifact : null;
+  if (!record) return { ok: false, error: "missing artifact", content: "" };
+  const raw = record.raw;
+  const sel = selector && typeof selector === "object" ? selector : {};
+
+  if (record.type === "source_file" || record.tool === "read") {
+    const content = raw && typeof raw === "object" ? String(raw.content || "") : String(raw || "");
+    const startLine = Number(sel.startLine || sel.start || 0);
+    const endLine = Number(sel.endLine || sel.end || 0);
+    if (startLine > 0 && endLine >= startLine) {
+      const lines = content.split(/\r?\n/);
+      const slice = lines.slice(startLine - 1, endLine).join("\n");
+      return { ok: true, error: "", content: slice, range: `${startLine}-${endLine}` };
+    }
+    const maxChars = Number(sel.maxChars || 8000);
+    if (content.length > maxChars) {
+      return {
+        ok: true,
+        error: "",
+        content: `${content.slice(0, maxChars)}\n...[truncated]`,
+        truncated: true,
+      };
+    }
+    return { ok: true, error: "", content };
+  }
+
+  if (record.tool === "bash") {
+    const stdout = raw && typeof raw === "object" ? String(raw.stdout || "") : "";
+    const stderr = raw && typeof raw === "object" ? String(raw.stderr || "") : "";
+    const tail = Number(sel.tailLines || 40);
+    const tailStdout = stdout.split(/\r?\n/).slice(-tail).join("\n");
+    const tailStderr = stderr.split(/\r?\n/).slice(-tail).join("\n");
+    return {
+      ok: true,
+      error: "",
+      content: JSON.stringify({
+        exitCode: raw && typeof raw === "object" ? raw.code : null,
+        stdout: tailStdout,
+        stderr: tailStderr,
+      }, null, 2),
+    };
+  }
+
+  const text = typeof raw === "string" ? raw : JSON.stringify(raw, null, 2);
+  const maxChars = Number(sel.maxChars || 12000);
+  if (text.length > maxChars) {
+    return { ok: true, error: "", content: `${text.slice(0, maxChars)}\n...[truncated]`, truncated: true };
+  }
+  return { ok: true, error: "", content: text };
+}
+
+function deleteSessionArtifacts(workspaceRoot = process.cwd(), sessionId = "") {
+  const dir = getArtifactsDir(workspaceRoot, sessionId);
+  if (!fs.existsSync(dir)) return { ok: true, error: "" };
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+    return { ok: true, error: "" };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "failed to delete artifacts",
+    };
+  }
+}
+
+module.exports = {
+  getArtifactsDir,
+  createArtifactId,
+  hashContent,
+  getArtifactFilePath,
+  buildArtifactRecord,
+  saveArtifact,
+  loadArtifact,
+  readArtifactSlice,
+  deleteSessionArtifacts,
+};