oc-tweaks 0.11.0 → 0.11.1

package/dist/cli/init.js

@@ -4,6 +4,282 @@
 // src/cli/init.ts
 import { mkdir } from "fs/promises";
 import { dirname } from "path";
+
+// src/plugins/auto-memory/diag.ts
+import { statSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/plugins/auto-memory/registry.ts
+import { closeSync, openSync, readdirSync, readSync } from "node:fs";
+import { join } from "node:path";
+
+// src/plugins/auto-memory/frontmatter.ts
+class MemoryFrontmatterParseError extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "MemoryFrontmatterParseError";
+  }
+}
+var DEFAULT_META = {
+  id: "",
+  scope: "global",
+  type: "note",
+  source: "user",
+  created_at: "",
+  updated_at: "",
+  trusted_as_instruction: false
+};
+function parseMinimalYaml(yaml) {
+  const result = {};
+  for (const rawLine of yaml.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1)
+      continue;
+    const key = line.slice(0, colonIdx).trim();
+    const rawVal = line.slice(colonIdx + 1).trim();
+    if (!key)
+      continue;
+    if (/[\[{]/.test(rawVal) && !/[\]}]/.test(rawVal)) {
+      throw new MemoryFrontmatterParseError(`Invalid YAML value for key "${key}": unclosed bracket/brace`);
+    }
+    result[key] = parseYamlValue(rawVal);
+  }
+  return result;
+}
+function parseYamlValue(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  if (raw === "false")
+    return false;
+  if (raw === "true")
+    return true;
+  if (/^-?\d+$/.test(raw))
+    return parseInt(raw, 10);
+  return raw;
+}
+function parseFrontmatter(raw) {
+  const stripped = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
+  if (!stripped.startsWith("---")) {
+    return { meta: { ...DEFAULT_META }, body: raw };
+  }
+  const afterOpen = stripped.slice(3);
+  const closeIdx = afterOpen.indexOf(`
+---`);
+  if (closeIdx === -1) {
+    return { meta: { ...DEFAULT_META }, body: raw };
+  }
+  const yamlBlock = afterOpen.slice(0, closeIdx);
+  const afterClose = afterOpen.slice(closeIdx + 4);
+  const body = afterClose.startsWith(`
+`) ? afterClose.slice(1) : afterClose;
+  let parsed;
+  try {
+    parsed = parseMinimalYaml(yamlBlock);
+  } catch (e) {
+    if (e instanceof MemoryFrontmatterParseError)
+      throw e;
+    throw new MemoryFrontmatterParseError("Failed to parse frontmatter YAML", e);
+  }
+  const meta = {
+    ...DEFAULT_META,
+    ...parsed.id !== undefined && { id: String(parsed.id) },
+    ...parsed.scope !== undefined && { scope: parsed.scope },
+    ...parsed.type !== undefined && { type: String(parsed.type) },
+    ...parsed.source !== undefined && { source: String(parsed.source) },
+    ...parsed.created_at !== undefined && { created_at: String(parsed.created_at) },
+    ...parsed.updated_at !== undefined && { updated_at: String(parsed.updated_at) },
+    trusted_as_instruction: false,
+    ...parsed.summary !== undefined && { summary: String(parsed.summary) },
+    ...parsed.disabled !== undefined && { disabled: Boolean(parsed.disabled) },
+    ...parsed.usage_count !== undefined && { usage_count: Number(parsed.usage_count) },
+    ...parsed.last_usage !== undefined && { last_usage: String(parsed.last_usage) }
+  };
+  return { meta, body };
+}
+
+// src/plugins/auto-memory/registry.ts
+var SKIP_PATTERNS = [
+  /^readme/i,
+  /^\.ds_store$/i,
+  /\.swp$/,
+  /\.lock$/,
+  /^\.gitignore$/,
+  /^\.gitkeep$/
+];
+function shouldSkip(filename) {
+  return SKIP_PATTERNS.some((p) => p.test(filename));
+}
+var MAX_READ_BYTES = 2048;
+function readPartial(absPath) {
+  const fd = openSync(absPath, "r");
+  try {
+    const buf = Buffer.alloc(MAX_READ_BYTES);
+    const bytesRead = readSync(fd, buf, 0, MAX_READ_BYTES, 0);
+    return buf.subarray(0, bytesRead).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+var MAX_SUMMARY_CHARS = 240;
+var MAX_SUMMARY_LINES = 5;
+function extractSummary(meta, body) {
+  if (meta.summary) {
+    return meta.summary.slice(0, MAX_SUMMARY_CHARS);
+  }
+  const lines = body.split(`
+`);
+  const collected = [];
+  for (const line of lines) {
+    if (collected.length >= MAX_SUMMARY_LINES)
+      break;
+    if (collected.length > 0 && line.trim() === "")
+      break;
+    collected.push(line);
+  }
+  return collected.join(`
+`).slice(0, MAX_SUMMARY_CHARS);
+}
+function scanDir(dir, scope) {
+  const map = new Map;
+  let filenames;
+  try {
+    filenames = readdirSync(dir, { withFileTypes: false });
+  } catch {
+    return map;
+  }
+  for (const filename of filenames) {
+    if (typeof filename !== "string")
+      continue;
+    if (!filename.endsWith(".md"))
+      continue;
+    if (shouldSkip(filename))
+      continue;
+    const absPath = join(dir, filename);
+    let partial;
+    try {
+      partial = readPartial(absPath);
+    } catch {
+      continue;
+    }
+    const { meta, body } = parseFrontmatter(partial);
+    const summary = extractSummary(meta, body);
+    const tokenEstimate = Math.ceil((summary.length + JSON.stringify(meta).length) / 4);
+    const entry = {
+      meta,
+      absPath,
+      scope,
+      tokenEstimate,
+      summary
+    };
+    const key = meta.id || filename;
+    map.set(key, entry);
+  }
+  return map;
+}
+function scanMemoryRoots(globalDir, projectDir) {
+  const globalMap = scanDir(globalDir, "global");
+  const projectMap = scanDir(projectDir, "project");
+  const merged = new Map([...globalMap, ...projectMap]);
+  return Array.from(merged.values());
+}
+
+// src/plugins/auto-memory/diag.ts
+function resolveRoots(opts) {
+  if (opts.root) {
+    return {
+      globalDir: join2(opts.root, "global"),
+      projectDir: join2(opts.root, "project", ".opencode", "memory")
+    };
+  }
+  return {
+    globalDir: opts.globalRoot ?? "",
+    projectDir: opts.projectRoot ?? ""
+  };
+}
+function fileSizeBytes(absPath) {
+  try {
+    return statSync(absPath).size;
+  } catch {
+    return 0;
+  }
+}
+async function runDiag(opts) {
+  const { globalDir, projectDir } = resolveRoots(opts);
+  const allEntries = scanMemoryRoots(globalDir, projectDir);
+  const globalEntries = allEntries.filter((e) => e.scope === "global");
+  const projectEntries = allEntries.filter((e) => e.scope === "project");
+  function scopeStats(entries, scope, root) {
+    const totalBytes2 = entries.reduce((s, e) => s + fileSizeBytes(e.absPath), 0);
+    const estimatedTokens = entries.reduce((s, e) => s + e.tokenEstimate, 0);
+    return { scope, root, fileCount: entries.length, totalBytes: totalBytes2, estimatedTokens };
+  }
+  const scopes = [
+    scopeStats(globalEntries, "global", globalDir),
+    scopeStats(projectEntries, "project", projectDir)
+  ];
+  const totalBytes = scopes.reduce((s, sc) => s + sc.totalBytes, 0);
+  const totalEstimatedTokens = scopes.reduce((s, sc) => s + sc.estimatedTokens, 0);
+  const top5ByUsageCount = [...allEntries].sort((a, b) => (b.meta.usage_count ?? 0) - (a.meta.usage_count ?? 0)).slice(0, 5);
+  const top5ByUpdatedAt = [...allEntries].sort((a, b) => (b.meta.updated_at ?? "").localeCompare(a.meta.updated_at ?? "")).slice(0, 5);
+  return {
+    roots: { global: globalDir, project: projectDir },
+    scopes,
+    totalFiles: allEntries.length,
+    totalBytes,
+    totalEstimatedTokens,
+    top5ByUsageCount,
+    top5ByUpdatedAt,
+    autoWriteEvents: "no buffer in this session"
+  };
+}
+function formatDiagReport(report) {
+  const lines = [];
+  lines.push("=== memory diag ===");
+  lines.push("");
+  lines.push("memory roots:");
+  lines.push(`  global:  ${report.roots.global}`);
+  lines.push(`  project: ${report.roots.project}`);
+  lines.push("");
+  lines.push("file count per scope:");
+  for (const sc of report.scopes) {
+    lines.push(`  ${sc.scope.padEnd(8)} root=${sc.root}  files=${sc.fileCount}  bytes=${sc.totalBytes}  estimated tokens=${sc.estimatedTokens}`);
+  }
+  lines.push(`  total    files=${report.totalFiles}  bytes=${report.totalBytes}  estimated tokens=${report.totalEstimatedTokens}`);
+  lines.push("");
+  lines.push("estimated tokens (total): " + report.totalEstimatedTokens);
+  lines.push("");
+  lines.push("top 5 by usage_count (desc):");
+  if (report.top5ByUsageCount.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const e of report.top5ByUsageCount) {
+      lines.push(`  [${e.scope}] ${e.meta.id || e.absPath}  usage_count=${e.meta.usage_count ?? 0}  updated_at=${e.meta.updated_at}`);
+    }
+  }
+  lines.push("");
+  lines.push("top 5 by updated_at (desc):");
+  if (report.top5ByUpdatedAt.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const e of report.top5ByUpdatedAt) {
+      lines.push(`  [${e.scope}] ${e.meta.id || e.absPath}  updated_at=${e.meta.updated_at}  usage_count=${e.meta.usage_count ?? 0}`);
+    }
+  }
+  lines.push("");
+  lines.push("auto-write events: " + report.autoWriteEvents);
+  return lines.join(`
+`);
+}
+if (false) {}
+
+// src/cli/init.ts
 var DEFAULT_CONFIG = {
   notify: { enabled: true },
   compaction: { enabled: true },
@@ -25,18 +301,47 @@ async function initConfig() {
 `);
   return { created: true, path: configPath };
 }
+function parseCliArgs(argv) {
+  const args = argv[0] === "tweaks" ? argv.slice(1) : argv;
+  if (args.length === 0 || args[0] === "init")
+    return { command: "init" };
+  if (args[0] === "memory" && args[1] === "diag") {
+    return { command: "memory-diag", opts: parseDiagOpts(args.slice(2)) };
+  }
+  return { command: "init" };
+}
+function parseDiagOpts(args) {
+  const opts = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--root" && args[i + 1])
+      opts.root = args[++i];
+    else if (arg === "--global-root" && args[i + 1])
+      opts.globalRoot = args[++i];
+    else if (arg === "--project-root" && args[i + 1])
+      opts.projectRoot = args[++i];
+  }
+  return opts;
+}
 var isMain = typeof Bun !== "undefined" && Bun.main === import.meta.path;
 if (isMain) {
-  const result = await initConfig();
-  if (result.created) {
-    console.log(`Created: ${result.path}`);
-    console.log("All plugins configured. Edit the file to customize.");
+  const parsed = parseCliArgs(process.argv.slice(2));
+  if (parsed.command === "memory-diag") {
+    const report = await runDiag(parsed.opts);
+    console.log(formatDiagReport(report));
   } else {
-    console.log(`Config already exists: ${result.path}`);
-    console.log("Nothing changed. Edit the file manually to update your configuration.");
+    const result = await initConfig();
+    if (result.created) {
+      console.log(`Created: ${result.path}`);
+      console.log("All plugins configured. Edit the file to customize.");
+    } else {
+      console.log(`Config already exists: ${result.path}`);
+      console.log("Nothing changed. Edit the file manually to update your configuration.");
+    }
   }
 }
 export {
+  parseCliArgs,
   initConfig,
   DEFAULT_CONFIG
 };