@empirical-gauzza/cli 1.0.21 → 1.0.22

package/lib/policyCommands.js

@@ -1,144 +1,144 @@
-'use strict';
-
-const { log, warn } = require('./ui');
-const { httpJson, printApiError } = require('./http');
-const { parseOption } = require('./env');
-const { requireAccessToken, resolveApiBaseUrl, buildApiAuthHeaders } = require('./auth');
-const { readPolicyCache, writePolicyCache } = require('./deviceConfig');
-
-const POLICY_CACHE_TTL_MS = 15 * 60 * 1000;
-
-function policyUrl(baseUrl) {
-  return new URL('/api/v1/users/me/empirical-policy', baseUrl).toString();
-}
-
-function isPolicyCacheFresh(cache, now = Date.now()) {
-  return Boolean(
-    cache &&
-    cache.policy &&
-    cache.updatedAt &&
-    now - new Date(cache.cachedAt || 0).getTime() < POLICY_CACHE_TTL_MS
-  );
-}
-
-async function fetchPolicy({ force = false } = {}) {
-  const cached = readPolicyCache();
-  if (!force && isPolicyCacheFresh(cached)) return { ...cached, source: 'cache' };
-
-  const accessToken = requireAccessToken();
-  const response = await httpJson(
-    policyUrl(resolveApiBaseUrl()),
-    'GET',
-    null,
-    buildApiAuthHeaders(accessToken)
-  );
-  const data = response?.data || response;
-  const next = {
-    policy: data.policy || {},
-    policyVersion: data.policyVersion || 1,
-    updatedAt: data.updatedAt || null,
-    cachedAt: new Date().toISOString()
-  };
-  writePolicyCache(next);
-  return { ...next, source: 'remote' };
-}
-
-function policyFromInstallerOptions(options = {}) {
-  return {
-    memoryFirstWorkflows: options.requireMemoryInWorkflows === false
-      ? []
-      : (options.requiredWorkflows || []),
-    allowDiscretionaryUse: options.allowDiscretionaryMemoryUsage !== false,
-    stopOnMemoryFailure: options.stopOnMemoryToolFailure !== false,
-    rememberCodingStyle: options.rememberCodingStyle !== false,
-    rememberArchitectureDecisions: options.rememberArchitectureDecisions !== false,
-    recordWorkHistory: options.recordWorkHistory !== false,
-    recordScarTissue: options.recordScarTissue !== false,
-    recordTodos: options.recordTodos === true,
-    storeInstructionArtifacts: options.storeInstructionArtifacts === true,
-    checkMemoryBeforeAskingContext: options.checkMemoryBeforeAskingContext !== false,
-    durableWritesOnly: options.durableWritesOnly !== false
-  };
-}
-
-async function savePolicy(policy, accessTokenOverride = null) {
-  const accessToken = accessTokenOverride || requireAccessToken();
-  const response = await httpJson(
-    policyUrl(resolveApiBaseUrl()),
-    'PATCH',
-    { policy },
-    buildApiAuthHeaders(accessToken)
-  );
-  const data = response?.data || response;
-  writePolicyCache({
-    policy: data.policy || {},
-    policyVersion: data.policyVersion || 1,
-    updatedAt: data.updatedAt || null,
-    cachedAt: new Date().toISOString()
-  });
-  return data;
-}
-
-async function runPolicyCommand(args = []) {
-  const subcommand = args[0] || 'show';
-  if (subcommand === 'show') {
-    try {
-      const result = await fetchPolicy({ force: args.includes('--refresh') });
-      log(JSON.stringify(result, null, 2));
-    } catch (error) {
-      printApiError(error);
-      process.exitCode = 1;
-    }
-    return;
-  }
-
-  if (subcommand === 'set') {
-    const raw = parseOption(args, '--json', '');
-    if (!raw) {
-      warn('Usage: empirical policy set --json \'{"allowDiscretionaryUse":false}\'');
-      process.exitCode = 1;
-      return;
-    }
-    let policy;
-    try {
-      policy = JSON.parse(raw);
-    } catch (error) {
-      warn(`Invalid policy JSON: ${error.message}`);
-      process.exitCode = 1;
-      return;
-    }
-    try {
-      const accessToken = requireAccessToken();
-      const response = await httpJson(
-        policyUrl(resolveApiBaseUrl()),
-        'PATCH',
-        { policy },
-        buildApiAuthHeaders(accessToken)
-      );
-      const data = response?.data || response;
-      writePolicyCache({
-        policy: data.policy || {},
-        policyVersion: data.policyVersion || 1,
-        updatedAt: data.updatedAt || null,
-        cachedAt: new Date().toISOString()
-      });
-      log(JSON.stringify(data, null, 2));
-    } catch (error) {
-      printApiError(error);
-      process.exitCode = 1;
-    }
-    return;
-  }
-
-  warn('Usage: empirical policy <show [--refresh]|set --json <policy>>');
-  process.exitCode = 1;
-}
-
-module.exports = {
-  POLICY_CACHE_TTL_MS,
-  isPolicyCacheFresh,
-  policyFromInstallerOptions,
-  fetchPolicy,
-  savePolicy,
-  runPolicyCommand
-};
+'use strict';
+
+const { log, warn } = require('./ui');
+const { httpJson, printApiError } = require('./http');
+const { parseOption } = require('./env');
+const { requireAccessToken, resolveApiBaseUrl, buildApiAuthHeaders } = require('./auth');
+const { readPolicyCache, writePolicyCache } = require('./deviceConfig');
+
+const POLICY_CACHE_TTL_MS = 15 * 60 * 1000;
+
+function policyUrl(baseUrl) {
+  return new URL('/api/v1/users/me/empirical-policy', baseUrl).toString();
+}
+
+function isPolicyCacheFresh(cache, now = Date.now()) {
+  return Boolean(
+    cache &&
+    cache.policy &&
+    cache.updatedAt &&
+    now - new Date(cache.cachedAt || 0).getTime() < POLICY_CACHE_TTL_MS
+  );
+}
+
+async function fetchPolicy({ force = false } = {}) {
+  const cached = readPolicyCache();
+  if (!force && isPolicyCacheFresh(cached)) return { ...cached, source: 'cache' };
+
+  const accessToken = requireAccessToken();
+  const response = await httpJson(
+    policyUrl(resolveApiBaseUrl()),
+    'GET',
+    null,
+    buildApiAuthHeaders(accessToken)
+  );
+  const data = response?.data || response;
+  const next = {
+    policy: data.policy || {},
+    policyVersion: data.policyVersion || 1,
+    updatedAt: data.updatedAt || null,
+    cachedAt: new Date().toISOString()
+  };
+  writePolicyCache(next);
+  return { ...next, source: 'remote' };
+}
+
+function policyFromInstallerOptions(options = {}) {
+  return {
+    memoryFirstWorkflows: options.requireMemoryInWorkflows === false
+      ? []
+      : (options.requiredWorkflows || []),
+    allowDiscretionaryUse: options.allowDiscretionaryMemoryUsage !== false,
+    stopOnMemoryFailure: options.stopOnMemoryToolFailure !== false,
+    rememberCodingStyle: options.rememberCodingStyle !== false,
+    rememberArchitectureDecisions: options.rememberArchitectureDecisions !== false,
+    recordWorkHistory: options.recordWorkHistory !== false,
+    recordScarTissue: options.recordScarTissue !== false,
+    recordTodos: options.recordTodos === true,
+    storeInstructionArtifacts: options.storeInstructionArtifacts === true,
+    checkMemoryBeforeAskingContext: options.checkMemoryBeforeAskingContext !== false,
+    durableWritesOnly: options.durableWritesOnly !== false
+  };
+}
+
+async function savePolicy(policy, accessTokenOverride = null) {
+  const accessToken = accessTokenOverride || requireAccessToken();
+  const response = await httpJson(
+    policyUrl(resolveApiBaseUrl()),
+    'PATCH',
+    { policy },
+    buildApiAuthHeaders(accessToken)
+  );
+  const data = response?.data || response;
+  writePolicyCache({
+    policy: data.policy || {},
+    policyVersion: data.policyVersion || 1,
+    updatedAt: data.updatedAt || null,
+    cachedAt: new Date().toISOString()
+  });
+  return data;
+}
+
+async function runPolicyCommand(args = []) {
+  const subcommand = args[0] || 'show';
+  if (subcommand === 'show') {
+    try {
+      const result = await fetchPolicy({ force: args.includes('--refresh') });
+      log(JSON.stringify(result, null, 2));
+    } catch (error) {
+      printApiError(error);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (subcommand === 'set') {
+    const raw = parseOption(args, '--json', '');
+    if (!raw) {
+      warn('Usage: empirical policy set --json \'{"allowDiscretionaryUse":false}\'');
+      process.exitCode = 1;
+      return;
+    }
+    let policy;
+    try {
+      policy = JSON.parse(raw);
+    } catch (error) {
+      warn(`Invalid policy JSON: ${error.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const accessToken = requireAccessToken();
+      const response = await httpJson(
+        policyUrl(resolveApiBaseUrl()),
+        'PATCH',
+        { policy },
+        buildApiAuthHeaders(accessToken)
+      );
+      const data = response?.data || response;
+      writePolicyCache({
+        policy: data.policy || {},
+        policyVersion: data.policyVersion || 1,
+        updatedAt: data.updatedAt || null,
+        cachedAt: new Date().toISOString()
+      });
+      log(JSON.stringify(data, null, 2));
+    } catch (error) {
+      printApiError(error);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  warn('Usage: empirical policy <show [--refresh]|set --json <policy>>');
+  process.exitCode = 1;
+}
+
+module.exports = {
+  POLICY_CACHE_TTL_MS,
+  isPolicyCacheFresh,
+  policyFromInstallerOptions,
+  fetchPolicy,
+  savePolicy,
+  runPolicyCommand
+};

package/lib/setupCommands.js

@@ -0,0 +1,123 @@
+'use strict';
+
+// Task 9: `empirical setup list/run/answer/finish/resume` — the CLI surface for the guided-
+// interview blueprint flow (Task 5's guidedSetupSession.service, exposed over HTTP by Task 9's
+// packages/server/src/routes/guidedSetups.ts). `run --answers <file.json>` drives the whole
+// interview non-interactively from a {questionKey: value} map with no TTY required, which per
+// spec is the primary end-to-end test harness for the feature; `run` with no `--answers` falls
+// back to the shared interactive prompter (createPrompter from ./ui) for a human at a terminal.
+const fs = require('fs');
+const path = require('path');
+const { httpJson, printApiError } = require('./http');
+const { parseOption } = require('./env');
+const { requireAccessToken, resolveApiBaseUrl, buildApiAuthHeaders } = require('./auth');
+const { warn, log, createPrompter } = require('./ui');
+
+function apiUrl(pathSuffix) {
+  return new URL(`/api/v1/guided-setups${pathSuffix}`, resolveApiBaseUrl()).toString();
+}
+
+async function callApi(method, pathSuffix, body) {
+  const accessToken = requireAccessToken();
+  try {
+    const response = await httpJson(apiUrl(pathSuffix), method, body, buildApiAuthHeaders(accessToken));
+    return response && response.data ? response.data : response;
+  } catch (error) {
+    printApiError(error);
+    process.exit(1);
+  }
+}
+
+async function runList() {
+  const { setups } = await callApi('GET', '', undefined);
+  log(JSON.stringify(setups, null, 2));
+}
+
+async function runNonInteractive(setupId, answersFilePath) {
+  const raw = fs.readFileSync(path.resolve(answersFilePath), 'utf8');
+  const answersByQuestionKey = JSON.parse(raw);
+
+  let current = await callApi('POST', '/start', { setupId });
+
+  while (current.status !== 'completed' && current.status !== 'finished_early') {
+    const questionKey = current.question.questionKey;
+    if (!Object.prototype.hasOwnProperty.call(answersByQuestionKey, questionKey)) {
+      warn(`Answers file is missing an answer for unknown question "${questionKey}"`);
+      process.exit(1);
+    }
+    current = await callApi('POST', `/${current.sessionId}/continue`, { answer: answersByQuestionKey[questionKey] });
+  }
+
+  log(JSON.stringify(current, null, 2));
+}
+
+async function runInteractive(setupId) {
+  const prompter = createPrompter(process.stderr);
+  try {
+    let current = await callApi('POST', '/start', { setupId });
+    while (current.question && current.status !== 'completed' && current.status !== 'finished_early') {
+      const answer = await prompter.askText(current.question.prompt);
+      current = await callApi('POST', `/${current.sessionId}/continue`, { answer });
+    }
+    log(JSON.stringify(current, null, 2));
+  } finally {
+    prompter.close();
+  }
+}
+
+async function runRun(args) {
+  const setupId = args[0] && !args[0].startsWith('--') ? args[0] : '';
+  if (!setupId) {
+    warn('Usage: empirical setup run <setupId> [--answers <file.json>]');
+    process.exit(1);
+  }
+  const answersFile = parseOption(args, '--answers', '');
+  if (answersFile) {
+    await runNonInteractive(setupId, answersFile);
+  } else {
+    await runInteractive(setupId);
+  }
+}
+
+async function runAnswer(args) {
+  const [sessionId, questionKey, ...valueParts] = args;
+  if (!sessionId || !questionKey || valueParts.length === 0) {
+    warn('Usage: empirical setup answer <sessionId> <questionKey> <value>');
+    process.exit(1);
+  }
+  const result = await callApi('POST', `/${sessionId}/continue`, { answer: valueParts.join(' '), questionKey });
+  log(JSON.stringify(result, null, 2));
+}
+
+async function runFinish(args) {
+  const [sessionId] = args;
+  if (!sessionId) {
+    warn('Usage: empirical setup finish <sessionId>');
+    process.exit(1);
+  }
+  const result = await callApi('POST', `/${sessionId}/finish`, {});
+  log(JSON.stringify(result, null, 2));
+}
+
+async function runResume(args) {
+  const [sessionId] = args;
+  if (!sessionId) {
+    warn('Usage: empirical setup resume <sessionId>');
+    process.exit(1);
+  }
+  const result = await callApi('POST', `/${sessionId}/continue`, {});
+  log(JSON.stringify(result, null, 2));
+}
+
+async function runSetupCommand(args) {
+  const [sub, ...rest] = args;
+  if (sub === 'list') return runList();
+  if (sub === 'run') return runRun(rest);
+  if (sub === 'answer') return runAnswer(rest);
+  if (sub === 'finish') return runFinish(rest);
+  if (sub === 'resume') return runResume(rest);
+  warn('Usage: empirical setup <list|run|answer|finish|resume> ...');
+  process.exit(1);
+}
+
+module.exports = { runSetupCommand };

package/lib/ui.js

@@ -174,6 +174,12 @@ function createPrompter(output = process.stdout) {
     return defaultYes;
   }
 
+  async function promptText(question) {
+    output.write(uiQuestion(`${question} `) + '\n');
+    const answer = await readLine();
+    return answer.trim();
+  }
+
   function close() {
     process.stdin.removeListener('data', onData);
     process.stdin.removeListener('end', onEnd);
@@ -184,7 +190,7 @@ function createPrompter(output = process.stdout) {
     process.stdin.pause();
   }
 
-  return { askYesNo: promptYesNo, close };
+  return { askYesNo: promptYesNo, askText: promptText, close };
 }
 
 function parseSelectionList(answer, max) {

package/lib/workspaceContext.js

@@ -1,44 +1,44 @@
-'use strict';
-
-const os = require('os');
-const path = require('path');
-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');
-
-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() {
-  const fs = require('fs');
-  if (fs.existsSync(SELECTED_WORKSPACE_PATH)) fs.unlinkSync(SELECTED_WORKSPACE_PATH);
-}
-
-async function withSelectedWorkspaceContext(fn) {
-  const stored = readSelectedWorkspace();
-  if (stored?.workspaceId) {
-    const previousWorkspaceId = globalThis.__empiricalCliWorkspaceId || null;
-    globalThis.__empiricalCliWorkspaceId = stored.workspaceId;
-    try {
-      return await fn();
-    } finally {
-      globalThis.__empiricalCliWorkspaceId = previousWorkspaceId;
-    }
-  }
-
-  const accessToken = resolveAccessToken();
+'use strict';
+
+const os = require('os');
+const path = require('path');
+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');
+
+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() {
+  const fs = require('fs');
+  if (fs.existsSync(SELECTED_WORKSPACE_PATH)) fs.unlinkSync(SELECTED_WORKSPACE_PATH);
+}
+
+async function withSelectedWorkspaceContext(fn) {
+  const stored = readSelectedWorkspace();
+  if (stored?.workspaceId) {
+    const previousWorkspaceId = globalThis.__empiricalCliWorkspaceId || null;
+    globalThis.__empiricalCliWorkspaceId = stored.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();
 
@@ -68,9 +68,9 @@ async function withSelectedWorkspaceContext(fn) {
   }
 }
 
-module.exports = {
-  withSelectedWorkspaceContext,
-  readSelectedWorkspace,
-  writeSelectedWorkspace,
-  clearSelectedWorkspace
-};
+module.exports = {
+  withSelectedWorkspaceContext,
+  readSelectedWorkspace,
+  writeSelectedWorkspace,
+  clearSelectedWorkspace
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empirical-gauzza/cli",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "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",

package/tests/ui.test.js

@@ -0,0 +1,42 @@
+'use strict';
+
+// Coverage for createPrompter()'s free-text askText method, alongside its existing askYesNo.
+// Follows the same fake-stdin-stream approach as the rest of this prompter's design: feed data
+// through process.stdin directly rather than mocking readline, since createPrompter reads
+// process.stdin itself (see the block comment above createPrompter in ../lib/ui.js).
+
+const { PassThrough } = require('stream');
+const { createPrompter } = require('../lib/ui');
+
+describe('createPrompter().askText', () => {
+  let originalStdin;
+  let fakeStdin;
+
+  beforeEach(() => {
+    originalStdin = Object.getOwnPropertyDescriptor(process, 'stdin');
+    fakeStdin = new PassThrough();
+    fakeStdin.setEncoding = PassThrough.prototype.setEncoding.bind(fakeStdin);
+    Object.defineProperty(process, 'stdin', { value: fakeStdin, configurable: true });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, 'stdin', originalStdin);
+  });
+
+  test('resolves with the trimmed line typed on stdin', async () => {
+    const output = new PassThrough();
+    let written = '';
+    output.on('data', (chunk) => { written += String(chunk); });
+
+    const prompter = createPrompter(output);
+    const answerPromise = prompter.askText('What is your favorite color?');
+
+    fakeStdin.write('  blue  \n');
+
+    const answer = await answerPromise;
+    expect(answer).toBe('blue');
+    expect(written).toMatch(/What is your favorite color\?/);
+
+    prompter.close();
+  });
+});