omo-suites 1.13.0 → 1.14.0

package/CHANGELOG.md

@@ -5,6 +5,20 @@ 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.14.0] - 2026-03-26
+
+### Added
+- **Auto system** — automatic background checks run on every `omocs` command (non-blocking)
+  - **Auto-Doctor** — workspace health check on first run per day (missing config, AGENTS.md, .gitignore)
+  - **Auto-Index** — rebuild workspace index when file structure changes (new/renamed files detected)
+  - **Auto-Compact** — periodic cleanup of stale memory, stats, and orphaned indexes (every 7 days)
+  - **Auto-Template Suggest** — detect empty projects and suggest matching saved templates
+- `omocs auto run` — manually trigger all auto checks
+- `omocs auto status` — view auto check state and timings
+- `omocs auto reset` — force re-run all checks
+- `omocs auto suppress <warning>` — hide specific warnings
+- Auto checks are silent unless there are warnings or fixes to report
+
 ## [1.13.0] - 2026-03-26
 
 ### Added

package/dist/cli/omocs.js

@@ -41963,6 +41963,492 @@ var init_squad = __esm(() => {
   SQUAD_STATE = join22(SQUAD_DIR, "state.json");
 });
 
+// src/core/auto.ts
+import { existsSync as existsSync28, readFileSync as readFileSync29, writeFileSync as writeFileSync21, mkdirSync as mkdirSync17, statSync as statSync11, readdirSync as readdirSync11 } from "fs";
+import { join as join23, extname as extname2, basename as basename8 } from "path";
+import { homedir as homedir17 } from "os";
+import { createHash as createHash6 } from "crypto";
+function ensureDir5(dir) {
+  if (!existsSync28(dir))
+    mkdirSync17(dir, { recursive: true });
+}
+function readJsonSafe5(path2) {
+  try {
+    return JSON.parse(readFileSync29(path2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function getAutoState() {
+  if (existsSync28(AUTO_STATE_FILE)) {
+    const state2 = readJsonSafe5(AUTO_STATE_FILE);
+    if (state2)
+      return state2;
+  }
+  return {
+    lastCompact: 0,
+    lastIndex: {},
+    lastDoctor: 0,
+    structureHashes: {},
+    suppressedWarnings: []
+  };
+}
+function saveAutoState(state2) {
+  ensureDir5(OMOCS_DIR2);
+  writeFileSync21(AUTO_STATE_FILE, JSON.stringify(state2, null, 2), "utf-8");
+}
+function getWorkspaceHash3(cwd) {
+  return createHash6("sha256").update(cwd).digest("hex").substring(0, 16);
+}
+function getStructureHash(cwd) {
+  try {
+    const entries = [];
+    const scan = (dir, depth) => {
+      if (depth > 2)
+        return;
+      const items = readdirSync11(dir, { withFileTypes: true });
+      for (const item of items) {
+        if (item.name.startsWith(".") || IGNORED_DIRS3.includes(item.name))
+          continue;
+        if (item.isDirectory()) {
+          entries.push(`d:${item.name}`);
+          scan(join23(dir, item.name), depth + 1);
+        } else if (item.isFile() && WATCHED_EXTS2.includes(extname2(item.name))) {
+          entries.push(`f:${item.name}`);
+        }
+      }
+    };
+    scan(cwd, 0);
+    return createHash6("sha256").update(entries.join("|")).digest("hex").substring(0, 16);
+  } catch {
+    return "";
+  }
+}
+function autoCompact(state2) {
+  const results = [];
+  const now = Date.now();
+  if (now - state2.lastCompact < COMPACT_THRESHOLD_DAYS * 24 * 60 * 60 * 1000) {
+    return results;
+  }
+  if (existsSync28(MEMORY_DIR3)) {
+    try {
+      const files = readdirSync11(MEMORY_DIR3).filter((f) => f.endsWith(".json"));
+      let totalEntries = 0;
+      let totalSize = 0;
+      for (const file of files) {
+        const filePath = join23(MEMORY_DIR3, file);
+        totalSize += statSync11(filePath).size;
+        const data = readJsonSafe5(filePath);
+        if (data && Array.isArray(data.notes))
+          totalEntries += data.notes.length;
+      }
+      if (totalEntries > COMPACT_MEMORY_MAX_ENTRIES) {
+        for (const file of files) {
+          const filePath = join23(MEMORY_DIR3, file);
+          const data = readJsonSafe5(filePath);
+          if (data && Array.isArray(data.notes) && data.notes.length > COMPACT_MEMORY_MAX_ENTRIES) {
+            const archiveDir = join23(MEMORY_DIR3, "archive");
+            ensureDir5(archiveDir);
+            const removed = data.notes.splice(0, data.notes.length - COMPACT_MEMORY_MAX_ENTRIES);
+            writeFileSync21(join23(archiveDir, `${basename8(file, ".json")}-auto-${now}.json`), JSON.stringify({ archived: new Date().toISOString(), notes: removed }, null, 2), "utf-8");
+            writeFileSync21(filePath, JSON.stringify(data, null, 2), "utf-8");
+          }
+        }
+        results.push({ action: "auto-compact-memory", status: "fixed", message: `Trimmed memory (${totalEntries} entries → ${COMPACT_MEMORY_MAX_ENTRIES} max per file)` });
+      } else {
+        results.push({ action: "auto-compact-memory", status: "ok", message: `Memory clean (${totalEntries} entries)` });
+      }
+    } catch {}
+  }
+  if (existsSync28(STATS_FILE2)) {
+    try {
+      const data = readJsonSafe5(STATS_FILE2);
+      if (data && data.daily) {
+        const cutoff = now - COMPACT_STATS_MAX_DAYS * 24 * 60 * 60 * 1000;
+        const dates = Object.keys(data.daily);
+        const old = dates.filter((d) => new Date(d).getTime() < cutoff);
+        if (old.length > 0) {
+          const archiveDir = join23(OMOCS_DIR2, "stats-archive");
+          ensureDir5(archiveDir);
+          const archived = {};
+          for (const d of old) {
+            archived[d] = data.daily[d];
+            delete data.daily[d];
+          }
+          writeFileSync21(join23(archiveDir, `stats-auto-${now}.json`), JSON.stringify({ archivedAt: new Date().toISOString(), daily: archived }, null, 2), "utf-8");
+          writeFileSync21(STATS_FILE2, JSON.stringify(data, null, 2), "utf-8");
+          results.push({ action: "auto-compact-stats", status: "fixed", message: `Archived ${old.length} old stats entries` });
+        }
+      }
+    } catch {}
+  }
+  if (existsSync28(INDEX_DIR3)) {
+    try {
+      const dirs = readdirSync11(INDEX_DIR3).filter((d) => {
+        const p = join23(INDEX_DIR3, d);
+        return statSync11(p).isDirectory();
+      });
+      let orphaned = 0;
+      for (const dir of dirs) {
+        const indexPath = join23(INDEX_DIR3, dir, "index.json");
+        if (!existsSync28(indexPath))
+          continue;
+        const data = readJsonSafe5(indexPath);
+        if (data && data.path && !existsSync28(data.path)) {
+          const { unlinkSync: unlinkSync6 } = __require("fs");
+          unlinkSync6(indexPath);
+          orphaned++;
+        }
+      }
+      if (orphaned > 0) {
+        results.push({ action: "auto-compact-index", status: "fixed", message: `Removed ${orphaned} orphaned index(es)` });
+      }
+    } catch {}
+  }
+  state2.lastCompact = now;
+  return results;
+}
+function autoIndex(cwd, state2) {
+  const results = [];
+  const wsHash = getWorkspaceHash3(cwd);
+  const now = Date.now();
+  const lastIndexTime = state2.lastIndex[wsHash] || 0;
+  if (now - lastIndexTime < INDEX_STALE_HOURS * 60 * 60 * 1000) {
+    return results;
+  }
+  const currentHash = getStructureHash(cwd);
+  const lastHash = state2.structureHashes[wsHash] || "";
+  if (currentHash && currentHash !== lastHash) {
+    try {
+      const indexDir = join23(INDEX_DIR3, wsHash);
+      ensureDir5(indexDir);
+      const techStack = [];
+      const keyFiles = [];
+      let fileCount = 0;
+      const scan = (dir, depth) => {
+        if (depth > 3)
+          return;
+        try {
+          const items = readdirSync11(dir, { withFileTypes: true });
+          for (const item of items) {
+            if (item.name.startsWith(".") || IGNORED_DIRS3.includes(item.name))
+              continue;
+            if (item.isDirectory())
+              scan(join23(dir, item.name), depth + 1);
+            else if (item.isFile()) {
+              fileCount++;
+              const ext = extname2(item.name);
+              if (ext === ".ts" || ext === ".tsx") {
+                if (!techStack.includes("TypeScript"))
+                  techStack.push("TypeScript");
+              }
+              if (ext === ".py") {
+                if (!techStack.includes("Python"))
+                  techStack.push("Python");
+              }
+              if (ext === ".go") {
+                if (!techStack.includes("Go"))
+                  techStack.push("Go");
+              }
+              if (ext === ".rs") {
+                if (!techStack.includes("Rust"))
+                  techStack.push("Rust");
+              }
+              if ([
+                "package.json",
+                "tsconfig.json",
+                "Cargo.toml",
+                "go.mod",
+                "pyproject.toml",
+                "Dockerfile",
+                "docker-compose.yml",
+                "next.config.ts",
+                "next.config.js",
+                "nest-cli.json",
+                "opencode.json",
+                "AGENTS.md"
+              ].includes(item.name)) {
+                keyFiles.push(join23(dir, item.name));
+              }
+            }
+          }
+        } catch {}
+      };
+      scan(cwd, 0);
+      const index = {
+        id: wsHash,
+        path: cwd,
+        builtAt: new Date().toISOString(),
+        techStack,
+        fileCount,
+        keyFiles: keyFiles.map((f) => f.replace(cwd, ".")),
+        autoBuilt: true
+      };
+      writeFileSync21(join23(indexDir, "index.json"), JSON.stringify(index, null, 2), "utf-8");
+      state2.lastIndex[wsHash] = now;
+      state2.structureHashes[wsHash] = currentHash;
+      results.push({ action: "auto-index", status: "fixed", message: `Index rebuilt (${fileCount} files, ${techStack.join("/")})` });
+    } catch {}
+  }
+  return results;
+}
+function autoDoctor(cwd, state2) {
+  const results = [];
+  const now = Date.now();
+  if (now - state2.lastDoctor < 24 * 60 * 60 * 1000)
+    return results;
+  const warnings = [];
+  const configLocations = ["opencode.json", join23(".opencode", "opencode.json")];
+  const hasConfig = configLocations.some((l) => existsSync28(join23(cwd, l)));
+  if (!hasConfig) {
+    warnings.push("No opencode.json found — run `omocs init` to set up");
+  }
+  if (!existsSync28(join23(cwd, "AGENTS.md"))) {
+    warnings.push("No AGENTS.md — run `omocs watch generate` or `omocs init-deep`");
+  }
+  const gitignorePath = join23(cwd, ".gitignore");
+  if (existsSync28(gitignorePath)) {
+    const gitignore = readFileSync29(gitignorePath, "utf-8");
+    if (!gitignore.includes(".opencode")) {
+      warnings.push(".opencode not in .gitignore — sessions/cache may be committed");
+    }
+  }
+  if (existsSync28(OMOCS_DIR2)) {
+    try {
+      let totalSize = 0;
+      const checkSize = (dir) => {
+        const items = readdirSync11(dir, { withFileTypes: true });
+        for (const item of items) {
+          const p = join23(dir, item.name);
+          if (item.isFile())
+            totalSize += statSync11(p).size;
+          else if (item.isDirectory())
+            checkSize(p);
+        }
+      };
+      checkSize(OMOCS_DIR2);
+      if (totalSize > 50 * 1024 * 1024) {
+        warnings.push(`~/.omocs is ${(totalSize / 1024 / 1024).toFixed(0)}MB — run \`omocs compact all --fix\``);
+      }
+    } catch {}
+  }
+  const unsuppressed = warnings.filter((w) => !state2.suppressedWarnings.includes(w));
+  if (unsuppressed.length > 0) {
+    results.push({
+      action: "auto-doctor",
+      status: "warn",
+      message: unsuppressed.join("; ")
+    });
+  } else {
+    results.push({ action: "auto-doctor", status: "ok", message: "Workspace healthy" });
+  }
+  state2.lastDoctor = now;
+  return results;
+}
+function autoTemplateSuggest(cwd, state2) {
+  const results = [];
+  const configLocations = ["opencode.json", join23(".opencode", "opencode.json")];
+  const hasConfig = configLocations.some((l) => existsSync28(join23(cwd, l)));
+  if (hasConfig)
+    return results;
+  if (!existsSync28(TEMPLATE_DIR2))
+    return results;
+  try {
+    const templates = readdirSync11(TEMPLATE_DIR2).filter((d) => {
+      const manifestPath = join23(TEMPLATE_DIR2, d, "manifest.json");
+      return existsSync28(manifestPath);
+    });
+    if (templates.length > 0) {
+      let projectType = "unknown";
+      if (existsSync28(join23(cwd, "package.json"))) {
+        const pkg = readJsonSafe5(join23(cwd, "package.json"));
+        if (pkg) {
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          if (deps["next"])
+            projectType = "nextjs";
+          else if (deps["@nestjs/core"])
+            projectType = "nestjs";
+          else if (deps["react"])
+            projectType = "react";
+          else if (deps["vue"])
+            projectType = "vue";
+          else
+            projectType = "node";
+        }
+      } else if (existsSync28(join23(cwd, "Cargo.toml")))
+        projectType = "rust";
+      else if (existsSync28(join23(cwd, "go.mod")))
+        projectType = "go";
+      else if (existsSync28(join23(cwd, "pyproject.toml")))
+        projectType = "python";
+      for (const t of templates) {
+        const manifest = readJsonSafe5(join23(TEMPLATE_DIR2, t, "manifest.json"));
+        if (manifest && manifest.tags) {
+          const tags = manifest.tags;
+          if (tags.includes(projectType) || tags.includes("fullstack")) {
+            results.push({
+              action: "auto-template",
+              status: "warn",
+              message: `Template "${manifest.name}" matches this ${projectType} project → omocs template load ${manifest.name}`
+            });
+            break;
+          }
+        }
+      }
+    }
+  } catch {}
+  return results;
+}
+async function runAutoChecks(cwd, opts) {
+  const state2 = getAutoState();
+  const allResults = [];
+  allResults.push(...autoDoctor(cwd, state2));
+  allResults.push(...autoIndex(cwd, state2));
+  if (!opts?.skipCompact) {
+    allResults.push(...autoCompact(state2));
+  }
+  allResults.push(...autoTemplateSuggest(cwd, state2));
+  saveAutoState(state2);
+  if (!opts?.silent) {
+    const warnings = allResults.filter((r) => r.status === "warn");
+    const fixes = allResults.filter((r) => r.status === "fixed");
+    if (warnings.length > 0 || fixes.length > 0) {
+      console.log(source_default.dim("  ── omocs auto ──"));
+      for (const r of fixes) {
+        console.log(`  ${source_default.green("⚡")} ${source_default.dim(r.message)}`);
+      }
+      for (const r of warnings) {
+        console.log(`  ${source_default.yellow("⚠")}  ${source_default.dim(r.message)}`);
+      }
+      console.log("");
+    }
+  }
+  return allResults;
+}
+function suppressWarning(warning) {
+  const state2 = getAutoState();
+  if (!state2.suppressedWarnings.includes(warning)) {
+    state2.suppressedWarnings.push(warning);
+    saveAutoState(state2);
+  }
+}
+function resetAutoState() {
+  const state2 = {
+    lastCompact: 0,
+    lastIndex: {},
+    lastDoctor: 0,
+    structureHashes: {},
+    suppressedWarnings: []
+  };
+  saveAutoState(state2);
+}
+var OMOCS_DIR2, AUTO_STATE_FILE, INDEX_DIR3, MEMORY_DIR3, STATS_FILE2, TEMPLATE_DIR2, COMPACT_THRESHOLD_DAYS = 7, COMPACT_MEMORY_MAX_ENTRIES = 100, COMPACT_STATS_MAX_DAYS = 60, INDEX_STALE_HOURS = 24, IGNORED_DIRS3, WATCHED_EXTS2;
+var init_auto = __esm(() => {
+  init_source();
+  OMOCS_DIR2 = join23(homedir17(), ".omocs");
+  AUTO_STATE_FILE = join23(OMOCS_DIR2, "auto-state.json");
+  INDEX_DIR3 = join23(OMOCS_DIR2, "workspaces");
+  MEMORY_DIR3 = join23(OMOCS_DIR2, "memory");
+  STATS_FILE2 = join23(OMOCS_DIR2, "stats.json");
+  TEMPLATE_DIR2 = join23(OMOCS_DIR2, "templates");
+  IGNORED_DIRS3 = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "coverage", ".opencode", ".venv", "vendor"];
+  WATCHED_EXTS2 = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".rb", ".php", ".vue", ".svelte"];
+});
+
+// src/commands/auto.ts
+function registerAutoCommand(program2) {
+  const auto = program2.command("auto").description("Manage automatic background checks (doctor, index, compact, template)");
+  auto.command("run").description("Run all auto checks now").option("--verbose", "Show all results including OK statuses").action(async (opts) => {
+    try {
+      heading("⚡ Auto Checks");
+      info(`Workspace: ${source_default.gray(process.cwd())}`);
+      console.log("");
+      const results = await runAutoChecks(process.cwd(), { silent: true });
+      if (results.length === 0) {
+        success("Nothing to check.");
+        return;
+      }
+      for (const r of results) {
+        if (r.status === "ok" && !opts.verbose)
+          continue;
+        const icon = r.status === "ok" ? source_default.green("✅") : r.status === "fixed" ? source_default.green("⚡") : source_default.yellow("⚠️");
+        console.log(`  ${icon} ${source_default.bold(r.action)} — ${r.message}`);
+      }
+      const ok = results.filter((r) => r.status === "ok").length;
+      const fixed = results.filter((r) => r.status === "fixed").length;
+      const warned = results.filter((r) => r.status === "warn").length;
+      console.log("");
+      info(`OK: ${ok} | Fixed: ${fixed} | Warnings: ${warned}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  auto.command("reset").description("Reset auto state (force re-run all checks)").action(() => {
+    try {
+      resetAutoState();
+      success("Auto state reset. All checks will re-run on next invocation.");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  auto.command("suppress <warning>").description("Suppress a specific auto warning").action((warning) => {
+    try {
+      suppressWarning(warning);
+      success(`Suppressed: "${warning}"`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  auto.command("status").description("Show auto check state").action(() => {
+    try {
+      heading("⚡ Auto Status");
+      const { existsSync: existsSync29, readFileSync: readFileSync30 } = __require("fs");
+      const { join: join24 } = __require("path");
+      const { homedir: homedir18 } = __require("os");
+      const stateFile = join24(homedir18(), ".omocs", "auto-state.json");
+      if (!existsSync29(stateFile)) {
+        info("No auto state yet. Run `omocs auto run` to initialize.");
+        return;
+      }
+      const state2 = JSON.parse(readFileSync30(stateFile, "utf-8"));
+      const formatTime2 = (ts) => ts ? new Date(ts).toLocaleString() : "never";
+      console.log(`  ${source_default.dim("Last compact:")}  ${formatTime2(state2.lastCompact)}`);
+      console.log(`  ${source_default.dim("Last doctor:")}   ${formatTime2(state2.lastDoctor)}`);
+      console.log(`  ${source_default.dim("Indexed workspaces:")} ${Object.keys(state2.lastIndex || {}).length}`);
+      console.log(`  ${source_default.dim("Suppressed warnings:")} ${(state2.suppressedWarnings || []).length}`);
+      if (state2.suppressedWarnings?.length > 0) {
+        console.log("");
+        info("Suppressed:");
+        for (const w of state2.suppressedWarnings) {
+          console.log(`    ${source_default.gray("•")} ${source_default.dim(w)}`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  auto.action(() => {
+    heading("⚡ Auto Checks");
+    infoBox("Auto", [
+      "Automatic background checks run on every omocs command.",
+      "",
+      `  ${source_default.cyan("omocs auto run")}       — run all checks now`,
+      `  ${source_default.cyan("omocs auto status")}    — show check state`,
+      `  ${source_default.cyan("omocs auto reset")}     — force re-run all`,
+      `  ${source_default.cyan("omocs auto suppress")}  — hide a warning`,
+      "",
+      "Checks: doctor, index rebuild, compact, template suggest",
+      "Auto-runs on startup (non-blocking, max every 24h)."
+    ].join(`
+`));
+  });
+}
+var init_auto2 = __esm(() => {
+  init_source();
+  init_auto();
+  init_ui();
+});
+
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
@@ -42000,17 +42486,24 @@ var init_src = __esm(() => {
   init_watch();
   init_marketplace();
   init_squad();
+  init_auto2();
+  init_auto();
   init_find_package_json();
   pkg = readPackageJson(import.meta.url);
   VERSION3 = pkg.version;
   program2 = new Command;
-  program2.name("omocs").description("OMO Suites — CLI toolkit for OpenCode power users").version(VERSION3, "-v, --version", "Show version").hook("preAction", () => {
+  program2.name("omocs").description("OMO Suites — CLI toolkit for OpenCode power users").version(VERSION3, "-v, --version", "Show version").hook("preAction", (thisCommand) => {
     process.on("uncaughtException", (error) => {
       handleError(error);
     });
     process.on("unhandledRejection", (error) => {
       handleError(error);
     });
+    const cmdName = thisCommand.args?.[0] || thisCommand.name();
+    const skipAuto = ["auto", "completion", "help"].includes(cmdName);
+    if (!skipAuto) {
+      runAutoChecks(process.cwd(), { silent: false }).catch(() => {});
+    }
   });
   registerInitCommand(program2);
   registerDoctorCommand(program2);
@@ -42041,6 +42534,7 @@ var init_src = __esm(() => {
   registerWatchCommand(program2);
   registerMarketplaceCommand(program2);
   registerSquadCommand(program2);
+  registerAutoCommand(program2);
   program2.action(() => {
     showBanner();
     program2.help();

package/package.json

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