@empirical-gauzza/cli 1.0.39 → 1.0.41

package/bin/empirical.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 'use strict';
 

package/lib/constants.js

@@ -352,13 +352,15 @@ A new interview is charged. \`setup abandon\` stops one but does not return what
     empirical workspace shape show --workspace-id <id>
     empirical workspace shape add-type "Reviewer" --workspace-id <id> --statuses "Not Yet Invited, Invited, Call Completed (done)" --fields "Email:text:required; Open to a call:select:Yes|No|Not asked; Wave:number" [--apply]
     empirical workspace shape add-status <type-key> "Declined" --done --workspace-id <id> [--apply]
+    empirical workspace shape add-status <type-key> "Call Scheduled" --after form_submitted --workspace-id <id> [--apply]
+    empirical workspace shape reorder-statuses <type-key> new,form_submitted,call_scheduled,call_held,won --workspace-id <id> [--apply]
     empirical workspace shape add-field <type-key> "Wave" --kind number --workspace-id <id> [--apply]
     empirical workspace shape edit --file <edit.json> [--mapping-file <m.json>] --workspace-id <id> [--apply]
     empirical workspace shape set --file <shape.json> --workspace-id <id> [--apply]
 
 The interview is the guided way and is charged. These are the direct way: you name the change and nothing is charged. Every change is a dry run until you add \`--apply\`: it is checked against the workspace's current shape, the result is printed, and with \`--apply\` it is saved only if the shape is still the one that was shown. You must manage the workspace; \`--apply\` needs \`--workspace-id\` written out, so a stale directory binding cannot aim a change at the wrong workspace.
 
-\`add-type\` on a workspace with no shape yet also needs \`--purpose "what this workspace is for"\` and creates its first shape. A kind of item with statuses must mark one as finished with \`(done)\`, and takes at most six fields. Field kinds: text, longText, number, date, select, multiSelect, person, link, url. \`--category\` and \`--node-type\` say how an item is stored as a memory (default project and entity). Keys are made from labels once and never change; refer to a type or status later by its key, which \`show\` prints in brackets.
+\`add-type\` on a workspace with no shape yet also needs \`--purpose "what this workspace is for"\` and creates its first shape. A kind of item with statuses must mark one as finished with \`(done)\`, and takes at most six fields. Field kinds: text, longText, number, date, select, multiSelect, person, link, url. \`--category\` and \`--node-type\` say how an item is stored as a memory (default project and entity). Keys are made from labels once and never change; refer to a type or status later by its key, which \`show\` prints in brackets. A new status goes just before the first finished status unless \`--after <key>\` or \`--before <key>\` places it; \`reorder-statuses\` takes every status key of the type once, in the new order (the first status is where new items start). Neither moves any item.
 
 \`edit\` takes the server's merge format: \`{"itemTypes":{"add":[...],"update":[{"key":"reviewer","statuses":{"add":[{"label":"Declined","isDone":true}]}}],"remove":["old-type"]}}\`. Removing or renaming something that has stored values needs \`--mapping-file\` saying where those values go. To save an item into the shape: \`empirical memory record --category lead --summary "..." --item-type reviewer --item-status invited --field email=a@b.com\` (run with \`EMPIRICAL_WORKSPACE_ID=<id>\` or after \`workspace use\`).
 
@@ -386,8 +388,10 @@ Resolution order for every memory command, first match wins: the \`EMPIRICAL_WOR
     empirical workspace invite create --role writer --expires-in-days 7 --max-uses 3
     empirical workspace invite list
     empirical workspace invite revoke <token>
+    empirical workspace invite email ana@example.com ben@example.com --role writer --note "Come help us review the book."
+    empirical workspace invite email ana@example.com --note-file ./invite-note.txt --from-name "Matt" --workspace-id ws_team_abc
 
-Invite commands operate on the active team workspace. Create prints a shareable URL.
+Invite commands operate on the active team workspace, or the one named by \`--workspace-id\`. Create prints a shareable URL. Email sends each address its own invite (one address per seat, expires in 14 days) and prints who was invited and why anyone was not; \`--note\` (up to 1000 characters) appears in the email as your own words, and \`--from-name\` changes the name the email says it is from ("Matt invited you") for that send only; without it your account's display name is used.
 
 ### Soft-delete a demo workspace
 

package/lib/help.js

@@ -53,13 +53,15 @@ function showHelp() {
   log('                                                Re-shape a team workspace you manage by interview. Without --workspace-id it');
   log('                                                confirms the workspace bound to this directory with you, at a terminal only;');
   log('                                                in a script or with --accept-cost it needs --workspace-id. A new interview is charged');
-  log('  empirical workspace shape show|set|edit|add-type|add-status|add-field --workspace-id <id> ...');
+  log('  empirical workspace shape show|set|edit|add-type|add-status|add-field|reorder-statuses --workspace-id <id> ...');
   log('                                                Edit the item types, statuses and fields of a workspace by hand, with no interview and no');
   log('                                                charge. A dry run until --apply. Details: empirical doc workspace');
   log('  empirical workspace invite create [--role reader|writer|manager] [--expires-in-days <n>] [--max-uses <n>]');
   log('                                                Create a shareable invite link for the active team workspace');
   log('  empirical workspace invite list              List active invites for the active team workspace');
   log('  empirical workspace invite revoke <token>    Revoke a previously created invite');
+  log('  empirical workspace invite email <address...> [--role reader|writer] [--note <text> | --note-file <path>] [--from-name <name>]');
+  log('                                                Email each person an invite, with your own note in the email');
   log('  empirical workspace delete <number|name|id> [--confirm]');
   log('                                                Soft-delete a team workspace (dry-run without --confirm)');
   log('');

package/lib/installWizard.js

@@ -36,6 +36,17 @@ function pluginNamesForInstallerOptions(options = {}) {
   return names.filter((name) => name === 'empirical-memory' || OPTIONAL_PLUGIN_NAMES.includes(name));
 }
 
+// Which detected CLIs to install for. At a terminal the person picks (Enter for all). With no
+// terminal, which is how an agent like Claude Code runs `empirical install` for someone, there is
+// nobody to answer, so it takes the default the list already shows: every detected CLI. Asking
+// anyway read an empty stdin and stopped with "nothing installed", so the agent's install did
+// nothing unless it knew to pipe an answer in.
+async function chooseInstallTargets(targets, { interactive = Boolean(process.stdin.isTTY), askFn = ask } = {}) {
+  if (!interactive) return targets.map((_, index) => index);
+  const answer = await askFn(uiQuestion('Press Enter for all, or select numbers (e.g. 1,2): '));
+  return parseSelection(answer, targets.length);
+}
+
 async function runInstallFlow() {
   log(uiHeader(`Empirical installer v${getCliVersion()}`));
   log('');
@@ -54,8 +65,10 @@ async function runInstallFlow() {
   });
   log('');
 
-  const answer = await ask(uiQuestion('Press Enter for all, or select numbers (e.g. 1,2): '));
-  const selectedIndexes = parseSelection(answer, targets.length);
+  const selectedIndexes = await chooseInstallTargets(targets);
+  if (!process.stdin.isTTY) {
+    log(`No terminal attached, so installing for every detected CLI: ${targets.map((t) => t.label).join(', ')}.`);
+  }
 
   if (selectedIndexes.length === 0) {
     log('No valid selection; nothing installed.');
@@ -407,5 +420,6 @@ async function runInstallFlow() {
 
 module.exports = {
   runInstallFlow,
-  pluginNamesForInstallerOptions
+  pluginNamesForInstallerOptions,
+  chooseInstallTargets
 };

package/lib/shapeCommands.js

@@ -6,7 +6,8 @@
 //   empirical workspace shape set       --workspace-id <id> --file <shape.json> [--apply]
 //   empirical workspace shape edit      --workspace-id <id> --file <edit.json>  [--apply]
 //   empirical workspace shape add-type  --workspace-id <id> <label> [--statuses "A,B,C (done)"] ...
-//   empirical workspace shape add-status --workspace-id <id> <type-key> <label> [--done]
+//   empirical workspace shape add-status --workspace-id <id> <type-key> <label> [--done] [--after <key> | --before <key>]
+//   empirical workspace shape reorder-statuses --workspace-id <id> <type-key> <key,key,...>
 //   empirical workspace shape add-field  --workspace-id <id> <type-key> <label> --kind <kind> ...
 //
 // The interview is charged (100 Empirical Tokens, plus 25 per change to a draft) and takes nine
@@ -16,23 +17,24 @@
 //
 // Every change is a DRY RUN until --apply. A change goes to /shape/preview first, which validates it
 // against the active shape and returns a confirmDigest; --apply sends that digest back, so an edit
-// is only ever applied to the shape that was shown. The commands here only ADD (a type, a status, a
-// field); removing needs a mapping for the stored values, which `edit --mapping-file` accepts.
+// is only ever applied to the shape that was shown. The commands here ADD (a type, a status, a field)
+// and REORDER statuses; removing needs a mapping for the stored values, which `edit --mapping-file`
+// accepts. A new status goes just before the first finished one unless --after or --before says where.
 
 const fs = require('fs');
 const { log, warn } = require('./ui');
 const { httpJson } = require('./http');
 const { parseOption, parseFlag } = require('./env');
 
-const SHAPE_ACTIONS = ['show', 'set', 'edit', 'add-type', 'add-status', 'add-field'];
+const SHAPE_ACTIONS = ['show', 'set', 'edit', 'add-type', 'add-status', 'add-field', 'reorder-statuses'];
 const FIELD_KINDS = ['text', 'longText', 'number', 'date', 'select', 'multiSelect', 'person', 'link', 'url'];
 const VALUE_OPTIONS = new Set([
   '--workspace-id', '--file', '--mapping-file', '--purpose', '--plural', '--category', '--node-type',
-  '--icon', '--color', '--statuses', '--fields', '--nest-under', '--kind', '--options'
+  '--icon', '--color', '--statuses', '--fields', '--nest-under', '--kind', '--options', '--after', '--before'
 ]);
 
 const SHAPE_USAGE = [
-  'Usage: empirical workspace shape <show|set|edit|add-type|add-status|add-field> --workspace-id <id> ...',
+  'Usage: empirical workspace shape <show|set|edit|add-type|add-status|add-field|reorder-statuses> --workspace-id <id> ...',
   '  show                                          print the workspace\'s item types, statuses and fields',
   '  set --file <shape.json> [--apply]             give a workspace with no shape its first shape',
   '  edit --file <edit.json> [--mapping-file <m.json>] [--apply]',
@@ -40,7 +42,9 @@ const SHAPE_USAGE = [
   '  add-type <label> [--statuses "A,B,C (done)"] [--fields "Email:text:required;Wave:number"]',
   '           [--plural <label>] [--category <cat>] [--node-type <type>] [--icon <i>] [--color <c>]',
   '           [--nest-under <type-key,...>] [--purpose <text>]   (--purpose only when the workspace has no shape yet)',
-  '  add-status <type-key> <label> [--done]',
+  '  add-status <type-key> <label> [--done] [--after <status-key> | --before <status-key>]',
+  '                                                without --after/--before it goes just before the first finished status',
+  '  reorder-statuses <type-key> <key,key,...>     every status key of that type once, in the new order',
   '  add-field <type-key> <label> [--kind text|longText|number|date|select|multiSelect|person|link|url]',
   '            [--required] [--options "Yes|No|Not asked"]',
   'Changes are a dry run until you add --apply. Running the interview instead: `empirical workspace shape` with no action.'
@@ -116,8 +120,15 @@ function buildTypeFromFlags(args, label) {
   return type;
 }
 
-function buildAddStatusEdit(typeKey, label, isDone) {
-  return { itemTypes: { update: [{ key: typeKey, statuses: { add: [isDone ? { label, isDone: true } : { label }] } }] } };
+function buildAddStatusEdit(typeKey, label, isDone, position = {}) {
+  const status = isDone ? { label, isDone: true } : { label };
+  if (position.after) status.after = position.after;
+  if (position.before) status.before = position.before;
+  return { itemTypes: { update: [{ key: typeKey, statuses: { add: [status] } }] } };
+}
+
+function buildReorderStatusesEdit(typeKey, keys) {
+  return { itemTypes: { update: [{ key: typeKey, statuses: { order: keys } }] } };
 }
 
 function buildAddFieldEdit(typeKey, field) {
@@ -278,8 +289,18 @@ async function runManualShapeCommand({ args, baseUrl, authHeaders, resolveBound
 
   if (action === 'add-status') {
     const [typeKey, label] = positionals(args);
-    if (!typeKey || !label) throw new Error('Usage: empirical workspace shape add-status <type-key> <label> [--done] --workspace-id <id> [--apply]');
-    return previewAndMaybeApply({ baseUrl, workspaceId, authHeaders, edit: buildAddStatusEdit(typeKey, label, parseFlag(args, '--done')), mapping, apply, asJson });
+    if (!typeKey || !label) throw new Error('Usage: empirical workspace shape add-status <type-key> <label> [--done] [--after <key> | --before <key>] --workspace-id <id> [--apply]');
+    const after = parseOption(args, '--after', '');
+    const before = parseOption(args, '--before', '');
+    if (after && before) throw new Error('Use --after or --before, not both.');
+    return previewAndMaybeApply({ baseUrl, workspaceId, authHeaders, edit: buildAddStatusEdit(typeKey, label, parseFlag(args, '--done'), { after, before }), mapping, apply, asJson });
+  }
+
+  if (action === 'reorder-statuses') {
+    const [typeKey, list] = positionals(args);
+    const keys = String(list || '').split(',').map((k) => k.trim()).filter(Boolean);
+    if (!typeKey || !keys.length) throw new Error('Usage: empirical workspace shape reorder-statuses <type-key> <key,key,...> --workspace-id <id> [--apply]   (`shape show` prints the keys)');
+    return previewAndMaybeApply({ baseUrl, workspaceId, authHeaders, edit: buildReorderStatusesEdit(typeKey, keys), mapping, apply, asJson });
   }
 
   if (action === 'add-field') {
@@ -307,6 +328,7 @@ module.exports = {
   parseFieldList,
   buildTypeFromFlags,
   buildAddStatusEdit,
+  buildReorderStatusesEdit,
   buildAddFieldEdit,
   formatShape,
   runManualShapeCommand

package/lib/workspaceCommands.js

@@ -53,7 +53,55 @@ async function resolveShapeTarget({ requested, local, answersFile, acceptCost, i
 function isWorkspaceCommand(args) {
   if (args[0] !== 'workspace') return false;
   if (['list', 'current', 'select', 'use', 'unbind', 'create', 'delete', 'shape'].includes(args[1])) return true;
-  return args[1] === 'invite' && ['create', 'list', 'revoke'].includes(args[2]);
+  return args[1] === 'invite' && ['create', 'list', 'revoke', 'email'].includes(args[2]);
+}
+
+// Mirrors WORKSPACE_INVITE_NOTE_MAX in @empirical/shared for a local pre-check only; the CLI is
+// published on its own and cannot import it. The server re-checks and is the one that decides.
+const INVITE_NOTE_MAX = 1000;
+
+const NOT_SENT_REASONS = {
+  invalid_email: 'not a valid email address',
+  already_member: 'already a member',
+  already_invited: 'already has a pending invite',
+  seat_limit: 'the workspace has no free seat',
+  recipient_suppressed: 'this address has bounced or unsubscribed before',
+  email_not_configured: 'email is not set up on this server',
+  send_failed: 'the email could not be sent'
+};
+
+// empirical workspace invite email <address...> [--role reader|writer] [--note <text> | --note-file <path>] [--from-name <name>]
+async function runInviteEmail({ args, inviteUrl, authHeaders, target }) {
+  const emails = positionalArgs(args, 3).join(' ').split(/[\s,;]+/).map((e) => e.trim()).filter(Boolean);
+  if (!emails.length) {
+    throw new Error('Usage: empirical workspace invite email <address...> [--role reader|writer] [--note <text> | --note-file <path>] [--from-name <name>] [--workspace-id <id>]');
+  }
+  const role = parseOption(args, '--role', 'reader');
+  if (!['reader', 'writer'].includes(role)) throw new Error('--role must be reader or writer for an emailed invite.');
+  const noteFile = parseOption(args, '--note-file', '');
+  let note = parseOption(args, '--note', '');
+  if (noteFile) {
+    if (note) throw new Error('Use --note or --note-file, not both.');
+    note = require('fs').readFileSync(noteFile, 'utf8');
+  }
+  note = String(note || '').replace(/\r\n?/g, '\n').trim();
+  if (note.length > INVITE_NOTE_MAX) throw new Error(`Keep the note under ${INVITE_NOTE_MAX} characters (it is ${note.length}).`);
+  // The name the email says it is from, for this send only. Empty means your account's display name.
+  const fromName = String(parseOption(args, '--from-name', '') || '').replace(/\s+/g, ' ').trim();
+  if (fromName && fromName.includes('@')) throw new Error('--from-name takes a name, not an email address.');
+  if (fromName && (fromName.length < 2 || fromName.length > 64)) throw new Error('--from-name must be 2 to 64 characters.');
+
+  const payload = await httpJson(`${inviteUrl}/email`, 'POST', { emails, accessRole: role, ...(note ? { note } : {}), ...(fromName ? { fromName } : {}) }, authHeaders);
+  const results = Array.isArray(payload?.results) ? payload.results : [];
+  const sent = results.filter((r) => r.sent);
+  const notSent = results.filter((r) => !r.sent);
+  if (sent.length) log(uiSuccess(`Invited to ${target.label} as ${role}: ${sent.map((r) => r.email).join(', ')}`));
+  for (const r of notSent) {
+    log(`Not sent to ${r.email}: ${NOT_SENT_REASONS[r.skippedReason] || r.skippedReason || 'unknown reason'}.${r.detail ? ` ${r.detail}` : ''}`);
+  }
+  if (sent.length && payload?.fromName) log(`Sent as ${payload.fromName}.`);
+  if (sent.length && note) log('Your note was included.');
+  if (!sent.length) process.exitCode = 1;
 }
 
 function describeSelectionSource(selection) {
@@ -72,7 +120,7 @@ function workspaceOptions(payload) {
 }
 
 function positionalArgs(args, startIndex) {
-  const valueOptions = new Set(['--description', '--role', '--expires-in-days', '--max-uses', '--answers', '--workspace-id']);
+  const valueOptions = new Set(['--description', '--role', '--expires-in-days', '--max-uses', '--answers', '--workspace-id', '--note', '--note-file', '--from-name']);
   const positional = [];
   for (let index = startIndex; index < args.length; index += 1) {
     if (valueOptions.has(args[index])) {
@@ -400,17 +448,23 @@ async function runWorkspaceCommand(args) {
       if (action === 'invite') {
         requireClientId(clientId);
         const inviteAction = args[2];
-        const currentPayload = await httpJson(currentUrl, 'GET', null, authHeaders);
-        const current = currentPayload?.current;
-        if (!current?.key || current.key === 'default_brain') {
-          throw new Error('Workspace invites require an active team workspace. Use `empirical workspace use <workspace>` first.');
+        const namedWorkspace = parseOption(args, '--workspace-id', '');
+        let target;
+        if (namedWorkspace) {
+          target = { workspaceId: namedWorkspace, label: namedWorkspace };
+        } else {
+          const currentPayload = await httpJson(currentUrl, 'GET', null, authHeaders);
+          const current = currentPayload?.current;
+          if (!current?.key || current.key === 'default_brain') {
+            throw new Error('Workspace invites require an active team workspace. Use `empirical workspace use <workspace>` first, or pass --workspace-id.');
+          }
+          const teamPayload = await httpJson(teamBrainsUrl, 'GET', null, authHeaders);
+          target = resolveWorkspaceTarget(
+            current.workspaceId || current.key,
+            { workspaces: [{ key: current.key, label: current.label, workspaceId: current.workspaceId }] },
+            teamPayload
+          );
         }
-        const teamPayload = await httpJson(teamBrainsUrl, 'GET', null, authHeaders);
-        const target = resolveWorkspaceTarget(
-          current.workspaceId || current.key,
-          { workspaces: [{ key: current.key, label: current.label, workspaceId: current.workspaceId }] },
-          teamPayload
-        );
         if (!target?.workspaceId) {
           throw new Error('The active workspace is not a team workspace available for invites.');
         }
@@ -434,6 +488,11 @@ async function runWorkspaceCommand(args) {
           return;
         }
 
+        if (inviteAction === 'email') {
+          await runInviteEmail({ args, inviteUrl, authHeaders, target });
+          return;
+        }
+
         if (inviteAction === 'list') {
           const payload = await httpJson(inviteUrl, 'GET', null, authHeaders);
           const invites = Array.isArray(payload?.invites) ? payload.invites : [];

package/package.json

@@ -1,33 +1,33 @@
-{
-  "name": "@empirical-gauzza/cli",
-  "version": "1.0.39",
-  "description": "Persistent cross-tool memory for AI agents. Give Claude Code, Codex, Copilot, Cursor, and ChatGPT one shared memory: save project context once, recall it everywhere via CLI or MCP.",
-  "keywords": [
-    "memory",
-    "mcp",
-    "agent memory",
-    "ai memory",
-    "claude",
-    "chatgpt",
-    "model context protocol",
-    "persistent memory",
-    "claude-code",
-    "codex",
-    "knowledge base"
-  ],
-  "type": "commonjs",
-  "license": "MIT",
-  "homepage": "https://empirical.gauzza.com/docs/cli-details",
-  "publishConfig": {
-    "access": "public"
-  },
-  "bin": {
-    "empirical": "bin/empirical.js"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "gray-matter": "^4.0.3"
-  }
-}
+{
+  "name": "@empirical-gauzza/cli",
+  "version": "1.0.41",
+  "description": "Persistent cross-tool memory for AI agents. Give Claude Code, Codex, Copilot, Cursor, and ChatGPT one shared memory: save project context once, recall it everywhere via CLI or MCP.",
+  "keywords": [
+    "memory",
+    "mcp",
+    "agent memory",
+    "ai memory",
+    "claude",
+    "chatgpt",
+    "model context protocol",
+    "persistent memory",
+    "claude-code",
+    "codex",
+    "knowledge base"
+  ],
+  "type": "commonjs",
+  "license": "MIT",
+  "homepage": "https://empirical.gauzza.com/docs/cli-details",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "empirical": "bin/empirical.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3"
+  }
+}