omo-suites 1.11.0 → 1.12.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to OMO Suites will be documented in this file.
 Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.12.0] - 2026-03-26
+
+### Added
+- `omocs compact config` — scan and clean stale config entries (duplicate plugins, empty MCP servers, stale provider keys)
+- `omocs compact memory` — trim old workspace memory notes with archiving (--keep, --older-than)
+- `omocs compact index` — clean up orphaned workspace indexes for non-existent workspaces
+- `omocs compact stats` — trim old stats data with archiving (--keep-days)
+- `omocs compact all` — run all compact operations with combined summary
+- All compact subcommands default to dry-run; use `--fix` to apply changes
+- Automatic backup before any destructive operation
+
 ## [1.11.0] - 2026-03-25
 
 ### Added

package/dist/cli/omocs.js

@@ -39804,6 +39804,451 @@ var init_index_cmd = __esm(() => {
   IGNORED_DIRS = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "coverage", ".opencode"];
 });
 
+// src/commands/compact.ts
+import { existsSync as existsSync21, readFileSync as readFileSync22, writeFileSync as writeFileSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync6, statSync as statSync6, unlinkSync as unlinkSync5, copyFileSync } from "fs";
+import { join as join15, basename as basename2 } from "path";
+import { homedir as homedir11 } from "os";
+function ensureDir(dir) {
+  if (!existsSync21(dir))
+    mkdirSync12(dir, { recursive: true });
+}
+function backupFile(filePath) {
+  if (!existsSync21(filePath))
+    return null;
+  const bakPath = filePath + ".bak." + Date.now();
+  copyFileSync(filePath, bakPath);
+  return bakPath;
+}
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readFileSync22(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function scanConfigIssues() {
+  const issues = [];
+  const configLocations = [
+    join15(process.cwd(), "opencode.json"),
+    join15(process.cwd(), ".opencode", "opencode.json"),
+    join15(homedir11(), ".config", "opencode", "opencode.json")
+  ];
+  const omocLocations = [
+    join15(process.cwd(), "oh-my-opencode.json"),
+    join15(process.cwd(), ".opencode", "oh-my-opencode.json"),
+    join15(homedir11(), ".config", "opencode", "oh-my-opencode.json")
+  ];
+  for (const loc of configLocations) {
+    if (!existsSync21(loc))
+      continue;
+    const data = readJsonSafe(loc);
+    if (!data) {
+      issues.push({ file: loc, type: "invalid-json", description: "File is not valid JSON", fixable: false });
+      continue;
+    }
+    if (Array.isArray(data.plugin)) {
+      const seen = new Set;
+      const dupes = [];
+      for (const p of data.plugin) {
+        const name = typeof p === "string" ? p : p?.name;
+        if (name && seen.has(name))
+          dupes.push(name);
+        if (name)
+          seen.add(name);
+      }
+      if (dupes.length > 0) {
+        issues.push({ file: loc, type: "duplicate-plugins", description: `Duplicate plugins: ${dupes.join(", ")}`, fixable: true });
+      }
+    }
+    if (data.mcpServers && typeof data.mcpServers === "object") {
+      for (const [key, val] of Object.entries(data.mcpServers)) {
+        if (!val || typeof val === "object" && Object.keys(val).length === 0) {
+          issues.push({ file: loc, type: "empty-mcp", description: `Empty MCP server config: "${key}"`, fixable: true });
+        }
+      }
+    }
+  }
+  for (const loc of omocLocations) {
+    if (!existsSync21(loc))
+      continue;
+    const data = readJsonSafe(loc);
+    if (!data) {
+      issues.push({ file: loc, type: "invalid-json", description: "File is not valid JSON", fixable: false });
+      continue;
+    }
+    if (data.providers && typeof data.providers === "object") {
+      for (const [provider, config] of Object.entries(data.providers)) {
+        const cfg = config;
+        if (cfg && cfg.apiKey === "") {
+          issues.push({ file: loc, type: "empty-api-key", description: `Empty API key for provider: "${provider}"`, fixable: true });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function fixConfigIssues(issues) {
+  let fixed = 0;
+  const fileCache = {};
+  for (const issue of issues) {
+    if (!issue.fixable)
+      continue;
+    if (!fileCache[issue.file]) {
+      const data = readJsonSafe(issue.file);
+      if (!data)
+        continue;
+      fileCache[issue.file] = { data, modified: false };
+    }
+    const entry = fileCache[issue.file];
+    if (issue.type === "duplicate-plugins" && Array.isArray(entry.data.plugin)) {
+      const seen = new Set;
+      entry.data.plugin = entry.data.plugin.filter((p) => {
+        const name = typeof p === "string" ? p : p?.name;
+        if (name && seen.has(name))
+          return false;
+        if (name)
+          seen.add(name);
+        return true;
+      });
+      entry.modified = true;
+      fixed++;
+    }
+    if (issue.type === "empty-mcp" && entry.data.mcpServers) {
+      const key = issue.description.match(/"([^"]+)"/)?.[1];
+      if (key && key in entry.data.mcpServers) {
+        delete entry.data.mcpServers[key];
+        entry.modified = true;
+        fixed++;
+      }
+    }
+    if (issue.type === "empty-api-key" && entry.data.providers) {
+      const provider = issue.description.match(/"([^"]+)"/)?.[1];
+      if (provider && entry.data.providers[provider]) {
+        delete entry.data.providers[provider];
+        entry.modified = true;
+        fixed++;
+      }
+    }
+  }
+  for (const [filePath, entry] of Object.entries(fileCache)) {
+    if (entry.modified) {
+      backupFile(filePath);
+      writeFileSync15(filePath, JSON.stringify(entry.data, null, 2) + `
+`, "utf-8");
+    }
+  }
+  return fixed;
+}
+function compactMemory(keepEntries, olderThanDays, fix) {
+  const result = { filesScanned: 0, entriesRemoved: 0, bytesFreed: 0, archived: 0 };
+  if (!existsSync21(MEMORY_DIR2))
+    return result;
+  const files = readdirSync6(MEMORY_DIR2).filter((f) => f.endsWith(".json") && f !== "archive");
+  const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+  for (const file of files) {
+    const filePath = join15(MEMORY_DIR2, file);
+    const sizeBefore = statSync6(filePath).size;
+    result.filesScanned++;
+    const data = readJsonSafe(filePath);
+    if (!data || !Array.isArray(data.notes))
+      continue;
+    const originalCount = data.notes.length;
+    let filtered = data.notes.filter((note) => {
+      const noteTime = new Date(note.timestamp).getTime();
+      return noteTime > cutoff;
+    });
+    if (filtered.length > keepEntries) {
+      filtered = filtered.slice(-keepEntries);
+    }
+    const removed = originalCount - filtered.length;
+    if (removed === 0)
+      continue;
+    result.entriesRemoved += removed;
+    if (fix) {
+      ensureDir(ARCHIVE_DIR);
+      const removedNotes = data.notes.filter((n) => !filtered.includes(n));
+      if (removedNotes.length > 0) {
+        const archivePath = join15(ARCHIVE_DIR, `${basename2(file, ".json")}-${Date.now()}.json`);
+        writeFileSync15(archivePath, JSON.stringify({ archived: new Date().toISOString(), notes: removedNotes }, null, 2), "utf-8");
+        result.archived++;
+      }
+      data.notes = filtered;
+      writeFileSync15(filePath, JSON.stringify(data, null, 2), "utf-8");
+      const sizeAfter = statSync6(filePath).size;
+      result.bytesFreed += sizeBefore - sizeAfter;
+    } else {
+      result.bytesFreed += Math.round(sizeBefore * (removed / originalCount));
+    }
+  }
+  return result;
+}
+function compactIndex(fix, rebuildAll) {
+  const result = { totalIndexes: 0, orphanedRemoved: 0, bytesFreed: 0 };
+  if (!existsSync21(INDEX_DIR2))
+    return result;
+  const dirs = readdirSync6(INDEX_DIR2).filter((d) => {
+    const p = join15(INDEX_DIR2, d);
+    return statSync6(p).isDirectory();
+  });
+  result.totalIndexes = dirs.length;
+  for (const dir of dirs) {
+    const indexPath = join15(INDEX_DIR2, dir, "index.json");
+    if (!existsSync21(indexPath))
+      continue;
+    const data = readJsonSafe(indexPath);
+    if (!data)
+      continue;
+    if (data.path && !existsSync21(data.path)) {
+      const size = statSync6(indexPath).size;
+      result.orphanedRemoved++;
+      result.bytesFreed += size;
+      if (fix) {
+        unlinkSync5(indexPath);
+        try {
+          const remaining = readdirSync6(join15(INDEX_DIR2, dir));
+          if (remaining.length === 0) {
+            unlinkSync5(join15(INDEX_DIR2, dir));
+          }
+        } catch {}
+      }
+    }
+  }
+  return result;
+}
+function compactStats(keepDays, fix) {
+  const result = { totalEntries: 0, entriesRemoved: 0, bytesFreed: 0 };
+  if (!existsSync21(STATS_FILE))
+    return result;
+  const sizeBefore = statSync6(STATS_FILE).size;
+  const data = readJsonSafe(STATS_FILE);
+  if (!data)
+    return result;
+  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1000;
+  if (data.daily && typeof data.daily === "object") {
+    const dates = Object.keys(data.daily);
+    result.totalEntries = dates.length;
+    const toRemove = dates.filter((d) => new Date(d).getTime() < cutoff);
+    result.entriesRemoved = toRemove.length;
+    if (fix && toRemove.length > 0) {
+      ensureDir(join15(OMOCS_DIR, "stats-archive"));
+      const archivePath = join15(OMOCS_DIR, "stats-archive", `stats-${Date.now()}.json`);
+      const archived = {};
+      for (const d of toRemove) {
+        archived[d] = data.daily[d];
+        delete data.daily[d];
+      }
+      writeFileSync15(archivePath, JSON.stringify({ archivedAt: new Date().toISOString(), daily: archived }, null, 2), "utf-8");
+      backupFile(STATS_FILE);
+      writeFileSync15(STATS_FILE, JSON.stringify(data, null, 2), "utf-8");
+      const sizeAfter = statSync6(STATS_FILE).size;
+      result.bytesFreed = sizeBefore - sizeAfter;
+    } else {
+      result.bytesFreed = Math.round(sizeBefore * (result.entriesRemoved / Math.max(result.totalEntries, 1)));
+    }
+  } else if (Array.isArray(data)) {
+    result.totalEntries = data.length;
+    const filtered = data.filter((entry) => {
+      const ts = entry.timestamp || entry.date || entry.createdAt;
+      return ts && new Date(ts).getTime() > cutoff;
+    });
+    result.entriesRemoved = data.length - filtered.length;
+    if (fix && result.entriesRemoved > 0) {
+      backupFile(STATS_FILE);
+      writeFileSync15(STATS_FILE, JSON.stringify(filtered, null, 2), "utf-8");
+      const sizeAfter = statSync6(STATS_FILE).size;
+      result.bytesFreed = sizeBefore - sizeAfter;
+    } else {
+      result.bytesFreed = Math.round(sizeBefore * (result.entriesRemoved / Math.max(result.totalEntries, 1)));
+    }
+  }
+  return result;
+}
+function registerCompactCommand(program2) {
+  const compact = program2.command("compact").description("Clean up config, memory, indexes, and stats data");
+  compact.command("config").description("Scan and clean stale config entries").option("--fix", "Apply fixes (default: dry-run)").action((opts) => {
+    try {
+      heading("Compact Config");
+      const issues = scanConfigIssues();
+      if (issues.length === 0) {
+        successBox("No config issues found! Everything is clean.");
+        return;
+      }
+      console.log(source_default.yellow(`
+  Found ${issues.length} issue(s):
+`));
+      for (const issue of issues) {
+        const fixable = issue.fixable ? source_default.green("[fixable]") : source_default.red("[manual]");
+        const icon = issue.fixable ? "⚠️" : "❌";
+        console.log(`  ${icon} ${fixable} ${source_default.dim(issue.file)}`);
+        console.log(`     ${issue.description}
+`);
+      }
+      if (opts.fix) {
+        const fixable = issues.filter((i) => i.fixable);
+        if (fixable.length === 0) {
+          warn("No auto-fixable issues found.");
+          return;
+        }
+        const fixed = fixConfigIssues(fixable);
+        success(`Fixed ${fixed} issue(s). Backups created (.bak).`);
+      } else {
+        const fixable = issues.filter((i) => i.fixable).length;
+        info(`Run ${source_default.cyan("omocs compact config --fix")} to auto-fix ${fixable} issue(s).`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  compact.command("memory").description("Trim old workspace memory notes").option("--keep <n>", "Keep last N entries per workspace", "50").option("--older-than <days>", "Remove entries older than N days", "30").option("--fix", "Apply cleanup (default: dry-run)").action((opts) => {
+    try {
+      heading("Compact Memory");
+      const keep = parseInt(opts.keep) || 50;
+      const olderThan = parseInt(opts.olderThan) || 30;
+      const result = compactMemory(keep, olderThan, !!opts.fix);
+      if (result.filesScanned === 0) {
+        info("No memory files found.");
+        return;
+      }
+      console.log(`
+  ${source_default.dim("Files scanned:")}  ${result.filesScanned}`);
+      console.log(`  ${source_default.dim("Entries to remove:")} ${result.entriesRemoved}`);
+      console.log(`  ${source_default.dim("Space savings:")}  ~${formatBytes(result.bytesFreed)}`);
+      if (result.entriesRemoved === 0) {
+        successBox("Memory is already clean!");
+      } else if (opts.fix) {
+        success(`Removed ${result.entriesRemoved} old entries. ${result.archived} archive(s) created.`);
+      } else {
+        info(`Run ${source_default.cyan("omocs compact memory --fix")} to clean up.`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  compact.command("index").description("Clean up orphaned workspace indexes").option("--all", "Rebuild all indexes").option("--fix", "Apply cleanup (default: dry-run)").action((opts) => {
+    try {
+      heading("Compact Index");
+      const result = compactIndex(!!opts.fix, !!opts.all);
+      if (result.totalIndexes === 0) {
+        info("No workspace indexes found.");
+        return;
+      }
+      console.log(`
+  ${source_default.dim("Total indexes:")}   ${result.totalIndexes}`);
+      console.log(`  ${source_default.dim("Orphaned:")}        ${result.orphanedRemoved}`);
+      console.log(`  ${source_default.dim("Space savings:")}   ~${formatBytes(result.bytesFreed)}`);
+      if (result.orphanedRemoved === 0) {
+        successBox("All indexes are valid!");
+      } else if (opts.fix) {
+        success(`Removed ${result.orphanedRemoved} orphaned index(es). Freed ~${formatBytes(result.bytesFreed)}.`);
+      } else {
+        info(`Run ${source_default.cyan("omocs compact index --fix")} to clean up.`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  compact.command("stats").description("Trim old stats data").option("--keep-days <n>", "Keep last N days of stats", "30").option("--fix", "Apply cleanup (default: dry-run)").action((opts) => {
+    try {
+      heading("Compact Stats");
+      const keepDays = parseInt(opts.keepDays) || 30;
+      const result = compactStats(keepDays, !!opts.fix);
+      if (result.totalEntries === 0) {
+        info("No stats data found.");
+        return;
+      }
+      console.log(`
+  ${source_default.dim("Total entries:")}  ${result.totalEntries}`);
+      console.log(`  ${source_default.dim("To remove:")}      ${result.entriesRemoved}`);
+      console.log(`  ${source_default.dim("Space savings:")}  ~${formatBytes(result.bytesFreed)}`);
+      if (result.entriesRemoved === 0) {
+        successBox("Stats are already clean!");
+      } else if (opts.fix) {
+        success(`Removed ${result.entriesRemoved} old entries. Freed ~${formatBytes(result.bytesFreed)}. Backup + archive created.`);
+      } else {
+        info(`Run ${source_default.cyan("omocs compact stats --fix")} to clean up.`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  compact.command("all").description("Run all compact operations").option("--fix", "Apply all fixes (default: dry-run)").action((opts) => {
+    try {
+      const fix = !!opts.fix;
+      heading("Compact Config");
+      const configIssues = scanConfigIssues();
+      if (configIssues.length === 0) {
+        console.log(`  ✅ Config: clean`);
+      } else {
+        console.log(`  ⚠️  Config: ${configIssues.length} issue(s)`);
+        if (fix) {
+          const fixed = fixConfigIssues(configIssues.filter((i) => i.fixable));
+          console.log(`  ✅ Fixed ${fixed} issue(s)`);
+        }
+      }
+      console.log("");
+      heading("Compact Memory");
+      const memResult = compactMemory(50, 30, fix);
+      if (memResult.entriesRemoved === 0) {
+        console.log(`  ✅ Memory: clean (${memResult.filesScanned} files)`);
+      } else {
+        console.log(`  ⚠️  Memory: ${memResult.entriesRemoved} old entries (~${formatBytes(memResult.bytesFreed)})`);
+        if (fix)
+          console.log(`  ✅ Cleaned & archived`);
+      }
+      console.log("");
+      heading("Compact Index");
+      const idxResult = compactIndex(fix, false);
+      if (idxResult.orphanedRemoved === 0) {
+        console.log(`  ✅ Index: clean (${idxResult.totalIndexes} indexes)`);
+      } else {
+        console.log(`  ⚠️  Index: ${idxResult.orphanedRemoved} orphaned (~${formatBytes(idxResult.bytesFreed)})`);
+        if (fix)
+          console.log(`  ✅ Removed orphaned indexes`);
+      }
+      console.log("");
+      heading("Compact Stats");
+      const statsResult = compactStats(30, fix);
+      if (statsResult.entriesRemoved === 0) {
+        console.log(`  ✅ Stats: clean (${statsResult.totalEntries} entries)`);
+      } else {
+        console.log(`  ⚠️  Stats: ${statsResult.entriesRemoved} old entries (~${formatBytes(statsResult.bytesFreed)})`);
+        if (fix)
+          console.log(`  ✅ Trimmed & archived`);
+      }
+      console.log("");
+      const totalIssues = configIssues.length + memResult.entriesRemoved + idxResult.orphanedRemoved + statsResult.entriesRemoved;
+      if (totalIssues === 0) {
+        successBox("Everything is clean! No action needed.");
+      } else if (fix) {
+        successBox(`Compact complete. ${totalIssues} issues resolved.`);
+      } else {
+        console.log(source_default.yellow(`
+  ${totalIssues} total issues found.`));
+        info(`Run ${source_default.cyan("omocs compact all --fix")} to clean everything up.`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+var OMOCS_DIR, MEMORY_DIR2, ARCHIVE_DIR, INDEX_DIR2, STATS_FILE;
+var init_compact = __esm(() => {
+  init_source();
+  init_ui();
+  OMOCS_DIR = join15(homedir11(), ".omocs");
+  MEMORY_DIR2 = join15(OMOCS_DIR, "memory");
+  ARCHIVE_DIR = join15(MEMORY_DIR2, "archive");
+  INDEX_DIR2 = join15(OMOCS_DIR, "workspaces");
+  STATS_FILE = join15(OMOCS_DIR, "stats.json");
+});
+
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
@@ -39833,6 +40278,7 @@ var init_src = __esm(() => {
   init_memory();
   init_completion();
   init_index_cmd();
+  init_compact();
   init_find_package_json();
   pkg = readPackageJson(import.meta.url);
   VERSION3 = pkg.version;
@@ -39866,6 +40312,7 @@ var init_src = __esm(() => {
   registerMemoryCommand(program2);
   registerCompletionCommand(program2);
   registerIndexCommand(program2);
+  registerCompactCommand(program2);
   program2.action(() => {
     showBanner();
     program2.help();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omo-suites",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "OMO Suites — OpenCode plugin + CLI toolkit. Multi-model orchestration, profiles, agent routing, MCP/LSP management.",
   "type": "module",
   "main": "dist/plugin.js",