oc-tweaks 0.11.1 → 0.11.3

package/dist/cli/init.js

@@ -2,8 +2,8 @@
 // @bun
 
 // src/cli/init.ts
-import { mkdir } from "fs/promises";
-import { dirname } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
 
 // src/plugins/auto-memory/diag.ts
 import { statSync } from "node:fs";
@@ -103,6 +103,33 @@ function parseFrontmatter(raw) {
   };
   return { meta, body };
 }
+function serializeFrontmatter(meta, body) {
+  const lines = ["---"];
+  if (meta.id)
+    lines.push(`id: ${meta.id}`);
+  lines.push(`scope: ${meta.scope}`);
+  if (meta.type)
+    lines.push(`type: ${meta.type}`);
+  if (meta.source)
+    lines.push(`source: ${meta.source}`);
+  if (meta.created_at)
+    lines.push(`created_at: ${meta.created_at}`);
+  if (meta.updated_at)
+    lines.push(`updated_at: ${meta.updated_at}`);
+  lines.push(`trusted_as_instruction: false`);
+  if (meta.summary !== undefined)
+    lines.push(`summary: "${meta.summary}"`);
+  if (meta.disabled !== undefined)
+    lines.push(`disabled: ${meta.disabled ? "true" : "false"}`);
+  if (meta.usage_count !== undefined)
+    lines.push(`usage_count: ${meta.usage_count}`);
+  if (meta.last_usage !== undefined)
+    lines.push(`last_usage: ${meta.last_usage}`);
+  lines.push("---");
+  lines.push(body);
+  return lines.join(`
+`);
+}
 
 // src/plugins/auto-memory/registry.ts
 var SKIP_PATTERNS = [
@@ -169,6 +196,8 @@ function scanDir(dir, scope) {
       continue;
     }
     const { meta, body } = parseFrontmatter(partial);
+    if (meta.disabled === true)
+      continue;
     const summary = extractSummary(meta, body);
     const tokenEstimate = Math.ceil((summary.length + JSON.stringify(meta).length) / 4);
     const entry = {
@@ -279,6 +308,90 @@ function formatDiagReport(report) {
 }
 if (false) {}
 
+// src/plugins/auto-memory/migrate.ts
+import { mkdir, open, readdir, readFile, rename, unlink } from "node:fs/promises";
+import { dirname, join as join3, resolve } from "node:path";
+function detectScope(absRoot, override) {
+  if (override)
+    return override;
+  return absRoot.includes(`.opencode${"/"}memory`) || absRoot.includes(`.opencode${"\\"}memory`) ? "project" : "global";
+}
+function slugifyFilename(filename) {
+  return filename.replace(/\.md$/i, "").toLowerCase().replace(/[\s_]+/g, "-");
+}
+async function atomicWrite(absPath, content) {
+  const tmpfile = `${absPath}.tmp.${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  let tmpfileCreated = false;
+  try {
+    await mkdir(dirname(absPath), { recursive: true });
+    const handle = await open(tmpfile, "w");
+    try {
+      await handle.writeFile(content, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    tmpfileCreated = true;
+    await rename(tmpfile, absPath);
+    tmpfileCreated = false;
+  } finally {
+    if (tmpfileCreated) {
+      await unlink(tmpfile).catch(() => {});
+    }
+  }
+}
+async function migrate(opts) {
+  const absRoot = resolve(opts.root);
+  const scope = detectScope(absRoot, opts.scope);
+  const result = { migrated: [], skipped: [], errored: [] };
+  let filenames;
+  try {
+    filenames = await readdir(absRoot);
+  } catch {
+    return result;
+  }
+  for (const filename of filenames) {
+    if (!filename.endsWith(".md"))
+      continue;
+    const absPath = join3(absRoot, filename);
+    let raw;
+    try {
+      raw = await readFile(absPath, "utf8");
+    } catch (err) {
+      console.error(`[migrate] error reading ${filename}: ${err.message}`);
+      result.errored.push(filename);
+      continue;
+    }
+    const stripped = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
+    if (stripped.startsWith("---")) {
+      console.log(`[migrate] skip (has frontmatter): ${filename}`);
+      result.skipped.push(filename);
+      continue;
+    }
+    const now = new Date().toISOString();
+    const meta = {
+      id: slugifyFilename(filename),
+      scope,
+      type: "note",
+      source: "migrate",
+      created_at: now,
+      updated_at: now,
+      trusted_as_instruction: false
+    };
+    const newContent = serializeFrontmatter(meta, raw);
+    try {
+      await atomicWrite(absPath, newContent);
+      console.log(`[migrate] migrated: ${filename}`);
+      result.migrated.push(filename);
+    } catch (err) {
+      console.error(`[migrate] error writing ${filename}: ${err.message}`);
+      result.errored.push(filename);
+    }
+  }
+  return result;
+}
+if (false) {}
+
 // src/cli/init.ts
 var DEFAULT_CONFIG = {
   notify: { enabled: true },
@@ -296,7 +409,7 @@ async function initConfig() {
     return { created: false, path: configPath };
   }
   const json = JSON.stringify(DEFAULT_CONFIG, null, 2);
-  await mkdir(dirname(configPath), { recursive: true });
+  await mkdir2(dirname2(configPath), { recursive: true });
   await Bun.write(configPath, json + `
 `);
   return { created: true, path: configPath };
@@ -308,6 +421,9 @@ function parseCliArgs(argv) {
   if (args[0] === "memory" && args[1] === "diag") {
     return { command: "memory-diag", opts: parseDiagOpts(args.slice(2)) };
   }
+  if (args[0] === "memory" && args[1] === "migrate") {
+    return { command: "memory-migrate", opts: parseMigrateOpts(args.slice(2)) };
+  }
   return { command: "init" };
 }
 function parseDiagOpts(args) {
@@ -323,12 +439,31 @@ function parseDiagOpts(args) {
   }
   return opts;
 }
+function parseMigrateOpts(args) {
+  const opts = { root: "" };
+  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 === "--scope" && args[i + 1]) {
+      const scope = args[++i];
+      if (scope === "global" || scope === "project")
+        opts.scope = scope;
+    }
+  }
+  return opts;
+}
 var isMain = typeof Bun !== "undefined" && Bun.main === import.meta.path;
 if (isMain) {
   const parsed = parseCliArgs(process.argv.slice(2));
   if (parsed.command === "memory-diag") {
     const report = await runDiag(parsed.opts);
     console.log(formatDiagReport(report));
+  } else if (parsed.command === "memory-migrate") {
+    if (!parsed.opts.root)
+      throw new Error("--root <dir> is required");
+    const result = await migrate(parsed.opts);
+    console.log(`Summary: migrated=${result.migrated.length}, skipped=${result.skipped.length}, errored=${result.errored.length}`);
   } else {
     const result = await initConfig();
     if (result.created) {

package/dist/index.js

@@ -931,7 +931,8 @@ async function recallMemory(query, registry, opts = {}) {
   if (query.length === 0) {
     return [{ id: NO_MATCH_SENTINEL_ID, content: NO_MATCH_SENTINEL_CONTENT }];
   }
-  const typeCandidates = opts.filterType ? registry.filter((e) => e.meta.type === opts.filterType) : registry;
+  const enabledEntries = registry.filter((entry) => entry.meta.disabled !== true);
+  const typeCandidates = opts.filterType ? enabledEntries.filter((e) => e.meta.type === opts.filterType) : enabledEntries;
   const candidates = opts.filterTags?.length ? typeCandidates.filter((entry) => {
     const tags = entry.meta.tags;
     return !tags || tags.some((tag) => opts.filterTags?.includes(tag));
@@ -1028,6 +1029,8 @@ function scanDir(dir, scope) {
       continue;
     }
     const { meta, body } = parseFrontmatter(partial);
+    if (meta.disabled === true)
+      continue;
     const summary = extractSummary(meta, body);
     const tokenEstimate = Math.ceil((summary.length + JSON.stringify(meta).length) / 4);
     const entry = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-tweaks",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"