@empirical-gauzza/cli 1.0.37 → 1.0.39

package/lib/workspaceCommands.js

@@ -1,12 +1,15 @@
 'use strict';
 
-const { log, ask, uiSuccess } = require('./ui');
+const { log, warn, ask, askYesNo, uiSuccess } = require('./ui');
 const { httpJson } = require('./http');
 const { getEnv, parseFlag, parseOption } = require('./env');
 const { ensureHeadlessToken, resolveAccessToken, buildApiAuthHeaders } = require('./auth');
 const { readStoredOAuthClient } = require('./oauthClient');
 const { deriveBaseUrlFromMcpUrl } = require('./constants');
 const { withCliAnalyticsContext } = require('./memoryCommands');
+const { runWorkspaceInterview, sanitizeForTerminal } = require('./setupCommands');
+const { isManualShapeAction, runManualShapeCommand } = require('./shapeCommands');
+const { isInteractiveTerminal } = require('./empiricalTokensFormat');
 const {
   writeSelectedWorkspace,
   clearSelectedWorkspace,
@@ -18,9 +21,38 @@ const {
   WORKSPACE_ENV_VAR
 } = require('./workspaceContext');
 
+const WORKSPACE_CREATE_INTERVIEW_USAGE = 'Usage: empirical workspace create --interview [--answers <file.json>] [--accept-cost]. The interview asks what the workspace is for, so it takes no name.';
+const WORKSPACE_SHAPE_USAGE = 'Usage: empirical workspace shape [--workspace-id <id>] [--answers <file.json>] [--accept-cost]. Pass --workspace-id, or at a terminal bind this directory to the workspace first with `empirical workspace use <id>` and the command will ask you to confirm it.';
+const WORKSPACE_SHAPE_EXPLICIT_ID = 'A re-shape is charged, so a script (--answers or --accept-cost) or a run with no terminal must name the workspace itself. Pass --workspace-id <id>; the workspace this directory is bound to is not used here.';
+
+// Which workspace `workspace shape` re-shapes. An explicit --workspace-id is used as given. The ambient
+// binding (env, project or global) is a convenience for a person at a terminal ONLY: it is shown by NAME
+// and source and needs a yes that names the workspace, and it is never used by a script or with
+// --accept-cost, so a stale binding cannot aim a paid re-shape at the wrong workspace unseen.
+// Everything said here goes to stderr (warn), so a scripted run keeps stdout for its result.
+async function resolveShapeTarget({ requested, local, answersFile, acceptCost, interactive, fetchName, askYesNo: confirm, say = warn }) {
+  if (requested) {
+    say(`Re-shaping workspace ${sanitizeForTerminal(requested)}.`);
+    return requested;
+  }
+  if (!local || !local.workspaceId) throw new Error(WORKSPACE_SHAPE_USAGE);
+  if (answersFile || acceptCost || !interactive) throw new Error(WORKSPACE_SHAPE_EXPLICIT_ID);
+  let name = '';
+  try { name = String((await fetchName(local.workspaceId)) || ''); } catch (_error) { name = ''; }
+  // The name can come from an AI-generated purpose, and everything below reaches the terminal: sanitised.
+  name = sanitizeForTerminal(name || String(local.label || ''));
+  const id = sanitizeForTerminal(local.workspaceId);
+  const source = sanitizeForTerminal(describeSelectionSource(local).trim().replace(/^\(|\)$/g, '')) || 'a local binding';
+  const shown = name ? `"${name}" (${id})` : id;
+  say(`No --workspace-id was given. This directory is bound to ${shown}: ${source}.`);
+  const yes = await confirm(`Re-shape ${name ? `"${name}"` : `workspace ${id}`}? This starts an interview that is charged.`, false, process.stderr);
+  if (!yes) throw new Error('Nothing was started. Pass --workspace-id <id> to name the workspace.');
+  return local.workspaceId;
+}
+
 function isWorkspaceCommand(args) {
   if (args[0] !== 'workspace') return false;
-  if (['list', 'current', 'select', 'use', 'unbind', 'create', 'delete'].includes(args[1])) return true;
+  if (['list', 'current', 'select', 'use', 'unbind', 'create', 'delete', 'shape'].includes(args[1])) return true;
   return args[1] === 'invite' && ['create', 'list', 'revoke'].includes(args[2]);
 }
 
@@ -40,7 +72,7 @@ function workspaceOptions(payload) {
 }
 
 function positionalArgs(args, startIndex) {
-  const valueOptions = new Set(['--description', '--role', '--expires-in-days', '--max-uses']);
+  const valueOptions = new Set(['--description', '--role', '--expires-in-days', '--max-uses', '--answers', '--workspace-id']);
   const positional = [];
   for (let index = startIndex; index < args.length; index += 1) {
     if (valueOptions.has(args[index])) {
@@ -276,9 +308,48 @@ async function runWorkspaceCommand(args) {
         return;
       }
 
+      if (action === 'shape' && isManualShapeAction(args)) {
+        // Editing the shape by hand (show, set, edit, add-type, add-status, add-field): no interview, no charge.
+        // A dry run unless --apply, and a change is only applied to the shape that was previewed.
+        const bound = resolveLocalWorkspaceSelection();
+        return runManualShapeCommand({ args, baseUrl, authHeaders, resolveBound: () => (bound && bound.workspaceId) || '' });
+      }
+
+      if (action === 'shape') {
+        // Re-shapes a team workspace you manage through the interview. resolveShapeTarget decides which: an
+        // explicit --workspace-id, or (at a terminal only, after a named yes) the bound workspace.
+        const requested = parseOption(args, '--workspace-id', '').trim();
+        const answersFile = parseOption(args, '--answers', '');
+        const acceptCost = parseFlag(args, '--accept-cost');
+        const targetWorkspaceId = await resolveShapeTarget({
+          requested,
+          local: requested ? null : resolveLocalWorkspaceSelection(),
+          answersFile,
+          acceptCost,
+          interactive: isInteractiveTerminal(),
+          fetchName: async (id) => {
+            const payload = await httpJson(teamBrainsUrl, 'GET', null, authHeaders);
+            const hit = getTeamBrains(payload).find((b) => b.workspaceId === id);
+            return hit ? hit.name : '';
+          },
+          askYesNo
+        });
+        return runWorkspaceInterview({ targetWorkspaceId, answersFile, acceptCost });
+      }
+
+      if (action === 'create' && parseFlag(args, '--interview')) {
+        // Creating through the interview takes no name (it asks what the workspace is for), and it never
+        // re-shapes: with no --workspace-id it always makes a new workspace.
+        if (positionalArgs(args, 2).length || parseOption(args, '--workspace-id', '')) throw new Error(WORKSPACE_CREATE_INTERVIEW_USAGE);
+        return runWorkspaceInterview({
+          answersFile: parseOption(args, '--answers', ''),
+          acceptCost: parseFlag(args, '--accept-cost')
+        });
+      }
+
       if (action === 'create') {
         const name = positionalArgs(args, 2).join(' ').trim();
-        if (!name) throw new Error('Usage: empirical workspace create <name> [--description <text>]');
+        if (!name) throw new Error('Usage: empirical workspace create <name> [--description <text>]  or  empirical workspace create --interview');
         const description = parseOption(args, '--description', '');
         const created = await httpJson(
           teamBrainsUrl,
@@ -394,5 +465,9 @@ module.exports = {
   isWorkspaceCommand,
   getWorkspaceCommandAuth,
   resolveWorkspaceTarget,
-  runWorkspaceCommand
+  runWorkspaceCommand,
+  WORKSPACE_CREATE_INTERVIEW_USAGE,
+  WORKSPACE_SHAPE_USAGE,
+  WORKSPACE_SHAPE_EXPLICIT_ID,
+  resolveShapeTarget
 };

package/lib/workspaceContext.js

@@ -1,176 +1,176 @@
-'use strict';
-
-const os = require('os');
-const path = require('path');
-const fs = require('fs');
-const { execFileSync } = require('child_process');
-const { httpJson } = require('./http');
-const { getEnv } = require('./env');
-const { resolveAccessToken, resolveApiBaseUrl, buildApiAuthHeaders } = require('./auth');
-const { readStoredOAuthClient } = require('./oauthClient');
-const { readJsonIfExists, writeFile, ensureDir } = require('./fsUtils');
-
-const WORKSPACE_CONTEXT_TIMEOUT_MS = 2000;
-const SELECTED_WORKSPACE_PATH = path.join(os.homedir(), '.empirical', 'workspace-selection.json');
-
-// Per-project binding (2026-09-24). The global selection above is one file per machine, so any
-// session in any repo flips it for every other session: a WOB session left the CLI on the WOB team
-// workspace and every tag-scoped recall from an empirical_v2 session returned [] while the memories
-// existed. The unit that actually varies is the project directory, like git config, so a project
-// can pin its workspace in <repo>/.empirical/workspace.json and `use` writes there by default when
-// run inside a git repo. Resolution order, first hit wins: env, project, global, then the server's
-// per-client selection exactly as before. No project file and no env means today's behavior.
-const PROJECT_WORKSPACE_DIRNAME = '.empirical';
-const PROJECT_WORKSPACE_FILENAME = 'workspace.json';
-const WORKSPACE_ENV_VAR = 'EMPIRICAL_WORKSPACE_ID';
-
-function readSelectedWorkspace() {
-  const value = readJsonIfExists(SELECTED_WORKSPACE_PATH);
-  return value && typeof value.workspaceId === 'string' ? value : null;
-}
-
-function writeSelectedWorkspace(workspace) {
-  ensureDir(path.dirname(SELECTED_WORKSPACE_PATH));
-  writeFile(SELECTED_WORKSPACE_PATH, `${JSON.stringify(workspace, null, 2)}\n`);
-}
-
-function clearSelectedWorkspace() {
-  if (fs.existsSync(SELECTED_WORKSPACE_PATH)) fs.unlinkSync(SELECTED_WORKSPACE_PATH);
-}
-
-/**
- * Nearest <dir>/.empirical/workspace.json walking up from `startDir` to the filesystem root.
- * Returns { path, value } or null. A malformed file is ignored rather than fatal: a broken
- * binding must not take the CLI down, it just falls through to the next source.
- */
-function findProjectWorkspaceFile(startDir = process.cwd()) {
-  let dir = path.resolve(startDir);
-  for (;;) {
-    const candidate = path.join(dir, PROJECT_WORKSPACE_DIRNAME, PROJECT_WORKSPACE_FILENAME);
-    const value = readJsonIfExists(candidate);
-    if (value && typeof value.workspaceId === 'string' && value.workspaceId.trim()) {
-      return { path: candidate, value };
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-
-/**
- * The git toplevel for `cwd`, or null outside a repo (or without git). Used to decide where
- * `workspace use` writes by default and where the project binding lives.
- */
-function findGitRoot(cwd = process.cwd()) {
-  try {
-    const out = execFileSync('git', ['rev-parse', '--show-toplevel'], {
-      cwd,
-      stdio: ['ignore', 'pipe', 'ignore'],
-      encoding: 'utf8'
-    });
-    const root = String(out || '').trim();
-    return root ? path.resolve(root) : null;
-  } catch (_error) {
-    return null;
-  }
-}
-
-function projectWorkspacePathFor(rootDir) {
-  return path.join(rootDir, PROJECT_WORKSPACE_DIRNAME, PROJECT_WORKSPACE_FILENAME);
-}
-
-function writeProjectWorkspace(rootDir, workspace) {
-  const filePath = projectWorkspacePathFor(rootDir);
-  ensureDir(path.dirname(filePath));
-  writeFile(filePath, `${JSON.stringify({ ...workspace, boundAt: new Date().toISOString() }, null, 2)}\n`);
-  return filePath;
-}
-
-function clearProjectWorkspace(rootDir) {
-  const filePath = projectWorkspacePathFor(rootDir);
-  if (fs.existsSync(filePath)) {
-    fs.unlinkSync(filePath);
-    return filePath;
-  }
-  return null;
-}
-
-/**
- * The single answer to "which workspace does this CLI invocation act on", before asking the
- * server. Every memory command and `workspace current` read this, so reads and writes can never
- * disagree again. Returns { workspaceId, label, key, source, path } or null when nothing local
- * is set (the caller then falls back to the server's per-client selection).
- */
-function resolveLocalWorkspaceSelection({ cwd = process.cwd(), env = process.env } = {}) {
-  const fromEnv = String(env[WORKSPACE_ENV_VAR] || '').trim();
-  if (fromEnv) {
-    return { workspaceId: fromEnv, label: null, key: null, source: 'env', path: WORKSPACE_ENV_VAR };
-  }
-  const project = findProjectWorkspaceFile(cwd);
-  if (project) {
-    const { workspaceId, label = null, key = null } = project.value;
-    return { workspaceId: workspaceId.trim(), label, key, source: 'project', path: project.path };
-  }
-  const global = readSelectedWorkspace();
-  if (global) {
-    return { workspaceId: global.workspaceId, label: global.label || null, key: global.key || null, source: 'global', path: SELECTED_WORKSPACE_PATH };
-  }
-  return null;
-}
-
-async function withSelectedWorkspaceContext(fn) {
-  const local = resolveLocalWorkspaceSelection();
-  if (local?.workspaceId) {
-    const previousWorkspaceId = globalThis.__empiricalCliWorkspaceId || null;
-    globalThis.__empiricalCliWorkspaceId = local.workspaceId;
-    try {
-      return await fn();
-    } finally {
-      globalThis.__empiricalCliWorkspaceId = previousWorkspaceId;
-    }
-  }
-
-  const accessToken = resolveAccessToken();
-  const clientId = getEnv('EMPIRICAL_CLIENT_ID') || readStoredOAuthClient()?.clientId;
-  if (!accessToken || !clientId) return fn();
-
-  const previousWorkspaceId = globalThis.__empiricalCliWorkspaceId || null;
-  globalThis.__empiricalCliWorkspaceId = null;
-  try {
-    const baseUrl = resolveApiBaseUrl();
-    const currentUrl = new URL(
-      `/oauth/clients/${encodeURIComponent(clientId)}/workspace-selection`,
-      baseUrl
-    ).toString();
-    try {
-      const payload = await httpJson(
-        currentUrl,
-        'GET',
-        null,
-        buildApiAuthHeaders(accessToken),
-        WORKSPACE_CONTEXT_TIMEOUT_MS
-      );
-      globalThis.__empiricalCliWorkspaceId = payload?.current?.workspaceId || null;
-    } catch (_error) {
-      globalThis.__empiricalCliWorkspaceId = null;
-    }
-    return await fn();
-  } finally {
-    globalThis.__empiricalCliWorkspaceId = previousWorkspaceId;
-  }
-}
-
-module.exports = {
-  withSelectedWorkspaceContext,
-  resolveLocalWorkspaceSelection,
-  readSelectedWorkspace,
-  writeSelectedWorkspace,
-  clearSelectedWorkspace,
-  findProjectWorkspaceFile,
-  findGitRoot,
-  projectWorkspacePathFor,
-  writeProjectWorkspace,
-  clearProjectWorkspace,
-  WORKSPACE_ENV_VAR,
-  SELECTED_WORKSPACE_PATH
-};
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { execFileSync } = require('child_process');
+const { httpJson } = require('./http');
+const { getEnv } = require('./env');
+const { resolveAccessToken, resolveApiBaseUrl, buildApiAuthHeaders } = require('./auth');
+const { readStoredOAuthClient } = require('./oauthClient');
+const { readJsonIfExists, writeFile, ensureDir } = require('./fsUtils');
+
+const WORKSPACE_CONTEXT_TIMEOUT_MS = 2000;
+const SELECTED_WORKSPACE_PATH = path.join(os.homedir(), '.empirical', 'workspace-selection.json');
+
+// Per-project binding (2026-09-24). The global selection above is one file per machine, so any
+// session in any repo flips it for every other session: a WOB session left the CLI on the WOB team
+// workspace and every tag-scoped recall from an empirical_v2 session returned [] while the memories
+// existed. The unit that actually varies is the project directory, like git config, so a project
+// can pin its workspace in <repo>/.empirical/workspace.json and `use` writes there by default when
+// run inside a git repo. Resolution order, first hit wins: env, project, global, then the server's
+// per-client selection exactly as before. No project file and no env means today's behavior.
+const PROJECT_WORKSPACE_DIRNAME = '.empirical';
+const PROJECT_WORKSPACE_FILENAME = 'workspace.json';
+const WORKSPACE_ENV_VAR = 'EMPIRICAL_WORKSPACE_ID';
+
+function readSelectedWorkspace() {
+  const value = readJsonIfExists(SELECTED_WORKSPACE_PATH);
+  return value && typeof value.workspaceId === 'string' ? value : null;
+}
+
+function writeSelectedWorkspace(workspace) {
+  ensureDir(path.dirname(SELECTED_WORKSPACE_PATH));
+  writeFile(SELECTED_WORKSPACE_PATH, `${JSON.stringify(workspace, null, 2)}\n`);
+}
+
+function clearSelectedWorkspace() {
+  if (fs.existsSync(SELECTED_WORKSPACE_PATH)) fs.unlinkSync(SELECTED_WORKSPACE_PATH);
+}
+
+/**
+ * Nearest <dir>/.empirical/workspace.json walking up from `startDir` to the filesystem root.
+ * Returns { path, value } or null. A malformed file is ignored rather than fatal: a broken
+ * binding must not take the CLI down, it just falls through to the next source.
+ */
+function findProjectWorkspaceFile(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  for (;;) {
+    const candidate = path.join(dir, PROJECT_WORKSPACE_DIRNAME, PROJECT_WORKSPACE_FILENAME);
+    const value = readJsonIfExists(candidate);
+    if (value && typeof value.workspaceId === 'string' && value.workspaceId.trim()) {
+      return { path: candidate, value };
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * The git toplevel for `cwd`, or null outside a repo (or without git). Used to decide where
+ * `workspace use` writes by default and where the project binding lives.
+ */
+function findGitRoot(cwd = process.cwd()) {
+  try {
+    const out = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf8'
+    });
+    const root = String(out || '').trim();
+    return root ? path.resolve(root) : null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+function projectWorkspacePathFor(rootDir) {
+  return path.join(rootDir, PROJECT_WORKSPACE_DIRNAME, PROJECT_WORKSPACE_FILENAME);
+}
+
+function writeProjectWorkspace(rootDir, workspace) {
+  const filePath = projectWorkspacePathFor(rootDir);
+  ensureDir(path.dirname(filePath));
+  writeFile(filePath, `${JSON.stringify({ ...workspace, boundAt: new Date().toISOString() }, null, 2)}\n`);
+  return filePath;
+}
+
+function clearProjectWorkspace(rootDir) {
+  const filePath = projectWorkspacePathFor(rootDir);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+    return filePath;
+  }
+  return null;
+}
+
+/**
+ * The single answer to "which workspace does this CLI invocation act on", before asking the
+ * server. Every memory command and `workspace current` read this, so reads and writes can never
+ * disagree again. Returns { workspaceId, label, key, source, path } or null when nothing local
+ * is set (the caller then falls back to the server's per-client selection).
+ */
+function resolveLocalWorkspaceSelection({ cwd = process.cwd(), env = process.env } = {}) {
+  const fromEnv = String(env[WORKSPACE_ENV_VAR] || '').trim();
+  if (fromEnv) {
+    return { workspaceId: fromEnv, label: null, key: null, source: 'env', path: WORKSPACE_ENV_VAR };
+  }
+  const project = findProjectWorkspaceFile(cwd);
+  if (project) {
+    const { workspaceId, label = null, key = null } = project.value;
+    return { workspaceId: workspaceId.trim(), label, key, source: 'project', path: project.path };
+  }
+  const global = readSelectedWorkspace();
+  if (global) {
+    return { workspaceId: global.workspaceId, label: global.label || null, key: global.key || null, source: 'global', path: SELECTED_WORKSPACE_PATH };
+  }
+  return null;
+}
+
+async function withSelectedWorkspaceContext(fn) {
+  const local = resolveLocalWorkspaceSelection();
+  if (local?.workspaceId) {
+    const previousWorkspaceId = globalThis.__empiricalCliWorkspaceId || null;
+    globalThis.__empiricalCliWorkspaceId = local.workspaceId;
+    try {
+      return await fn();
+    } finally {
+      globalThis.__empiricalCliWorkspaceId = previousWorkspaceId;
+    }
+  }
+
+  const accessToken = resolveAccessToken();
+  const clientId = getEnv('EMPIRICAL_CLIENT_ID') || readStoredOAuthClient()?.clientId;
+  if (!accessToken || !clientId) return fn();
+
+  const previousWorkspaceId = globalThis.__empiricalCliWorkspaceId || null;
+  globalThis.__empiricalCliWorkspaceId = null;
+  try {
+    const baseUrl = resolveApiBaseUrl();
+    const currentUrl = new URL(
+      `/oauth/clients/${encodeURIComponent(clientId)}/workspace-selection`,
+      baseUrl
+    ).toString();
+    try {
+      const payload = await httpJson(
+        currentUrl,
+        'GET',
+        null,
+        buildApiAuthHeaders(accessToken),
+        WORKSPACE_CONTEXT_TIMEOUT_MS
+      );
+      globalThis.__empiricalCliWorkspaceId = payload?.current?.workspaceId || null;
+    } catch (_error) {
+      globalThis.__empiricalCliWorkspaceId = null;
+    }
+    return await fn();
+  } finally {
+    globalThis.__empiricalCliWorkspaceId = previousWorkspaceId;
+  }
+}
+
+module.exports = {
+  withSelectedWorkspaceContext,
+  resolveLocalWorkspaceSelection,
+  readSelectedWorkspace,
+  writeSelectedWorkspace,
+  clearSelectedWorkspace,
+  findProjectWorkspaceFile,
+  findGitRoot,
+  projectWorkspacePathFor,
+  writeProjectWorkspace,
+  clearProjectWorkspace,
+  WORKSPACE_ENV_VAR,
+  SELECTED_WORKSPACE_PATH
+};

package/package.json

@@ -1,33 +1,33 @@
-{
-  "name": "@empirical-gauzza/cli",
-  "version": "1.0.37",
-  "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.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"
+  }
+}