atris 3.14.0 → 3.15.11

package/commands/now.js

@@ -0,0 +1,263 @@
+const fs = require('fs');
+const path = require('path');
+
+const NOW_PATH = path.join('atris', 'now.md');
+
+function todayIso() {
+  return new Date().toISOString().split('T')[0];
+}
+
+function ensureAtrisDir(root = process.cwd()) {
+  const atrisDir = path.join(root, 'atris');
+  if (!fs.existsSync(atrisDir)) {
+    throw new Error('atris/ folder not found. Run "atris init" first.');
+  }
+  return atrisDir;
+}
+
+function hasWorkspaceMarkers(atrisDir) {
+  return fs.existsSync(path.join(atrisDir, 'MAP.md')) || fs.existsSync(path.join(atrisDir, 'TODO.md'));
+}
+
+function findChildWorkspaces(root = process.cwd()) {
+  if (!fs.existsSync(root)) return [];
+
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+    .map((entry) => {
+      const workspaceRoot = path.join(root, entry.name);
+      const atrisDir = path.join(workspaceRoot, 'atris');
+      if (!fs.existsSync(atrisDir) || !hasWorkspaceMarkers(atrisDir)) return null;
+      const mapPath = path.join(atrisDir, 'MAP.md');
+      const todoPath = path.join(atrisDir, 'TODO.md');
+      return {
+        slug: entry.name,
+        root: workspaceRoot,
+        atrisDir,
+        mapPath,
+        todoPath,
+        nowPath: path.join(atrisDir, 'now.md'),
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => a.slug.localeCompare(b.slug));
+}
+
+function readFirstHeading(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, 'utf8');
+  const line = content.split(/\r?\n/).find((l) => l.trim().startsWith('#'));
+  return line ? line.replace(/^#+\s*/, '').trim() : null;
+}
+
+function countMatches(filePath, pattern) {
+  if (!fs.existsSync(filePath)) return 0;
+  const content = fs.readFileSync(filePath, 'utf8');
+  return (content.match(pattern) || []).length;
+}
+
+function currentJournalPath(root = process.cwd()) {
+  const now = new Date();
+  const year = String(now.getFullYear());
+  const date = todayIso();
+  return path.join(root, 'atris', 'logs', year, `${date}.md`);
+}
+
+function renderDefaultNow(root = process.cwd()) {
+  const atrisDir = ensureAtrisDir(root);
+  const mapHeading = readFirstHeading(path.join(atrisDir, 'MAP.md')) || 'MAP not filled yet';
+  const todoPath = path.join(atrisDir, 'TODO.md');
+  const journalPath = currentJournalPath(root);
+  const backlogCount = countMatches(todoPath, /^-\s+\*\*.+?\*\*/gm);
+  const inboxCount = countMatches(journalPath, /^-\s+\*\*I\d+:/gm);
+  const completedCount = countMatches(journalPath, /^-\s+\*\*C\d+:/gm);
+  const generated = todayIso();
+
+  return `# now
+
+> Current operating truth for this workspace.
+> Read this first. Follow links only when needed.
+
+Last updated: ${generated}
+
+## What Matters Now
+
+- Decide the next useful move before opening more context.
+
+## Current Priority
+
+- Keep the workspace coherent and useful for the next human or agent.
+
+## Signals
+
+- Map: ${mapHeading}
+- TODO items visible: ${backlogCount}
+- Inbox items today: ${inboxCount}
+- Completed receipts today: ${completedCount}
+
+## Watchouts
+
+- Do not treat old logs as current truth unless this file links to them.
+- Do not create motion for its own sake.
+- If facts conflict, surface the conflict and cite the receipts.
+
+## Next Move
+
+- Read \`atris/MAP.md\`, \`atris/TODO.md\`, and today's journal only as needed for the task in front of you.
+
+## Receipts
+
+- \`atris/MAP.md\`
+- \`atris/TODO.md\`
+- \`${path.relative(root, journalPath)}\`
+`;
+}
+
+function renderPortfolioNow(root = process.cwd()) {
+  const workspaces = findChildWorkspaces(root);
+  if (workspaces.length === 0) {
+    throw new Error('atris/ folder not found. Run "atris init" first.');
+  }
+
+  const generated = todayIso();
+  const lines = workspaces.map((workspace) => {
+    const heading = readFirstHeading(workspace.mapPath) || workspace.slug;
+    const todoCount = countMatches(workspace.todoPath, /^-\s+\*\*.+?\*\*/gm);
+    const nowState = fs.existsSync(workspace.nowPath) ? 'has now.md' : 'needs now.md';
+    return `- ${workspace.slug}: ${heading}; ${todoCount} visible TODO item${todoCount === 1 ? '' : 's'}; ${nowState}.`;
+  });
+
+  return `# now
+
+> Current operating truth for this portfolio of Atris workspaces.
+> Read this first. Then enter the specific workspace that matters.
+
+Last updated: ${generated}
+
+## What Matters Now
+
+- Keep the active business workspaces easy to scan, update, and hand off.
+
+## Current Priority
+
+- Use the child workspace with the right slug; avoid creating duplicate business brains.
+
+## Workspace Signals
+
+${lines.join('\n')}
+
+## Watchouts
+
+- Parent status is a map, not the source of truth for each business.
+- Each active workspace should own its own \`atris/now.md\`.
+- If slugs conflict, resolve the workspace identity before pushing or pulling.
+
+## Next Move
+
+- Run \`atris now\` inside the workspace you are about to operate.
+
+## Receipts
+
+${workspaces.map((workspace) => `- \`${workspace.slug}/atris/MAP.md\``).join('\n')}
+`;
+}
+
+function ensureNowFile(root = process.cwd()) {
+  let atrisDir = path.join(root, 'atris');
+  const isWorkspace = fs.existsSync(atrisDir) && hasWorkspaceMarkers(atrisDir);
+  const childWorkspaces = isWorkspace ? [] : findChildWorkspaces(root);
+  if (!isWorkspace && childWorkspaces.length === 0) {
+    ensureAtrisDir(root);
+  }
+  if (!isWorkspace && childWorkspaces.length > 0) {
+    fs.mkdirSync(atrisDir, { recursive: true });
+  }
+  const nowPath = path.join(atrisDir, 'now.md');
+  if (!fs.existsSync(nowPath)) {
+    const content = isWorkspace ? renderDefaultNow(root) : renderPortfolioNow(root);
+    fs.writeFileSync(nowPath, content, 'utf8');
+    return { created: true, path: nowPath };
+  }
+  return { created: false, path: nowPath };
+}
+
+function refreshNowFile(root = process.cwd()) {
+  const atrisDir = path.join(root, 'atris');
+  const isWorkspace = fs.existsSync(atrisDir) && hasWorkspaceMarkers(atrisDir);
+  const childWorkspaces = isWorkspace ? [] : findChildWorkspaces(root);
+  if (!isWorkspace && childWorkspaces.length === 0) {
+    ensureAtrisDir(root);
+  }
+  if (!isWorkspace && childWorkspaces.length > 0) {
+    fs.mkdirSync(atrisDir, { recursive: true });
+  }
+  const nowPath = path.join(atrisDir, 'now.md');
+  const content = isWorkspace ? renderDefaultNow(root) : renderPortfolioNow(root);
+  fs.writeFileSync(nowPath, content, 'utf8');
+  return { path: nowPath };
+}
+
+function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
+  const help = args.includes('--help') || args.includes('-h');
+  if (help) {
+    console.log('Usage: atris now [--init|--refresh|--all|--path]');
+    console.log('');
+    console.log('Show the current operating truth for this workspace.');
+    console.log('');
+    console.log('  atris now           Show atris/now.md');
+    console.log('  atris now --init    Create atris/now.md if missing');
+    console.log('  atris now --refresh Regenerate a small local now.md');
+    console.log('  atris now --all     Refresh this parent and every child Atris workspace');
+    console.log('  atris now --path    Print the file path only');
+    return;
+  }
+
+  const init = args.includes('--init');
+  const refresh = args.includes('--refresh');
+  const all = args.includes('--all');
+  const pathOnly = args.includes('--path');
+
+  let result;
+  if (all) {
+    const workspaces = findChildWorkspaces(root);
+    for (const workspace of workspaces) {
+      refreshNowFile(workspace.root);
+    }
+    result = refreshNowFile(root);
+    if (!pathOnly) {
+      console.log(`Refreshed ${workspaces.length} child workspace${workspaces.length === 1 ? '' : 's'}.`);
+      console.log('');
+    }
+  } else if (refresh) {
+    result = refreshNowFile(root);
+  } else if (init) {
+    result = ensureNowFile(root);
+  } else {
+    result = ensureNowFile(root);
+  }
+
+  const rel = path.relative(root, result.path);
+  if (pathOnly) {
+    console.log(rel);
+    return;
+  }
+
+  if (result.created) {
+    console.log(`Created ${rel}`);
+    console.log('');
+  }
+
+  const content = fs.readFileSync(result.path, 'utf8').trimEnd();
+  console.log(content);
+}
+
+module.exports = {
+  NOW_PATH,
+  ensureNowFile,
+  findChildWorkspaces,
+  nowAtris,
+  refreshNowFile,
+  renderDefaultNow,
+  renderPortfolioNow,
+};

package/commands/pull.js

@@ -11,6 +11,13 @@ const { loadManifest, saveManifest, computeFileHash, buildManifest, computeLocal
 const { normalizeWikiOnlyPrefix } = require('../lib/wiki');
 const { emitSyncEvent, startTimer } = require('../lib/sync-telemetry');
 const { resolveSafeOutputDir } = require('../lib/workspace-safety');
+const {
+  buildConflictReviewPacket,
+  readBaseContent,
+  removeBaseContents,
+  writeBaseContents,
+  writeConflictReviewPacket,
+} = require('../lib/company-brain-sync');
 
 function pruneEmptyParentDirs(filePath, stopDir) {
   let current = path.dirname(filePath);
@@ -26,11 +33,50 @@ function pruneEmptyParentDirs(filePath, stopDir) {
   }
 }
 
+function isBusinessWorkspaceRoot(dir) {
+  return fs.existsSync(path.join(dir, '.atris', 'business.json')) && fs.existsSync(path.join(dir, 'atris'));
+}
+
+function syncTimestamp() {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+function buildPullConflictReviewPacket(outputDir, conflictChanges, remoteContents = {}, timestamp = syncTimestamp()) {
+  const baseContents = {};
+  const localContents = {};
+  const normalizedRemoteContents = {};
+
+  for (const change of conflictChanges) {
+    const p = change.path;
+    const localPath = path.join(outputDir, p.replace(/^\//, ''));
+    try {
+      localContents[p] = fs.readFileSync(localPath, 'utf8');
+    } catch {
+      localContents[p] = '';
+    }
+
+    const baseContent = readBaseContent(outputDir, p);
+    if (baseContent !== null) baseContents[p] = baseContent;
+
+    normalizedRemoteContents[p] = Object.prototype.hasOwnProperty.call(remoteContents, p)
+      ? remoteContents[p]
+      : '';
+  }
+
+  return buildConflictReviewPacket({
+    plan: { changes: conflictChanges },
+    baseContents,
+    localContents,
+    remoteContents: normalizedRemoteContents,
+    timestamp,
+  });
+}
+
 async function pullAtris() {
   let arg = process.argv[3];
 
   if (arg === '--help') {
-    console.log('Usage: atris pull [business] [--into <path>] [--only <prefix>] [--keep-local] [--timeout <seconds>]');
+    console.log('Usage: atris pull [business] [--into <path>] [--only <prefix>] [--keep-local] [--timeout <seconds>] [--dry-run]');
     console.log('');
     console.log('  Pull is force-overwrite by default. Cloud is the source of truth.');
     console.log('  Local files that conflict with cloud are replaced by the cloud version.');
@@ -40,6 +86,7 @@ async function pullAtris() {
     console.log('  atris pull doordash --into /tmp/doordash');
     console.log('  atris pull doordash --only atris/wiki/');
     console.log('  atris pull --keep-local      Preserve conflicting local edits as .remote files (legacy)');
+    console.log('  atris pull --dry-run         Preview pull changes without writing local files');
     return;
   }
 
@@ -127,6 +174,8 @@ async function pullBusiness(slug) {
   // --keep-local opts back into the legacy three-way merge with .remote conflict files.
   // --force is still accepted as an alias for the default for muscle-memory.
   const force = !process.argv.includes('--keep-local');
+  const failOnConflict = process.argv.includes('--fail-on-conflict');
+  const dryRun = process.argv.includes('--dry-run');
 
   // Parse --only flag: comma-separated directory prefixes to filter
   // Supports both --only=team/,context/ and --only team/,context/
@@ -140,7 +189,7 @@ async function pullBusiness(slug) {
       onlyRaw = process.argv[onlyIdx + 1];
     }
   }
-  const onlyPrefixes = onlyRaw
+  let onlyPrefixes = onlyRaw
     ? onlyRaw.split(',').map(p => {
         let norm = p.replace(/^\//, '');
         const wikiPrefix = normalizeWikiOnlyPrefix(norm);
@@ -202,6 +251,10 @@ async function pullBusiness(slug) {
   // for a stray cwd to cause atris to delete user files.
   ({ dir: outputDir } = resolveSafeOutputDir(outputDir, { slug, op: 'pull into' }));
 
+  if (!onlyPrefixes && isBusinessWorkspaceRoot(outputDir)) {
+    onlyPrefixes = ['atris/'];
+  }
+
   // Resolve business ID — always refresh from API to avoid stale workspace_id
   let businessId, workspaceId, businessName, resolvedSlug;
   let localSlug = slug;
@@ -283,6 +336,14 @@ async function pullBusiness(slug) {
   // Load manifest (last sync state)
   const manifest = loadManifest(resolvedSlug || slug);
   const timeSince = manifest ? _timeSince(manifest.last_sync) : null;
+  const localFilesBeforePull = fs.existsSync(outputDir) ? computeLocalHashes(outputDir) : {};
+  const manifestRootMatchesOutput = !manifest || !manifest.workspace_root || (() => {
+    try {
+      return fs.realpathSync(manifest.workspace_root) === fs.realpathSync(outputDir);
+    } catch {
+      return path.resolve(manifest.workspace_root || '') === path.resolve(outputDir);
+    }
+  })();
 
   console.log('');
   console.log(`Pulling ${businessName}...` + (timeSince ? `  (last synced ${timeSince})` : ''));
@@ -297,7 +358,12 @@ async function pullBusiness(slug) {
   }, 250);
 
   // Smart pull: if we have a manifest (not first sync), fetch hashes first, then only changed content
-  const hasManifest = manifest && manifest.files && Object.keys(manifest.files).length > 0 && !force;
+  const hasManifest = manifest
+    && manifest.files
+    && Object.keys(manifest.files).length > 0
+    && Object.keys(localFilesBeforePull).length > 0
+    && manifestRootMatchesOutput
+    && !force;
   let result;
 
   const pathsParam = onlyPrefixes ? `&paths=${encodeURIComponent(onlyPrefixes.map(p => p.replace(/\/$/, '')).join(','))}` : '';
@@ -483,7 +549,7 @@ async function pullBusiness(slug) {
   }
 
   // Compute local file hashes
-  const localFiles = fs.existsSync(outputDir) ? computeLocalHashes(outputDir) : {};
+  const localFiles = localFilesBeforePull;
 
   // If output dir is empty (fresh clone) or --force, treat as first sync — pull everything
   const effectiveManifest = (Object.keys(localFiles).length === 0 || force) ? null : manifest;
@@ -491,11 +557,38 @@ async function pullBusiness(slug) {
   // Three-way compare
   const diff = threeWayCompare(localFiles, remoteFiles, effectiveManifest);
 
+  if (dryRun) {
+    console.log('');
+    for (const p of [...diff.toPull, ...diff.newRemote]) {
+      const label = diff.newRemote.includes(p) ? 'new on computer' : 'updated on computer';
+      const icon = diff.newRemote.includes(p) ? '+' : '\u2193';
+      console.log(`  ${icon} ${p.replace(/^\//, '')}  ${label}  (dry run)`);
+    }
+    for (const p of diff.conflicts) {
+      console.log(`  ! ${p.replace(/^\//, '')}  conflict  (dry run)`);
+    }
+    for (const p of diff.deletedRemote) {
+      console.log(`  - ${p.replace(/^\//, '')}  deleted on computer  (dry run)`);
+    }
+
+    const parts = [];
+    const pullCount = diff.toPull.length + diff.newRemote.length;
+    if (pullCount > 0) parts.push(`${pullCount} would be pulled`);
+    if (diff.deletedRemote.length > 0) parts.push(`${diff.deletedRemote.length} local file${diff.deletedRemote.length === 1 ? '' : 's'} would be removed`);
+    if (diff.unchanged.length > 0) parts.push(`${diff.unchanged.length} unchanged`);
+    if (diff.conflicts.length > 0) parts.push(`${diff.conflicts.length} conflict${diff.conflicts.length === 1 ? '' : 's'}`);
+    if (parts.length === 0) parts.push('no changes');
+    console.log(`\n  ${parts.join(', ')}. (--dry-run, nothing written)\n`);
+    return;
+  }
+
   // Apply changes
   let pulled = 0;
   let deleted = 0;
   let conflictCount = 0;
   let unchangedCount = diff.unchanged.length;
+  const conflictChanges = [];
+  const conflictRemoteContents = {};
 
   console.log('');
 
@@ -526,6 +619,8 @@ async function pullBusiness(slug) {
     } else {
       // Save remote version alongside local
       const content = remoteContent[p];
+      conflictRemoteContents[p] = content || '';
+      conflictChanges.push({ path: p, status: 'conflict_updated', action: 'review' });
       if (content || content === '') {
         const localPath = path.join(outputDir, p.replace(/^\//, '') + '.remote');
         fs.mkdirSync(path.dirname(localPath), { recursive: true });
@@ -553,6 +648,8 @@ async function pullBusiness(slug) {
       deleted++;
     } else {
       console.log(`  \u26A0 ${p.replace(/^\//, '')}  deleted on computer, but you changed it locally`);
+      conflictRemoteContents[p] = '';
+      conflictChanges.push({ path: p, status: 'conflict_remote_deleted_local_updated', action: 'review' });
       conflictCount++;
     }
   }
@@ -640,6 +737,22 @@ async function pullBusiness(slug) {
   if (unchangedCount > 0) parts.push(`${unchangedCount} unchanged`);
   if (conflictCount > 0) parts.push(`${conflictCount} conflict${conflictCount > 1 ? 's' : ''}`);
   if (parts.length > 0) console.log(`  ${parts.join(', ')}.`);
+  if (failOnConflict && conflictCount > 0) {
+    const timestamp = syncTimestamp();
+    const packet = buildPullConflictReviewPacket(outputDir, conflictChanges, conflictRemoteContents, timestamp);
+    writeConflictReviewPacket(outputDir, packet);
+    console.log('');
+    console.log(`  Sync paused: ${conflictCount} conflict${conflictCount === 1 ? '' : 's'} need review before publishing.`);
+    console.log(`  Review packet: .atris/sync/conflicts/${timestamp}/summary.md`);
+    console.log('  Resolve the conflict, then run sync again.');
+    process.exit(2);
+  }
+  if (remoteFiles['atris/now.md'] || remoteFiles['/atris/now.md']) {
+    const nowLocal = path.join(outputDir, 'atris', 'now.md');
+    if (fs.existsSync(nowLocal)) {
+      console.log('  now: atris/now.md is current.');
+    }
+  }
 
   // Get current commit hash from remote (for manifest)
   let commitHash = null;
@@ -693,8 +806,10 @@ async function pullBusiness(slug) {
     }
     manifestFiles = merged;
   }
-  const newManifest = buildManifest(manifestFiles, commitHash);
+  const newManifest = buildManifest(manifestFiles, commitHash, { workspaceRoot: outputDir });
   saveManifest(resolvedSlug || slug, newManifest);
+  writeBaseContents(outputDir, remoteContent);
+  removeBaseContents(outputDir, diff.deletedRemote);
 
   // Save business config in the output dir so push/status work without args
   const atrisDir = path.join(outputDir, '.atris');
@@ -901,4 +1016,4 @@ async function pullMemberJournal(token, agentId, memberName, memberDir) {
   return synced;
 }
 
-module.exports = { pullAtris };
+module.exports = { buildPullConflictReviewPacket, pullAtris };