@yeaft/webchat-agent 0.1.700 → 0.1.702

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.700",
+  "version": "0.1.702",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/cli.js

@@ -31,6 +31,8 @@ import { loadSession } from './session.js';
 import { listModels, resolveModel, parseModelRef } from './models.js';
 import { buildSystemPrompt } from './prompts.js';
 import { searchMessages } from './conversation/search.js';
+import { ConversationStore } from './conversation/persist.js';
+import { snapshotGroups } from './groups/group-crud.js';
 
 // ─── Argument parsing ──────────────────────────────────────────
 
@@ -46,6 +48,9 @@ function parseArgs(argv) {
     dryRun: false,
     skipMCP: false,
     skipSkills: false,
+    compactOrphans: false,
+    compactOrphansDry: false,
+    deleteGroup: null,
     prompt: null,
   };
 
@@ -88,6 +93,15 @@ function parseArgs(argv) {
       case '--skip-skills':
         args.skipSkills = true;
         break;
+      case '--compact-orphans':
+        args.compactOrphans = true;
+        break;
+      case '--compact-orphans-dry':
+        args.compactOrphansDry = true;
+        break;
+      case '--delete-group':
+        args.deleteGroup = rest[++i] || null;
+        break;
       default:
         if (!arg.startsWith('-') && !args.prompt) {
           args.prompt = arg;
@@ -198,6 +212,81 @@ function handleDryRun(args, config) {
   console.log('=== END DRY RUN ===');
 }
 
+// ─── Maintenance handlers (no LLM session needed) ──────────────
+
+/**
+ * One-shot orphan-message sweep. Reads the live group list off disk and
+ * deletes every persisted message whose `groupId` frontmatter is missing
+ * or points to a group that no longer exists.
+ *
+ * Exposed via `--compact-orphans` (delete) and `--compact-orphans-dry`
+ * (preview only). Defensive: if the live group list is unreadable, we
+ * abort rather than wipe everything.
+ */
+function handleCompactOrphans(config, { dryRun = false } = {}) {
+  const yeaftDir = config.dir;
+  let groups;
+  try {
+    groups = snapshotGroups(yeaftDir);
+  } catch (err) {
+    console.error(`Cannot read groups directory: ${err.message}`);
+    console.error('Refusing to compact orphans without an authoritative live-group list.');
+    process.exitCode = 1;
+    return;
+  }
+  const keepGroupIds = (groups || []).map(g => g.id).filter(Boolean);
+  const store = new ConversationStore(yeaftDir);
+  const result = store.compactOrphans({ keepGroupIds, dryRun });
+
+  console.log(dryRun ? '=== COMPACT ORPHANS (dry run) ===' : '=== COMPACT ORPHANS ===');
+  console.log(`  Live groups:   ${keepGroupIds.length}${keepGroupIds.length ? ` (${keepGroupIds.join(', ')})` : ''}`);
+  console.log(`  Scanned:       ${result.scanned}`);
+  console.log(`  Orphan files:  ${result.orphans.length}`);
+  console.log(`  Removed:       ${result.removed}${dryRun ? ' (dry run — no files touched)' : ''}`);
+  if (result.orphans.length > 0) {
+    const preview = result.orphans.slice(0, 10);
+    for (const p of preview) console.log(`    - ${p}`);
+    if (result.orphans.length > preview.length) {
+      console.log(`    ... and ${result.orphans.length - preview.length} more`);
+    }
+  }
+}
+
+/**
+ * One-shot group hard-delete with cascade. Removes the group directory
+ * AND every persisted message stamped with that group id. Same semantics
+ * as the web-bridge `unify_delete_group` op, but reachable from the CLI
+ * for scripted maintenance.
+ */
+function handleDeleteGroup(config, groupId) {
+  const yeaftDir = config.dir;
+  // Lazy import to avoid loading the whole groups module on every CLI call.
+  // (Static `import` at top is fine too — kept dynamic to mirror the web-bridge
+  // pattern and keep the maintenance path self-contained.)
+  // eslint-disable-next-line global-require
+  return import('./groups/group-crud.js').then(({ deleteGroup }) => {
+    let result;
+    try {
+      result = deleteGroup(yeaftDir, groupId);
+    } catch (err) {
+      console.error(`Failed to delete group ${groupId}: ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    let messagesRemoved = 0;
+    try {
+      const store = new ConversationStore(yeaftDir);
+      messagesRemoved = store.deleteByGroup(groupId);
+    } catch (err) {
+      console.warn(`Group dir removed, but cascade failed: ${err.message}`);
+    }
+    console.log('=== DELETE GROUP ===');
+    console.log(`  Group:               ${result.groupId}`);
+    console.log(`  Legacy archives swept: ${result.legacyCleanedUp}`);
+    console.log(`  Messages cascaded:   ${messagesRemoved}`);
+  });
+}
+
 // ─── REPL ──────────────────────────────────────────────────────
 
 async function runREPL(config, args) {
@@ -674,6 +763,16 @@ async function main() {
     return;
   }
 
+  // Handle one-shot maintenance ops (no LLM needed, no session needed)
+  if (args.compactOrphans || args.compactOrphansDry) {
+    handleCompactOrphans(config, { dryRun: args.compactOrphansDry });
+    return;
+  }
+  if (args.deleteGroup) {
+    await handleDeleteGroup(config, args.deleteGroup);
+    return;
+  }
+
   // Handle interactive mode
   if (args.interactive) {
     await runREPL(config, args);
@@ -709,6 +808,9 @@ async function main() {
   console.log('  node cli.js --trace stats             — Debug trace statistics');
   console.log('  node cli.js --trace recent            — Recent turns');
   console.log('  node cli.js --trace search "keyword"  — Search traces');
+  console.log('  node cli.js --compact-orphans         — Delete orphan messages (no live group)');
+  console.log('  node cli.js --compact-orphans-dry     — Preview orphan sweep, no delete');
+  console.log('  node cli.js --delete-group <id>       — Hard delete group + cascade messages');
   console.log();
   console.log('Options:');
   console.log('  -d, --debug           Enable debug tracing');

package/unify/conversation/persist.js

@@ -580,6 +580,122 @@ export class ConversationStore {
 
   // ─── Internal ───────────────────────────────────────────
 
+  /**
+   * Delete every persisted message stamped with `groupId`. Scans both hot
+   * (`messages/`) and cold (`cold/`) directories and `unlink`s matching
+   * files. Messages without a `groupId` frontmatter are NOT touched —
+   * they may be legitimate pre-grouping legacy messages and are handled
+   * by `compactOrphans` instead.
+   *
+   * Used as the cascade step for hard-deleting a group: when the user
+   * deletes a group via web-bridge / CLI, the group's persisted message
+   * files would otherwise stick around as orphans.
+   *
+   * Idempotent and safe: missing dirs / unparseable files are skipped.
+   * Returns the number of message files removed.
+   *
+   * @param {string} groupId
+   * @returns {number}
+   */
+  deleteByGroup(groupId) {
+    if (!groupId) return 0;
+    let removed = 0;
+    for (const dir of [this.#msgDir, this.#coldDir]) {
+      if (!existsSync(dir)) continue;
+      let files;
+      try {
+        files = readdirSync(dir).filter(f => f.endsWith('.md'));
+      } catch (err) {
+        if (isPermissionError(err)) continue;
+        throw err;
+      }
+      for (const file of files) {
+        const path = join(dir, file);
+        let raw;
+        try {
+          raw = readFileSync(path, 'utf8');
+        } catch (err) {
+          if (isPermissionError(err)) continue;
+          throw err;
+        }
+        const msg = parseMessage(raw);
+        if (!msg || msg.groupId !== groupId) continue;
+        try {
+          unlinkSync(path);
+          removed += 1;
+        } catch (err) {
+          if (isPermissionError(err)) continue;
+          throw err;
+        }
+      }
+    }
+    // Invalidate cached next-seq — countHot/loadAll will re-scan.
+    this.#nextSeq = null;
+    return removed;
+  }
+
+  /**
+   * Sweep messages that don't belong to any live group. A message is
+   * considered an orphan when its frontmatter `groupId`:
+   *   - is missing entirely (legacy / pre-grouping); OR
+   *   - is set to a value not in `keepGroupIds`.
+   *
+   * One-shot maintenance helper exposed via the CLI (`--compact-orphans`).
+   * The caller is responsible for passing the authoritative live-group
+   * list — we do NOT auto-discover it here, because a transient failure
+   * in group loading (returning an empty list) would otherwise wipe
+   * every persisted message. Defensive design: an empty/missing
+   * `keepGroupIds` is rejected with a no-op return.
+   *
+   * @param {{ keepGroupIds: string[], dryRun?: boolean }} opts
+   * @returns {{ scanned: number, removed: number, orphans: string[], skipped: boolean }}
+   */
+  compactOrphans({ keepGroupIds, dryRun = false } = {}) {
+    if (!Array.isArray(keepGroupIds)) {
+      return { scanned: 0, removed: 0, orphans: [], skipped: true };
+    }
+    const keep = new Set(keepGroupIds);
+    let scanned = 0;
+    let removed = 0;
+    const orphans = [];
+    for (const dir of [this.#msgDir, this.#coldDir]) {
+      if (!existsSync(dir)) continue;
+      let files;
+      try {
+        files = readdirSync(dir).filter(f => f.endsWith('.md'));
+      } catch (err) {
+        if (isPermissionError(err)) continue;
+        throw err;
+      }
+      for (const file of files) {
+        const path = join(dir, file);
+        let raw;
+        try {
+          raw = readFileSync(path, 'utf8');
+        } catch (err) {
+          if (isPermissionError(err)) continue;
+          throw err;
+        }
+        const msg = parseMessage(raw);
+        if (!msg) continue;
+        scanned += 1;
+        const isOrphan = !msg.groupId || !keep.has(msg.groupId);
+        if (!isOrphan) continue;
+        orphans.push(path);
+        if (dryRun) continue;
+        try {
+          unlinkSync(path);
+          removed += 1;
+        } catch (err) {
+          if (isPermissionError(err)) continue;
+          throw err;
+        }
+      }
+    }
+    if (removed > 0) this.#nextSeq = null;
+    return { scanned, removed, orphans, skipped: false };
+  }
+
   /**
    * Reassign every message in this store whose `threadId === sourceId`
    * to `targetId`. The original thread id is preserved in

package/unify/web-bridge.js

@@ -377,7 +377,25 @@ export function handleUnifyDeleteGroup(msg) {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const result = deleteGroup(yeaftDir, groupId);
-    sendGroupCrudResult({ op: 'delete', requestId, ok: true, groupId: result.groupId });
+    // Cascade: remove every persisted message stamped with this group id.
+    // Hard delete (per user spec): no soft-archive, the bytes are gone.
+    // Skipped silently if the session/store isn't initialized — the next
+    // CLI `--compact-orphans` run will sweep them as orphans.
+    let messagesRemoved = 0;
+    try {
+      if (session && session.conversationStore) {
+        messagesRemoved = session.conversationStore.deleteByGroup(groupId);
+      }
+    } catch (cascadeErr) {
+      console.warn(`[Yeaft] cascade delete for group ${groupId} failed: ${cascadeErr.message}`);
+    }
+    sendGroupCrudResult({
+      op: 'delete',
+      requestId,
+      ok: true,
+      groupId: result.groupId,
+      messagesRemoved,
+    });
     sendGroupSnapshotBroadcast();
   } catch (err) {
     sendGroupCrudResult({ op: 'delete', requestId, ok: false, error: groupErrorPayload(err) });