aibridge-context 1.5.2 → 2.0.0

package/core/watcher.js

@@ -1,9 +1,10 @@
 'use strict';
 
-const path = require('path');
+const path     = require('path');
 const chokidar = require('chokidar');
 
-const { syncContextToGit } = require('./gitSync');
+const { syncContextToGit }           = require('./gitSync');
+const { captureSnapshot, deleteSnapshot } = require('./fileSnapshot');
 const {
   createDebouncedStateUpdater,
   loadRuntimeConfig,
@@ -12,82 +13,110 @@ const {
   updateProjectState
 } = require('./stateManager');
 
-function normalizeFilePath(projectRoot, filePath) {
-  return path.relative(projectRoot, filePath).split(path.sep).join('/');
+function normPath(root, filePath) {
+  return path.relative(root, filePath).split(path.sep).join('/');
 }
 
 async function startWatcher(projectRoot, options) {
-  const settings = Object.assign({ logger: null }, options);
-  const logger = settings.logger;
-  const config = await loadRuntimeConfig(projectRoot);
-  const syncCallback = async () => syncContextToGit(projectRoot, config.gitSync, logger);
-  const debouncedUpdater = createDebouncedStateUpdater(projectRoot, {
-    debounceMs: config.debounceMs,
+  const settings   = Object.assign({ logger: null }, options);
+  const logger     = settings.logger;
+  const config     = await loadRuntimeConfig(projectRoot);
+  const syncCb     = async () => syncContextToGit(projectRoot, config.gitSync, logger);
+  const debounced  = createDebouncedStateUpdater(projectRoot, {
+    debounceMs:   config.debounceMs,
     logger,
-    syncCallback
+    syncCallback: syncCb
   });
 
   const watcher = chokidar.watch(projectRoot, {
     ignored(filePath) {
-      const normalizedPath = normalizeFilePath(projectRoot, filePath);
-      return shouldIgnoreProjectFile(normalizedPath);
+      const rel = normPath(projectRoot, filePath);
+      return shouldIgnoreProjectFile(rel);
     },
     ignoreInitial: true,
-    persistent: true
+    persistent:    true,
+    awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 30 }
   });
 
-  function handleEvent(action, filePath) {
-    const normalizedPath = normalizeFilePath(projectRoot, filePath);
+  // ── ADD: capture snapshot BEFORE chokidar fires for 'change'
+  // We pre-read when the watch starts for existing files via 'ready' + 'add'
+  watcher.on('add', (filePath) => {
+    const rel = normPath(projectRoot, filePath);
+    if (!rel || shouldIgnoreProjectFile(rel) || scoreEvent(rel) < 2) return;
 
-    if (!normalizedPath || shouldIgnoreProjectFile(normalizedPath) || scoreEvent(normalizedPath) < 2) {
-      return;
-    }
+    // Snapshot what the file looks like when first seen
+    captureSnapshot(filePath);
 
-    if (logger) {
-      logger.debug(`Queued meaningful ${action} for ${normalizedPath}`);
-    }
+    if (logger) logger.debug(`Tracking new file: ${rel}`);
 
-    debouncedUpdater.enqueue({
-      timestamp: new Date().toISOString(),
-      action,
-      file: normalizedPath
+    debounced.enqueue({
+      timestamp:  new Date().toISOString(),
+      action:     'add',
+      file:       rel,
+      oldContent: null         // brand new file
+      // newContent left undefined → watcher will read it fresh
+    });
+  });
+
+  watcher.on('change', (filePath) => {
+    const rel = normPath(projectRoot, filePath);
+    if (!rel || shouldIgnoreProjectFile(rel) || scoreEvent(rel) < 2) return;
+
+    // Grab the PREVIOUS content BEFORE it's overwritten on disk
+    const oldContent = require('./fileSnapshot').getSnapshot(filePath);
+
+    // Immediately update the snapshot to the latest saved version
+    captureSnapshot(filePath);
+
+    if (logger) logger.debug(`Change detected: ${rel}`);
+
+    debounced.enqueue({
+      timestamp:  new Date().toISOString(),
+      action:     'change',
+      file:       rel,
+      oldContent  // what it looked like before this save
+      // newContent left undefined → stateManager reads from disk (just written)
     });
-  }
-
-  watcher.on('add', (filePath) => handleEvent('add', filePath));
-  watcher.on('change', (filePath) => handleEvent('change', filePath));
-  watcher.on('unlink', (filePath) => handleEvent('delete', filePath));
-  watcher.on('error', (error) => {
-    if (logger) {
-      logger.error(`Watcher error: ${error.message}`);
-    }
   });
 
+  watcher.on('unlink', (filePath) => {
+    const rel = normPath(projectRoot, filePath);
+    if (!rel || shouldIgnoreProjectFile(rel)) return;
+
+    deleteSnapshot(filePath);
+
+    if (logger) logger.debug(`Deleted: ${rel}`);
+
+    debounced.enqueue({
+      timestamp:  new Date().toISOString(),
+      action:     'delete',
+      file:       rel,
+      oldContent: null,
+      newContent: ''
+    });
+  });
+
+  watcher.on('error', (err) => {
+    if (logger) logger.error(`Watcher error: ${err.message}`);
+  });
+
+  // Initial state update on startup
   await updateProjectState(
     projectRoot,
-    {
-      timestamp: new Date().toISOString(),
-      action: 'watcher_started',
-      file: '.'
-    },
-    {
-      logger,
-      syncCallback
-    }
+    { timestamp: new Date().toISOString(), action: 'watcher_started', file: '.' },
+    { logger, syncCallback: syncCb }
   );
 
   return {
     watcher,
     async close() {
-      await debouncedUpdater.flushNow();
+      await debounced.flushNow();
       await watcher.close();
     },
     async flush() {
-      await debouncedUpdater.flushNow();
+      await debounced.flushNow();
     }
   };
 }
 
-module.exports = {
-  startWatcher
-};
+module.exports = { startWatcher };

package/index.js

@@ -1,14 +1,17 @@
 'use strict';
 
-const { initProject } = require('./core/init');
-const { startWatcher } = require('./core/watcher');
+const { initProject }     = require('./core/init');
+const { startWatcher }    = require('./core/watcher');
+const { generateBriefing } = require('./core/briefingGenerator');
 const {
   bootstrapProjectAnalysis,
   updateProjectState,
   loadRuntimeConfig,
-  updateRuntimeConfig
+  updateRuntimeConfig,
+  createDefaultState,
+  getContextPaths
 } = require('./core/stateManager');
-const { startServer } = require('./server/server');
+const { startServer }  = require('./server/server');
 const {
   buildPublicAiUrls,
   ensureGitInitialized,
@@ -17,14 +20,25 @@ const {
 } = require('./core/gitSync');
 
 module.exports = {
-  buildPublicAiUrls,
-  ensureGitInitialized,
+  // Core lifecycle
   initProject,
-  linkGithubRepository,
   startWatcher,
+  startServer,
+
+  // State management
   updateProjectState,
   loadRuntimeConfig,
   updateRuntimeConfig,
-  startServer,
+  createDefaultState,
+  getContextPaths,
+  bootstrapProjectAnalysis,
+
+  // Briefing
+  generateBriefing,
+
+  // Git
+  buildPublicAiUrls,
+  ensureGitInitialized,
+  linkGithubRepository,
   syncContextToGit
-};
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aibridge-context",
-  "version": "1.5.2",
-  "description": "Zero-config CLI and library for generating AI-readable project context, serving it locally, and syncing it with git.",
+  "version": "2.0.0",
+  "description": "Zero-config CLI that auto-generates an AI briefing file for any project. Tracks code changes with real diffs, errors, fixes, file structure, API routes and dependencies. One command: npx aibridge-context start",
   "main": "./index.js",
   "bin": {
     "aibridge-context": "./bin/cli.js",
@@ -29,7 +29,11 @@
     "watcher",
     "express",
     "developer-tools",
-    "git"
+    "git",
+    "briefing",
+    "diff",
+    "changelog",
+    "code-tracking"
   ],
   "author": "",
   "license": "MIT",

package/server/routes.js

@@ -1,50 +1,46 @@
 'use strict';
 
-const path = require('path');
+const path    = require('path');
 const express = require('express');
 const { getContextPaths } = require('../core/stateManager');
 
 function createRoutes(projectRoot, logger) {
   const router = express.Router();
-  const paths = getContextPaths(projectRoot);
+  const paths  = getContextPaths(projectRoot);
 
   function sendFile(filePath, contentType) {
-    return function routeHandler(request, response) {
-      response.type(contentType);
-      response.sendFile(
-        path.resolve(filePath),
-        {
-          dotfiles: 'allow'
-        },
-        (error) => {
-          if (!error) {
-            return;
-          }
-
-          if (logger) {
-            logger.error(`Failed to serve ${request.path}: ${error.message}`);
-          }
-
-          if (response.headersSent) {
-            return;
-          }
-
-          response.status(error.statusCode || 500).json({
-            error: 'Unable to read AI context file.'
-          });
-        }
-      );
+    return function routeHandler(req, res) {
+      res.type(contentType);
+      res.sendFile(path.resolve(filePath), { dotfiles: 'allow' }, (err) => {
+        if (!err) return;
+        if (logger) logger.error(`Failed to serve ${req.path}: ${err.message}`);
+        if (res.headersSent) return;
+        res.status(err.statusCode || 500).json({ error: 'Unable to read AI context file.' });
+      });
     };
   }
 
-  router.get('/state.json', sendFile(paths.stateFile, 'application/json'));
-  router.get('/brain.txt', sendFile(paths.brainFile, 'text/plain'));
-  router.get('/context.md', sendFile(paths.contextFile, 'text/markdown'));
-  router.get('/changelog.json', sendFile(paths.changelogFile, 'application/json'));
+  router.get('/state.json',    sendFile(paths.stateFile,     'application/json'));
+  router.get('/brain.txt',     sendFile(paths.brainFile,     'text/plain'));
+  router.get('/context.md',    sendFile(paths.contextFile,   'text/markdown'));
+  router.get('/changelog.json',sendFile(paths.changelogFile, 'application/json'));
+  router.get('/briefing.md',   sendFile(paths.briefingFile,  'text/markdown'));
+
+  // Convenience root — lists all available endpoints
+  router.get('/', (req, res) => {
+    res.json({
+      project:   require('../core/stateManager').detectProjectMetadata(projectRoot).project,
+      endpoints: {
+        briefing:  '/briefing.md   – Full AI briefing (paste into any AI)',
+        state:     '/state.json    – Machine-readable full state',
+        changelog: '/changelog.json – Code change history with diffs',
+        brain:     '/brain.txt     – AI instructions',
+        context:   '/context.md    – Human-readable project summary'
+      }
+    });
+  });
 
   return router;
 }
 
-module.exports = {
-  createRoutes
-};
+module.exports = { createRoutes };