syndes 0.1.0 → 0.3.0

package/bin/cli.mjs

@@ -10,6 +10,7 @@
 import { readFileSync, writeFileSync, existsSync, unlinkSync, mkdirSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { join } from 'node:path';
+import { homedir } from 'node:os';
 import {
   packageRoot, displayPath, dataDir, installDir, workerScript, pauseFile,
   ensureDataDirs, installedCliScript, isInstalledCopy,
@@ -41,6 +42,11 @@ import { openUrl } from '../src/open.mjs';
 import { pendingCount } from '../runtime/spool.mjs';
 import { detectAll, adapterFor, ADAPTERS } from '../adapters/index.mjs';
 import { pollTails, resetCursors } from '../collect/tail.mjs';
+import { joinPool, leave as leavePool, syncOnce, readPool, isEnabled, teamConfig, loadState, poolRoot, inviteCode, removeDevice, poolName } from '../sync/index.mjs';
+import { decode as decodeInvite, commandFor } from '../sync/invite.mjs';
+import { diagnose as preflight, repair as repairAuth, ghInstallHint } from '../src/preflight.mjs';
+import { identity, setName, initialsOf } from '../runtime/identity.mjs';
+import { team as teamView } from '../analytics/team.mjs';
 
 const VERSION = readVersion();
 
@@ -48,7 +54,7 @@ const COMMANDS = {
   install: cmdInstall, uninstall: cmdUninstall, doctor: cmdDoctor,
   status: cmdStatus, report: cmdReport, dashboard: cmdDashboard, ui: cmdDashboard,
   lock: cmdLock, verify: cmdVerify, sessions: cmdSessions,
-  sources: cmdSources, watch: cmdWatch,
+  sources: cmdSources, watch: cmdWatch, team: cmdTeam, join: cmdJoin,
   projects: cmdProjects, practices: cmdPractices, habits: cmdPractices, coach: cmdCoach,
   ledger: cmdLedger, export: cmdExport, rebuild: cmdRebuild, drain: cmdDrain,
   archive: cmdArchive, prune: cmdPrune, config: cmdConfig,
@@ -119,10 +125,114 @@ async function cmdInstall(args) {
   if (found.length) scan.succeed(found.map((agent) => agent.name).join(', '));
   else scan.skip('none besides Claude Code');
 
+  await setUpSharing(args);
+
   await runBriefing(result);
   clearPending();
 }
 
+/**
+ * The sharing question, asked during install rather than left to be discovered.
+ *
+ * Several people on one Claude account is the case SynDes cannot see without
+ * being told, and somebody who does not know the feature exists will never run
+ * `syndes team join`. So install asks — once, in the one moment the user is
+ * already configuring the tool.
+ *
+ * Three things this must never do:
+ *   • Ask when nobody is there to answer. The npm postinstall runs install()
+ *     with no TTY, and a prompt there would hang `npm install -g` forever.
+ *   • Ask again on a re-install. Repairing an install is not an invitation to
+ *     re-interview somebody about a decision they already made.
+ *   • Fail the install. A pool that cannot be reached is a pool problem; the
+ *     hooks are wired and the ledger is open either way.
+ */
+async function setUpSharing(args = []) {
+  const flag = (name) => args.find((arg) => arg.startsWith(`--${name}=`))?.split('=').slice(1).join('=');
+  const repoFlag = flag('team');
+  const nameFlag = flag('name');
+
+  if (args.includes('--no-team')) return;
+
+  // Already in a pool: report, do not re-ask.
+  if (isEnabled() && !repoFlag) {
+    const step = spinner('Checking the shared pool');
+    await beat();
+    const state = syncOnce();
+    if (state.ok) step.succeed(`${identity().name} · ${readPool().length} machine(s)`);
+    else step.fail(state.error ?? 'could not reach the pool');
+    return;
+  }
+
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !process.env.CI;
+  if (!repoFlag && !interactive) return; // nobody is there to answer
+
+  let repo = repoFlag;
+  let who = nameFlag;
+
+  if (!repo) {
+    write();
+    write(`  ${bold('Is anyone else using this Claude account?')}`);
+    write(grey('  Two people on one account look like one user. SynDes can pool each'));
+    write(grey('  machine\'s numbers through a private repo so you see the real split.'));
+    write(grey('  Counts and tokens are shared. Prompts, paths and commands never are.'));
+    write();
+
+    if (!(await confirm('  Set up sharing now?'))) {
+      write(grey(`  ${DOT} skipped — ${cyan('syndes team join <repo>')} whenever you want it`));
+      write();
+      return;
+    }
+
+    write();
+    write(grey('  A private git repo everyone can push to, or a synced folder.'));
+    write(grey('  e.g. git@github.com:you/usage.git   or   ~/Dropbox/usage'));
+    repo = (await ask('  Repository or folder: ')).trim();
+    if (!repo) {
+      write(grey(`  ${DOT} nothing entered — ${cyan('syndes team join <repo>')} later`));
+      write();
+      return;
+    }
+    who = who || (await ask(`  Your name [${identity().name}]: `)).trim();
+  }
+
+  if (who) {
+    try { setName(who); } catch { /* an unusable name is not worth failing an install over */ }
+  }
+
+  const path = repo.startsWith('~') ? repo.replace('~', homedir()) : repo;
+  const transport = /^(https?:\/\/|git@|ssh:\/\/|git:\/\/)/.test(path) || path.endsWith('.git')
+    ? 'git'
+    : 'folder';
+
+  write();
+  const step = spinner(`Joining the pool over ${transport}`);
+  await beat();
+  try {
+    joinPool({ transport, repo: path });
+  } catch (error) {
+    // Deliberately not fatal. The install succeeded; only the pool did not.
+    step.fail(error.message);
+    write(grey(`  ${DOT} everything else is installed — fix the repo and run ${cyan('syndes team join')}`));
+    write();
+    return;
+  }
+  step.succeed(path);
+
+  const share = spinner('Publishing this machine');
+  await beat();
+  const state = syncOnce();
+  if (state.ok) {
+    share.succeed(`${state.published} day(s) shared as ${identity().name}`);
+    const others = readPool().filter((peer) => !peer.isMe);
+    if (others.length) write(grey(`  ${DOT} already in the pool: ${others.map((peer) => peer.name).join(', ')}`));
+  } else {
+    share.fail(state.error ?? 'could not publish');
+    write(grey(`  ${DOT} joined, but the exchange failed — check git access, then ${cyan('syndes team sync')}`));
+  }
+  write();
+}
+
 async function cmdUninstall(args) {
   const purge = args.includes('--purge');
 
@@ -484,6 +594,305 @@ async function cmdWatch(args) {
   process.on('SIGINT', () => { clearInterval(timer); write(); process.exit(0); });
 }
 
+/**
+ * `syndes join <invite>` — everything a newcomer has to do, in one command.
+ *
+ * The person receiving an invite has not read any of this and should not have
+ * to. So this installs if it is not installed, works out why git cannot reach
+ * the repository, offers to fix that, joins, and publishes — reporting each
+ * step rather than failing with one line about credentials.
+ */
+async function cmdJoin(args) {
+  const raw = args.find((arg) => !arg.startsWith('--'));
+  if (!raw) throw new Error('usage: syndes join <invite-code>   (the line whoever invited you sent)');
+
+  const invite = decodeInvite(raw);
+  if (!invite) {
+    throw new Error('that does not look like an invite — paste the whole line you were sent, or use: syndes team join <repo-url>');
+  }
+
+  banner();
+  write(`  Joining ${bold(invite.pool ?? 'the pool')}${invite.from ? grey(`, invited by ${invite.from}`) : ''}`);
+  write(grey(`  ${invite.repo}`));
+  write();
+
+  if (!isInstalledHere()) {
+    const step = spinner('Setting up SynDes on this machine');
+    await beat();
+    await install({});
+    step.succeed(displayPath(installDir));
+  } else {
+    write(`  ${grey(DOT)} ${grey('already installed')}`);
+  }
+
+  if (!(await ensureReachable(invite.repo, args))) return;
+
+  let who = args.find((arg) => arg.startsWith('--name='))?.split('=').slice(1).join('=');
+  if (!who && process.stdin.isTTY) {
+    write();
+    who = (await ask(`  Your name, as the others will see it [${identity().name}]: `)).trim();
+  }
+  if (who) setName(who);
+
+  write();
+  const step = spinner('Joining the pool');
+  await beat();
+  try {
+    joinPool({ transport: invite.transport, repo: invite.repo });
+  } catch (error) {
+    step.fail(error.message);
+    process.exitCode = 1;
+    return;
+  }
+  step.succeed(poolName());
+
+  const share = spinner('Publishing this machine');
+  await beat();
+  const state = syncOnce();
+  if (state.ok) share.succeed(`${state.published} day(s) shared as ${identity().name}`);
+  else share.fail(state.error ?? 'could not publish');
+
+  const others = readPool().filter((peer) => !peer.isMe);
+  write();
+  write(`  ${OK} you are in${others.length ? grey(` · also here: ${others.map((peer) => peer.name).join(', ')}`) : ''}`);
+  write(grey(`  ${cyan('syndes dashboard')} then open Team`));
+  write();
+}
+
+function isInstalledHere() {
+  try {
+    return (adapterFor('claude-code').status?.().wired ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check git can reach the repository, and fix it if we can.
+ *
+ * The confusing case this exists for: accepting a collaborator invite in a
+ * browser authorises the ACCOUNT, while git on this machine still cannot prove
+ * who it is — and GitHub answers that with "not found" rather than "not you".
+ */
+async function ensureReachable(repo, args = []) {
+  const step = spinner('Checking access to the repository');
+  await beat();
+  let report = preflight(repo);
+
+  if (report.ok) {
+    // Only claim an account when a reach check actually ran and passed with it.
+    // A folder pool, or a local path, never touches GitHub — saying "as <user>"
+    // there would credit an authentication that was not tested.
+    const tested = report.checks.some((check) => check.name === 'repository' && check.ok);
+    step.succeed(tested && report.gh.account ? `as ${report.gh.account}` : tested ? 'reachable' : 'no sign-in needed');
+    return true;
+  }
+  step.fail(report.blocking.detail);
+
+  if (report.gh.installed && process.stdin.isTTY && !args.includes('--no-fix')) {
+    write();
+    write(grey('  This is usually a sign-in, not a missing repository.'));
+    if (await confirm('  Sign in to GitHub now?', true)) {
+      write();
+      const fixed = repairAuth({ interactive: true });
+      write();
+      if (fixed.ran.length) write(grey(`  ran: ${fixed.ran.join(', ')}`));
+      const retry = spinner('Checking access again');
+      await beat();
+      report = preflight(repo);
+      if (report.ok) {
+        retry.succeed(report.gh.account ? `as ${report.gh.account}` : 'reachable');
+        return true;
+      }
+
+      retry.fail(report.blocking.detail);
+    }
+  }
+
+  write();
+  write(`  ${cyan('→')} ${report.blocking.fix}`);
+  if (!report.gh.installed) write(`  ${cyan('→')} the GitHub CLI makes this one command: ${ghInstallHint()}`);
+  write(grey('  then run this again — nothing is lost, recording has already started'));
+  write();
+  process.exitCode = 1;
+  return false;
+}
+
+/**
+ * `syndes team …` — the shared-account pool.
+ *
+ * Sub-verbs rather than top-level commands: everything here is meaningless
+ * unless sharing is on, and hanging six more verbs off the root would bury the
+ * ones that matter to somebody using this alone.
+ */
+async function cmdTeam(args) {
+  const [verb = 'status', ...rest] = args;
+
+  if (verb === 'join') {
+    const repo = rest.find((arg) => !arg.startsWith('--'));
+    if (!repo) throw new Error('usage: syndes team join <repo-url|folder> [--folder] [--detailed]');
+
+    const transport = rest.includes('--folder') || !/^(https?:\/\/|git@|ssh:\/\/|git:\/\/)/.test(repo)
+      ? (repo.endsWith('.git') ? 'git' : 'folder')
+      : 'git';
+
+    const spin = spinner(`Joining the pool over ${transport}`);
+    await beat();
+    let result;
+    try {
+      result = joinPool({ transport, repo, scope: rest.includes('--detailed') ? 'detailed' : undefined });
+    } catch (error) {
+      spin.fail(error.message);
+      throw error;
+    }
+    spin.succeed(result.describe ?? repo);
+
+    const push = spinner('Publishing this machine');
+    await beat();
+    const state = syncOnce();
+    if (state.ok) push.succeed(`${state.published} day(s) shared`);
+    else push.fail(state.error ?? 'could not reach the pool');
+
+    write();
+    write(grey(`  You appear as ${bold(identity().name)}. ${cyan('syndes team name <you>')} to change it.`));
+    write(grey(`  ${cyan('syndes dashboard')} then open Team for the live view.`));
+    write();
+    return;
+  }
+
+  if (verb === 'leave') {
+    leavePool();
+    write(`${OK} left the pool ${grey('· your shelf stays until someone deletes it')}`);
+    return;
+  }
+
+  if (verb === 'name') {
+    if (!rest.length) throw new Error('usage: syndes team name <your name>');
+    const me = setName(rest.join(' '));
+    if (isEnabled()) syncOnce();
+    write(`${OK} this machine is ${bold(me.name)}`);
+    return;
+  }
+
+  if (verb === 'scope') {
+    const scope = rest[0];
+    if (!['summary', 'detailed'].includes(scope)) throw new Error('usage: syndes team scope <summary|detailed>');
+    const next = rawConfig();
+    setPath(next, 'team.scope', scope);
+    saveConfig(next);
+    if (isEnabled()) syncOnce();
+    write(`${OK} sharing ${bold(scope)} ${grey('· prompt text is never shared, at any scope')}`);
+    return;
+  }
+
+  if (verb === 'invite') {
+    if (!isEnabled()) throw new Error('sharing is off — syndes team join <repo> first');
+    const code = inviteCode();
+    write();
+    write(`  ${bold('Send this line')} ${grey('· they paste it into a terminal, and that is all')}`);
+    write();
+    write(`  ${cyan(commandFor(code))}`);
+    write();
+    write(grey('  It installs SynDes, checks their GitHub access, offers to fix it,'));
+    write(grey('  and joins them to this pool.'));
+    write();
+    write(grey(`  ${WARN} first add them as a collaborator on ${teamConfig().repo}`));
+    write(grey('  The invite is not a key — access is the repository\'s collaborator list.'));
+    write(grey('  Everyone in the pool can see everyone else in it.'));
+    write();
+    return;
+  }
+
+  if (verb === 'remove') {
+    const target = rest.filter((arg) => !arg.startsWith('--')).join(' ');
+    if (!target) throw new Error('usage: syndes team remove <name>');
+    if (!isEnabled()) throw new Error('sharing is off');
+
+    const peers = readPool();
+    const match = peers.find((p) => p.deviceId === target || p.name?.toLowerCase() === target.toLowerCase());
+    if (!match) throw new Error(`no machine called "${target}" — ${peers.map((p) => p.name).join(', ')}`);
+
+    write();
+    write(`  ${WARN} removing ${bold(match.name)} takes their ${match.rollups.size} published day(s) out of the pool`);
+    write(grey('  Their own ledger is untouched. Past totals will change for everyone.'));
+    write(grey('  Git keeps the old commits, so this removes them from view, not from history.'));
+    write(grey(`  To stop them adding more, remove their GitHub access as well.`));
+    write();
+    if (process.stdin.isTTY && !rest.includes('--yes') && !(await confirm(`  Remove ${match.name}?`))) return write('cancelled');
+
+    const step = spinner(`Removing ${match.name}`);
+    await beat();
+    const result = removeDevice(match.deviceId);
+    if (!result.removed) { step.fail(result.error); process.exitCode = 1; return; }
+    if (result.pushed) step.succeed('removed and pushed');
+    else step.fail(`removed locally, but the push failed: ${result.error ?? 'unknown'}`);
+    return;
+  }
+
+  if (verb === 'doctor') {
+    const report = preflight(teamConfig().repo ?? null);
+    write();
+    for (const check of report.checks) {
+      const mark = check.ok === true ? OK : check.ok === false ? FAIL : grey(DOT);
+      write(`  ${mark} ${check.name.padEnd(12)} ${check.ok === false ? check.detail : grey(check.detail)}`);
+      if (check.fix) write(`     ${cyan('→')} ${check.fix}`);
+    }
+    write();
+    if (!report.ok) process.exitCode = 1;
+    return;
+  }
+
+  if (verb === 'sync') {
+    if (!isEnabled()) return write(grey('sharing is off — syndes team join <repo>'));
+    const spin = spinner('Exchanging with the pool');
+    await beat();
+    const state = syncOnce();
+    if (state.ok) spin.succeed(`${state.published} day(s) published${state.pushed ? ', pushed' : ', nothing new to push'}`);
+    else spin.fail(state.error ?? 'sync failed');
+    if (!state.ok) process.exitCode = 1;
+    return;
+  }
+
+  // status
+  if (!isEnabled()) {
+    write();
+    write(`  ${grey('sharing is')} ${bold('off')}`);
+    write();
+    write(grey('  One Claude account used by several people shows up as one user.'));
+    write(grey('  A pool gives each machine its own shelf, so the split is visible.'));
+    write();
+    write(`  ${cyan('syndes team join git@github.com:you/usage.git')}`);
+    write(`  ${cyan('syndes team join ~/Dropbox/usage --folder')}`);
+    write();
+    return;
+  }
+
+  const data = await teamView(rest[0] ?? '7d');
+  const state = loadState();
+
+  write();
+  write(`  ${bold('Pool')} ${grey(poolRoot())}`);
+  write(`  ${grey('transport')} ${teamConfig().transport}  ${grey('scope')} ${teamConfig().scope}  ${grey('last sync')} ${state.at ? new Date(state.at).toLocaleTimeString() : '—'}${state.error ? red(' · ' + String(state.error).slice(0, 60)) : ''}`);
+  write();
+  write(table([
+    [grey(''), grey('person'), grey('share'), grey('tokens'), grey('sessions'), grey('active'), grey('last seen')],
+    ...data.peers.map((peer) => [
+      peer.isMe ? green('›') : ' ',
+      `${peer.name}${peer.stale ? yellow(' (stale)') : ''}`,
+      percent(peer.share),
+      compact(peer.totals.tokens),
+      String(peer.totals.sessions),
+      duration(peer.totals.activeMs),
+      peer.lastSeen ? new Date(peer.lastSeen).toLocaleString(undefined, { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' }) : '—',
+    ]),
+  ], { align: ['left', 'left', 'right', 'right', 'right', 'right', 'left'] }).map((line) => `  ${line}`).join('\n'));
+  write();
+  write(`  ${grey('overlap')} ${percent(data.grid.overlapRate)} ${grey(`of working hours had more than one of you in them`)}`);
+  write();
+  write(grey(`  ${cyan('syndes team invite')} to add someone  ${DOT}  ${cyan('syndes team remove <name>')}  ${DOT}  ${cyan('syndes team doctor')}`));
+  write();
+}
+
 /** `syndes lock [open|system|pin]` */
 async function cmdLock(args) {
   const requested = args[0];
@@ -577,6 +986,9 @@ function usage_() {
     [cyan('export --format=csv'), 'all of it, back out'],
     [cyan('sources'), 'which coding agents SynDes can see'],
     [cyan('watch [--once]'), 'follow agents that have no hook API'],
+    [cyan('join <invite>'), 'accept an invite — installs and sets everything up'],
+    [cyan('team invite'), 'a line to send someone so they can join'],
+    [cyan('team [status|remove]'), 'share one account and see the split'],
     [cyan('lock [mode]'), 'how the dashboard unlocks: open, system or pin'],
     [cyan('doctor [--full]'), 'what is wired and what actually works'],
     [cyan('off [30m] / on'), 'pause and resume tracking'],

package/collect/projects.mjs

@@ -11,22 +11,38 @@
  */
 
 import { execFileSync } from 'node:child_process';
-import { basename, resolve } from 'node:path';
+import { basename, resolve, sep } from 'node:path';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { projectsFile } from '../runtime/paths.mjs';
+import { projectsFile, dataDir } from '../runtime/paths.mjs';
 import { which } from '../runtime/platform.mjs';
 
 const cache = new Map();
 
+/**
+ * Our own data directory is not a project.
+ *
+ * The shared pool is a git working copy living under dataDir, so the git-root
+ * rule below would classify it as somewhere the user works — and it would then
+ * appear in their per-project breakdown and get told off for having no
+ * CLAUDE.md. It is a mirror of a remote that this tool maintains, and counting
+ * it would be the tool measuring itself.
+ */
+function isOurs(path) {
+  const root = resolve(dataDir);
+  return path === root || path.startsWith(root + sep);
+}
+
 /** @returns {{id: string, name: string, root: string}|null} */
 export function projectFor(cwd) {
   if (!cwd) return null;
   const key = resolve(cwd);
   if (cache.has(key)) return cache.get(key);
+  if (isOurs(key)) { cache.set(key, null); return null; }
 
   const root = gitRoot(key) ?? key;
+  if (isOurs(resolve(root))) { cache.set(key, null); return null; }
   const project = {
     id: createHash('sha256').update(root).digest('hex').slice(0, 12),
     name: basename(root) || root,