memhouse 0.15.0 → 0.16.0

package/bin/memhouse.js

@@ -30,6 +30,7 @@ const {
 const envfile = require(path.join(REPO_ROOT, 'memhouse', 'envfile'));
 const { consumeSecretChunk } = require(path.join(REPO_ROOT, 'memhouse', 'secret-input'));
 const { capabilitiesFrom } = require(path.join(REPO_ROOT, 'memhouse', 'capabilities'));
+const { unknownFlags, allowedFlags, suggestFlag } = require(path.join(REPO_ROOT, 'memhouse', 'flags'));
 
 const HOME_DIR = process.env.MEMHOUSE_HOME || path.join(os.homedir(), '.memhouse');
 const ENV_FILE = path.join(HOME_DIR, 'env');
@@ -53,6 +54,22 @@ for (let i = 0; i < rest.length; i++) {
 }
 const JSON_OUT = flags.json === true;
 
+// Unknown flags stop the run — see memhouse/flags.js for why a shrug is not enough.
+(() => {
+  const bad = unknownFlags(cmd, flags);
+  if (!bad.length) return;
+  const allowed = allowedFlags(cmd);
+  for (const f of bad) {
+    const hint = suggestFlag(f, allowed);
+    console.error(`memhouse: unknown option --${f}${hint ? `  (did you mean --${hint}?)` : ''}`);
+  }
+  const list = [...allowed].sort().map((f) => `--${f}`).join(' ');
+  console.error(`  ${cmd || 'memhouse'} takes: ${list || '(no options)'}`);
+  console.error('  Nothing ran. A flag that is ignored rather than refused is how a --dry-run typo');
+  console.error('  becomes a real migration.');
+  process.exit(2);
+})();
+
 let ONBOARDING = false;
 let _inviteFileToShred = null;
 let _inviteWantsRotate = false;
@@ -2957,6 +2974,9 @@ async function cmdWhoami() {
   const au = process.env.MEMHOUSE_ADMIN_USER;
   const ap = process.env.MEMHOUSE_ADMIN_PASSWORD;
   const usingAdminEnv = wantAdmin && au;
+  // `--admin` with nothing to resolve is worth saying out loud. Silently falling back to
+  // the member credential makes `whoami --admin` and `whoami` print the same thing, and
+  // the reader is left thinking they asked a question the program never heard.
   const who = usingAdminEnv ? { ...cfg, user: au, password: ap || '' } : cfg;
 
   if (!who.url || !who.user) {
@@ -2990,10 +3010,16 @@ async function cmdWhoami() {
     console.log(JSON.stringify({
       ok: true, url: who.url, user: server, db: who.db, source, role, ...caps,
       grants_readable: grants.length > 0,
+      admin_env_present: Boolean(au),
+      admin_requested: wantAdmin,
     }, null, 2));
     return 0;
   }
   console.log(ok(`${server} at ${who.url} — ${role}`));
+  if (wantAdmin && !usingAdminEnv) {
+    console.log(warn('--admin asked for MEMHOUSE_ADMIN_USER / MEMHOUSE_ADMIN_PASSWORD; neither is set,'));
+    console.log('  so this is the ordinary configured credential.');
+  }
   console.log(`  credential from: ${source}`);
   console.log(`  house:           ${who.db || '(none set)'}`);
   console.log(`  may create users:    ${caps.canMintUsers ? 'yes' : 'no'}`);

package/memhouse/delivery/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mem",
   "description": "Conversation memory for AI agents over the memhouse typed ClickHouse store: ask, search, browse, analyze, check, share, and invite across all 17 supported editors and machines, plus administration of the ClickHouse behind it. Skills install as /mem:hello, /mem:ask, /mem:search, /mem:sessions, /mem:share, /mem:invite, /mem:sql, /mem:status, /mem:users, and /mem:admin.",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "author": {
     "name": "Ramazan Polat"
   },

package/memhouse/flags.js

@@ -0,0 +1,76 @@
+// Which options each command takes, and what to say when one is not among them.
+//
+// Anything `--like-this` used to be accepted and ignored. That is quiet in the good case
+// and dangerous in the bad one: `--dryrun` for `--dry-run` does not warn, it RUNS the
+// migration; `--adopt` on a build that predates the guard is swallowed and the invite
+// proceeds into somebody else's house. A flag the program does not know is a sentence
+// the user believes they said and the program never heard.
+//
+// The tables live here rather than beside the parser so a test can hold them against the
+// flags the CLI actually reads — a flag added to one and not the other fails the suite
+// instead of being discovered by whoever typed it.
+
+const GLOBAL_FLAGS = ['json', 'yes', 'help', 'version'];
+
+const COMMAND_FLAGS = {
+  null: [], help: [], version: [],
+  whoami: ['admin'],
+  discover: [], stats: [], stop: [], doctor: [], 'sessions-query': [],
+  status: [], start: [],
+  onboard: ['url', 'user', 'password', 'db', 'port', 'no-ship', 'target', 'house-port', 'tag', 'local'],
+  install: ['url', 'user', 'password', 'db', 'port', 'no-ship', 'env', 'print-sql', 'member',
+    'member-password', 'admin-user', 'admin-password', 'ensure-schema', 'rotate-password', 'force'],
+  setup: ['url', 'user', 'password', 'db', 'port'],
+  ship: ['full', 'loop', 'ensure-schema'],
+  search: ['limit'],
+  resume: [],
+  update: ['check', 'migrate', 'no-install'],
+  reset: ['all-origins'],
+  invite: ['url', 'db', 'out', 'admin-user', 'admin-password', 'adopt', 'print-sql',
+    'allow-local', 'member-password'],
+  passwd: ['password', 'admin-user', 'admin-password', 'print-sql', 'member'],
+  nightly: ['out'],
+  migrate: ['dry-run'], 'migrate-rooms': ['dry-run'],
+  relocate: ['to', 'to-user', 'to-password', 'to-db', 'from-native-host', 'from-native-port',
+    'insecure-native', 'keep-shipper', 'dry-run'],
+  deploy: ['local', 'down', 'house-port', 'port', 'tag'],
+  service: ['interval'],
+  uninstall: ['credentials', 'full-removal'],
+  plugins: ['target'],
+  prompt: ['install'],
+};
+
+/** Levenshtein, small and local — this is the only caller. */
+function editDistance(a, b) {
+  const m = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 0; j <= b.length; j++) m[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      m[i][j] = Math.min(m[i - 1][j] + 1, m[i][j - 1] + 1, m[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+  }
+  return m[a.length][b.length];
+}
+
+/** The flag a typo most likely meant, or null when nothing is close enough to guess. */
+function suggestFlag(bad, allowed) {
+  let best = null; let bd = Infinity;
+  for (const c of allowed) { const d = editDistance(bad, c); if (d < bd) { bd = d; best = c; } }
+  return bd <= Math.max(2, Math.floor(bad.length / 3)) ? best : null;
+}
+
+/** Every option this command does not take. Unknown COMMANDS return [] — dispatch owns that. */
+function unknownFlags(cmd, flags) {
+  const known = COMMAND_FLAGS[cmd === null || cmd === undefined ? 'null' : cmd];
+  if (known === undefined) return [];
+  const allowed = allowedFlags(cmd);
+  return Object.keys(flags).filter((f) => !allowed.has(f));
+}
+
+/** The full accepted set for a command, globals included. */
+function allowedFlags(cmd) {
+  const known = COMMAND_FLAGS[cmd === null || cmd === undefined ? 'null' : cmd] || [];
+  return new Set([...GLOBAL_FLAGS, ...known]);
+}
+
+module.exports = { GLOBAL_FLAGS, COMMAND_FLAGS, unknownFlags, allowedFlags, suggestFlag, editDistance };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memhouse",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "memhouse \u2014 agent conversation memory across 17 editors: parse-on-client shippers, a typed ClickHouse store with one set of rooms per member, kernel-agency install, and the agentlytics dashboard",
   "main": "bin/memhouse.js",
   "bin": {