kushi-agents 5.2.0 → 5.4.0

package/src/promote.test.mjs

@@ -0,0 +1,161 @@
+// kushi v5.3.0 — promote operation tests.
+// MUST use $env:KUSHI_GLOBAL_ROOT under .testtmp/ — never the real ~/.kushi-global/.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { detectIdentifiers, promote, globalInit } from './global-wiki.mjs';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const TESTTMP = path.join(repoRoot, '.testtmp');
+
+function makeFixtureProject(label, body) {
+  const root = path.join(TESTTMP, `promote-${label}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  const evidence = path.join(root, 'projectroot', 'Evidence', 'acme', 'State', 'answers');
+  fs.mkdirSync(evidence, { recursive: true });
+  const page = path.join(evidence, '2026-05-27_confidence-ladder.md');
+  fs.writeFileSync(page, body);
+  return {
+    tmpRoot: root,
+    projectRoot: path.join(root, 'projectroot'),
+    globalRoot: path.join(root, 'global'),
+    sourcePath: page,
+    relSource: path.relative(path.join(root, 'projectroot'), page),
+  };
+}
+
+function rmrf(p) {
+  if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true });
+}
+
+test('promote: detectIdentifiers flags project name, alias, and external email', () => {
+  const body = [
+    '# notes',
+    'Acme is shipping in Q3 with help from lead@acme.com.',
+    'acme stakeholder pinged us; also internal kushikd@microsoft.com (ok).',
+    'Re-pinged Acme on Friday.',
+  ].join('\n');
+
+  const hits = detectIdentifiers(body, { project: 'acme', alias: 'acme' });
+  const literal = hits.find((h) => h.kind === 'project-or-alias');
+  assert.ok(literal, 'must flag project literal');
+  assert.ok(literal.count >= 3, `expected ≥3 acme hits, got ${literal.count}`);
+
+  const emails = hits.filter((h) => h.kind === 'external-email');
+  assert.equal(emails.length, 1, 'must flag exactly the external email');
+  assert.equal(emails[0].pattern, 'lead@acme.com');
+
+  const internalLeak = hits.find((h) => h.pattern && h.pattern.endsWith('@microsoft.com'));
+  assert.equal(internalLeak, undefined, '@microsoft.com must NOT be flagged');
+});
+
+test('promote: refuses without --force when identifiers are detected', () => {
+  const fx = makeFixtureProject(
+    'refuse',
+    '---\nkushi_state_page: true\n---\n\n# Acme confidence ladder\n\nAcme uses strong/weak/hypothesis tiers. Contact lead@acme.com.\n',
+  );
+  try {
+    globalInit({ root: fx.globalRoot });
+    const r = promote({
+      project: 'acme',
+      sourcePath: fx.sourcePath,
+      projectRoot: fx.projectRoot,
+      globalRoot: fx.globalRoot,
+    });
+    assert.equal(r.ok, false, 'must refuse');
+    assert.equal(r.refused, true);
+    assert.ok(r.detections.length >= 1, 'must surface detections');
+    // No target file written under answers/.
+    const answers = path.join(fx.globalRoot, 'State', 'answers');
+    const files = fs.existsSync(answers) ? fs.readdirSync(answers) : [];
+    assert.equal(files.length, 0, 'refusal must leave global answers/ empty');
+  } finally {
+    rmrf(fx.tmpRoot);
+  }
+});
+
+test('promote: --force writes redacted target, privacy callout, back-link, and dual log', () => {
+  const fx = makeFixtureProject(
+    'force',
+    '---\nkushi_state_page: true\n---\n\n# Acme confidence ladder\n\nAcme uses strong/weak/hypothesis tiers. Contact lead@acme.com.\n',
+  );
+  try {
+    globalInit({ root: fx.globalRoot });
+    const r = promote({
+      project: 'acme',
+      sourcePath: fx.sourcePath,
+      projectRoot: fx.projectRoot,
+      globalRoot: fx.globalRoot,
+      force: true,
+      now: new Date('2026-05-27T12:00:00Z'),
+    });
+
+    assert.equal(r.ok, true, 'forced promote must succeed');
+    assert.ok(r.target && fs.existsSync(r.target), 'target file must exist');
+    assert.ok(r.redactions.length >= 2, `expected ≥2 redactions, got ${r.redactions.length}`);
+
+    const targetBody = fs.readFileSync(r.target, 'utf8');
+    assert.match(targetBody, /^---\n/, 'target must start with frontmatter');
+    assert.match(targetBody, /scope: global/, 'target frontmatter must mark scope: global');
+    assert.match(targetBody, /promoted_from: "acme\//, 'target must record promoted_from');
+    assert.match(targetBody, /promoted_at:/, 'target must record promoted_at');
+    assert.match(targetBody, /\[REDACTED\]/, 'target body must contain [REDACTED]');
+    // Strip frontmatter AND the privacy callout block (which legitimately echoes the redacted labels) before scanning prose.
+    const prose = targetBody
+      .replace(/^---\n[\s\S]*?\n---\n/, '')
+      .replace(/> \[!warning\] potential-customer-leak[\s\S]*$/m, '');
+    assert.doesNotMatch(prose, /lead@acme\.com/, 'external email must be redacted in prose');
+    assert.doesNotMatch(prose, /\bAcme\b/i, 'project literal must be redacted in prose');
+    assert.match(targetBody, /> \[!warning\] potential-customer-leak/, 'target must carry privacy callout');
+
+    // Source must gain back-link callout.
+    const sourceBody = fs.readFileSync(fx.sourcePath, 'utf8');
+    assert.match(sourceBody, /> \[!info\] Promoted to global wiki/, 'source must carry back-link callout');
+    assert.match(sourceBody, /answers\/[a-z0-9-]+\.md/, 'back-link must reference the global slug');
+
+    // Dual log: both project State/log.md and global State/log.md updated.
+    // Project log lives at <projectRoot>/Evidence/acme/State/log.md
+    const projLog = path.join(fx.projectRoot, 'Evidence', 'acme', 'State', 'log.md');
+    assert.ok(fs.existsSync(projLog), 'project log must exist after promote');
+    assert.match(fs.readFileSync(projLog, 'utf8'), /promote\b/, 'project log must record promote op');
+
+    const globalLog = path.join(fx.globalRoot, 'State', 'log.md');
+    assert.match(fs.readFileSync(globalLog, 'utf8'), /promote-in/, 'global log must record promote-in op');
+  } finally {
+    rmrf(fx.tmpRoot);
+  }
+});
+
+test('promote: clean page (no identifiers) promotes without --force and emits no privacy callout', () => {
+  const fx = makeFixtureProject(
+    'clean',
+    '---\nkushi_state_page: true\n---\n\n# Confidence ladder pattern\n\nUse strong / weak / hypothesis tiers when reporting findings. Contact teammate@microsoft.com.\n',
+  );
+  try {
+    globalInit({ root: fx.globalRoot });
+    const r = promote({
+      project: 'acme',
+      sourcePath: fx.sourcePath,
+      projectRoot: fx.projectRoot,
+      globalRoot: fx.globalRoot,
+      // NOTE: source path lives under Evidence/acme/, so alias guess = 'acme'.
+      // Body never mentions 'acme' or 'Acme' literally, and @microsoft.com is allowed.
+    });
+    assert.equal(r.ok, true, 'clean page must promote without --force');
+    assert.equal(r.refused, false);
+    assert.equal(r.redactions.length, 0, 'clean page must produce zero redactions');
+
+    const targetBody = fs.readFileSync(r.target, 'utf8');
+    assert.doesNotMatch(
+      targetBody,
+      /> \[!warning\] potential-customer-leak/,
+      'clean promote must NOT emit a privacy callout',
+    );
+    assert.match(targetBody, /redactions: \[\]/, 'frontmatter must record empty redactions array');
+  } finally {
+    rmrf(fx.tmpRoot);
+  }
+});

package/src/setup-wizard.mjs

@@ -0,0 +1,133 @@
+// kushi v5.4.0 — interactive setup wizard.
+// Non-interactive overrides (used by tests + CI):
+//   KUSHI_WIZARD_ROOT     — engagement root path
+//   KUSHI_WIZARD_HOSTS    — comma list: clawpilot,vscode  (or "both")
+//   KUSHI_WIZARD_GLOBAL   — "y" or "n"
+//   KUSHI_INSTALL_ROOT    — override ~/.copilot/ for install target (test isolation)
+//   KUSHI_SKIP_INSTALL    — "1" to skip the actual install step (tests)
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import readline from 'node:readline';
+
+function detectEngagementRoot() {
+  const home = process.env.USERPROFILE || process.env.HOME || os.homedir();
+  // Look for the canonical "ISE\Engagement Assets" path under any OneDrive*.
+  try {
+    const entries = fs.readdirSync(home, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (!/^OneDrive/i.test(e.name)) continue;
+      const candidate = path.join(home, e.name, 'ISE', 'Engagement Assets');
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  } catch {}
+  return path.join(home, 'Engagement Assets');
+}
+
+function detectHosts() {
+  const home = process.env.USERPROFILE || process.env.HOME || os.homedir();
+  const installRoot = process.env.KUSHI_INSTALL_ROOT || home;
+  const claw = fs.existsSync(path.join(installRoot, '.copilot'));
+  const vsc  = fs.existsSync(path.join(installRoot, '.vscode'));
+  if (claw && vsc) return 'both';
+  if (vsc) return 'vscode';
+  return 'clawpilot';
+}
+
+function makePrompter() {
+  const fromEnv = (key) => {
+    const v = process.env[key];
+    return (typeof v === 'string' && v.length > 0) ? v : null;
+  };
+  if (fromEnv('KUSHI_WIZARD_ROOT') || fromEnv('KUSHI_WIZARD_HOSTS') || fromEnv('KUSHI_WIZARD_GLOBAL')) {
+    return { interactive: false, ask: async (_q, _def, envKey) => fromEnv(envKey) };
+  }
+  if (!process.stdin.isTTY) {
+    return { interactive: false, ask: async (_q, def) => def };
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    interactive: true,
+    ask: (q, def) => new Promise((res) => {
+      rl.question(`${q} [${def}]: `, (a) => res(a.trim() || def));
+    }),
+    close: () => rl.close(),
+  };
+}
+
+export async function runSetupWizard({ args = [] } = {}) {
+  const detectedRoot  = detectEngagementRoot();
+  const detectedHosts = detectHosts();
+  const p = makePrompter();
+
+  console.log('');
+  console.log('  kushi setup wizard — 3 questions, then I install.');
+  console.log('');
+
+  const root  = (await p.ask('  Where is your engagement root?', detectedRoot, 'KUSHI_WIZARD_ROOT')) || detectedRoot;
+  const hosts = (await p.ask('  Install for clawpilot / vscode / both?', detectedHosts, 'KUSHI_WIZARD_HOSTS')) || detectedHosts;
+  const wantGlobal = (await p.ask('  Enable global wiki at ~/.kushi-global/?', 'y', 'KUSHI_WIZARD_GLOBAL')) || 'y';
+
+  if (p.close) p.close();
+
+  const answers = {
+    engagementRoot: root,
+    hosts: hosts.toLowerCase(),
+    globalWiki: /^y/i.test(wantGlobal),
+  };
+
+  console.log('');
+  console.log('  Answers:');
+  console.log(`    engagement root: ${answers.engagementRoot}`);
+  console.log(`    hosts:           ${answers.hosts}`);
+  console.log(`    global wiki:     ${answers.globalWiki ? 'yes' : 'no'}`);
+  console.log('');
+
+  if (process.env.KUSHI_SKIP_INSTALL === '1') {
+    console.log('  (KUSHI_SKIP_INSTALL=1 — skipping actual install; wizard complete.)');
+    console.log('');
+    console.log('  Next steps:');
+    console.log('    kushi doctor');
+    console.log('    kushi bootstrap <project>');
+    console.log('');
+    return answers;
+  }
+
+  // Dispatch to multi-host install.
+  const { runMultiHost } = await import('./multi-host.mjs');
+  const hostList = [];
+  if (answers.hosts === 'both' || answers.hosts === 'all') {
+    hostList.push('clawpilot', 'vscode');
+  } else if (answers.hosts === 'clawpilot' || answers.hosts === 'vscode') {
+    hostList.push(answers.hosts);
+  } else {
+    hostList.push('clawpilot');
+  }
+
+  try {
+    await runMultiHost({ hosts: hostList, all: false, uninstall: false, profile: undefined });
+  } catch (err) {
+    console.error(`  install failed: ${err.message}`);
+    throw err;
+  }
+
+  if (answers.globalWiki) {
+    try {
+      const { runGlobalInit } = await import('./global-wiki-cli.mjs');
+      await runGlobalInit();
+    } catch (err) {
+      console.error(`  global init skipped: ${err.message}`);
+    }
+  }
+
+  console.log('');
+  console.log('  ✅ wizard complete — next steps:');
+  console.log('    kushi doctor');
+  console.log('    kushi bootstrap <project>');
+  console.log('    kushi ask <project> "..."');
+  console.log('');
+
+  return answers;
+}

package/src/setup-wizard.test.mjs

@@ -0,0 +1,74 @@
+// kushi v5.4.0 — setup-wizard tests.
+// All cases run sequentially inside a single test() to avoid process.env races
+// between async tests (which would otherwise risk hitting the real installer).
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { runSetupWizard } from './setup-wizard.mjs';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const TESTTMP = path.join(repoRoot, '.testtmp');
+if (!fs.existsSync(TESTTMP)) fs.mkdirSync(TESTTMP, { recursive: true });
+
+async function withEnv(envOverrides, fn) {
+  const saved = {};
+  for (const k of Object.keys(envOverrides)) {
+    saved[k] = process.env[k];
+    if (envOverrides[k] === null) delete process.env[k];
+    else process.env[k] = envOverrides[k];
+  }
+  try { return await fn(); }
+  finally {
+    for (const k of Object.keys(saved)) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+  }
+}
+
+test('setup-wizard: env-driven cases (sequential to avoid env race)', async (t) => {
+  await t.test('case 1: env overrides resolve all three prompts', async () => {
+    const root = path.join(TESTTMP, `wizard-root-${Date.now()}-1`);
+    fs.mkdirSync(root, { recursive: true });
+    const result = await withEnv({
+      KUSHI_WIZARD_ROOT: root,
+      KUSHI_WIZARD_HOSTS: 'clawpilot',
+      KUSHI_WIZARD_GLOBAL: 'n',
+      KUSHI_SKIP_INSTALL: '1',
+    }, () => runSetupWizard());
+    assert.equal(result.engagementRoot, root, 'root from env');
+    assert.equal(result.hosts, 'clawpilot', 'host from env');
+    assert.equal(result.globalWiki, false, 'global wiki off');
+  });
+
+  await t.test('case 2: "both" hosts retained in answers', async () => {
+    const root = path.join(TESTTMP, `wizard-root-${Date.now()}-2`);
+    fs.mkdirSync(root, { recursive: true });
+    const result = await withEnv({
+      KUSHI_WIZARD_ROOT: root,
+      KUSHI_WIZARD_HOSTS: 'both',
+      KUSHI_WIZARD_GLOBAL: 'n',
+      KUSHI_SKIP_INSTALL: '1',
+    }, () => runSetupWizard());
+    assert.equal(result.hosts, 'both');
+  });
+
+  await t.test('case 3: isolated install root + global wiki yes', async () => {
+    const installRoot = path.join(TESTTMP, `wizard-install-root-${Date.now()}-3`);
+    fs.mkdirSync(path.join(installRoot, '.copilot'), { recursive: true });
+    const result = await withEnv({
+      KUSHI_WIZARD_ROOT: installRoot,
+      KUSHI_WIZARD_HOSTS: 'clawpilot',
+      KUSHI_WIZARD_GLOBAL: 'y',
+      KUSHI_SKIP_INSTALL: '1',
+      KUSHI_INSTALL_ROOT: installRoot,
+    }, () => runSetupWizard());
+    assert.equal(result.hosts, 'clawpilot');
+    assert.equal(result.globalWiki, true);
+    assert.equal(result.engagementRoot, installRoot);
+  });
+});