bridge-workspace 0.1.0

package/src/backend.js

@@ -0,0 +1,342 @@
+const fs = require('node:fs/promises');
+const http = require('node:http');
+const path = require('node:path');
+const readline = require('node:readline/promises');
+const chokidar = require('chokidar');
+const express = require('express');
+const { WebSocketServer } = require('ws');
+
+const {
+  createBridgeFilter,
+  createFileSnapshot,
+  matchesIncludeRules,
+  normalizeRelativePath,
+  parseIncludeInput,
+  parsePort,
+  parseRepeatedOption,
+  readTextFile,
+} = require('./config');
+
+const DEFAULT_HOST_PORT = 3001;
+let proposalConfirmationQueue = Promise.resolve();
+
+function assertSafeRelativePath(filePath) {
+  const normalized = normalizeRelativePath(filePath);
+  if (!normalized || normalized.startsWith('../') || path.isAbsolute(normalized)) {
+    throw new Error(`Unsafe backend file path: ${filePath}`);
+  }
+  return normalized;
+}
+
+function createUnifiedDiff(filePath, oldContent, newContent) {
+  const oldLines = oldContent.split(/\r?\n/);
+  const newLines = newContent.split(/\r?\n/);
+  const output = [`--- a/${filePath}`, `+++ b/${filePath}`, `@@ -1,${oldLines.length} +1,${newLines.length} @@`];
+
+  for (const line of oldLines) {
+    output.push(`-${line}`);
+  }
+  for (const line of newLines) {
+    output.push(`+${line}`);
+  }
+
+  return `${output.join('\n')}\n`;
+}
+
+async function createChangeProposal(rootDir, filePath, newContent) {
+  const safePath = assertSafeRelativePath(filePath);
+  const absolutePath = path.join(rootDir, safePath);
+  const oldContent = await fs.readFile(absolutePath, 'utf8');
+  const patch = createUnifiedDiff(safePath, oldContent, newContent);
+  const patchDir = path.join(rootDir, '.bridge', 'patches');
+  const patchPath = path.join(patchDir, `${Date.now()}-${safePath.replace(/[\\/]/g, '__')}.patch`);
+
+  await fs.mkdir(patchDir, { recursive: true });
+  await fs.writeFile(patchPath, patch, 'utf8');
+
+  return {
+    filePath: safePath,
+    patch,
+    patchPath,
+    async apply() {
+      await fs.writeFile(absolutePath, newContent, 'utf8');
+    },
+  };
+}
+
+async function createFileIndex(rootDir, filter) {
+  const initialSnapshot = await createFileSnapshot(rootDir, filter);
+  const files = new Map();
+
+  for (const file of initialSnapshot.files) {
+    const absolutePath = path.join(rootDir, file.path);
+    const stat = await fs.stat(absolutePath);
+    files.set(file.path, {
+      path: file.path,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      content: file.content,
+    });
+  }
+
+  function sortedFiles() {
+    return Array.from(files.values())
+      .sort((left, right) => left.path.localeCompare(right.path))
+      .map((file) => ({ path: file.path, size: file.size, mtimeMs: file.mtimeMs }));
+  }
+
+  return {
+    snapshot(includeRules = []) {
+      return { files: sortedFiles().filter((file) => matchesIncludeRules(file.path, includeRules)) };
+    },
+    async upsertAbsolutePath(absolutePath) {
+      const relativePath = normalizeRelativePath(path.relative(rootDir, absolutePath));
+      if (!filter.isAllowed(relativePath)) {
+        return null;
+      }
+      const content = await readTextFile(rootDir, relativePath);
+      const stat = await fs.stat(absolutePath);
+      files.set(relativePath, { path: relativePath, size: stat.size, mtimeMs: stat.mtimeMs, content });
+      return { path: relativePath, content };
+    },
+    removeAbsolutePath(absolutePath) {
+      const relativePath = normalizeRelativePath(path.relative(rootDir, absolutePath));
+      files.delete(relativePath);
+      return relativePath;
+    },
+    getContent(filePath) {
+      const file = files.get(normalizeRelativePath(filePath));
+      return file ? file.content : null;
+    },
+    hasFile(filePath) {
+      return files.has(normalizeRelativePath(filePath));
+    },
+  };
+}
+
+function parseRequestInclude(req) {
+  const rawInclude = req.query.include;
+  if (Array.isArray(rawInclude)) {
+    return parseIncludeInput(rawInclude);
+  }
+  return parseIncludeInput(rawInclude || '');
+}
+
+function printDiffPreview(proposal, output = process.stdout) {
+  output.write(`\n\x1b[33m[Bridge] 前端 AI 申请修改 ${proposal.filePath}\x1b[0m\n`);
+  output.write(`\x1b[36mPatch: ${proposal.patchPath}\x1b[0m\n`);
+  for (const line of proposal.patch.split('\n')) {
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      output.write(`\x1b[32m${line}\x1b[0m\n`);
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      output.write(`\x1b[31m${line}\x1b[0m\n`);
+    } else {
+      output.write(`${line}\n`);
+    }
+  }
+}
+
+async function confirmAndApplyProposal(proposal, options = {}) {
+  const output = options.output || process.stdout;
+  const rl = options.rl || readline.createInterface({ input: options.input || process.stdin, output });
+
+  try {
+    const answer = await rl.question(`[Bridge] 前端 AI 申请修改 ${proposal.filePath}，确认应用此改动吗？(Y/N) `);
+    if (answer.trim().toLowerCase() === 'y') {
+      await proposal.apply();
+      output.write(`[Bridge] 已应用 ${proposal.filePath}，请在 IDE/Git 中 Review 未提交改动。\n`);
+      return true;
+    }
+    output.write(`[Bridge] 已拒绝 ${proposal.filePath} 的修改申请。\n`);
+    return false;
+  } finally {
+    if (!options.rl) {
+      rl.close();
+    }
+  }
+}
+
+function enqueueProposalConfirmation(proposal, options = {}) {
+  const run = () => confirmAndApplyProposal(proposal, options);
+  const result = proposalConfirmationQueue.then(run, run);
+  proposalConfirmationQueue = result.catch(() => {});
+  return result;
+}
+
+function broadcastJson(wss, payload) {
+  const message = JSON.stringify(payload);
+  for (const client of wss.clients) {
+    if (client.readyState === client.OPEN) {
+      client.send(message);
+    }
+  }
+}
+
+async function createBackendHost(options = {}) {
+  const rootDir = path.resolve(options.rootDir || process.cwd());
+  const port = Number(options.port || DEFAULT_HOST_PORT);
+  const hostInclude = parseIncludeInput(options.include || []);
+  const filter = await createBridgeFilter(rootDir, { include: hostInclude });
+  const fileIndex = await createFileIndex(rootDir, filter);
+  const app = express();
+  const server = http.createServer(app);
+  const wss = new WebSocketServer({ server });
+
+  app.use(express.json({ limit: '2mb' }));
+
+  app.get('/health', (req, res) => {
+    res.json({ ok: true, service: 'bridge-host', root: rootDir });
+  });
+
+  app.get('/file-tree', async (req, res, next) => {
+    try {
+      res.json(fileIndex.snapshot(parseRequestInclude(req)));
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.get('/file-content', (req, res) => {
+    const filePath = typeof req.query.path === 'string' ? normalizeRelativePath(req.query.path) : '';
+    const includeRules = parseRequestInclude(req);
+    if (!filePath || !filter.isAllowed(filePath) || !matchesIncludeRules(filePath, includeRules)) {
+      res.status(400).json({ error: 'Invalid or disallowed file path' });
+      return;
+    }
+    const content = fileIndex.getContent(filePath);
+    if (content === null) {
+      res.status(404).json({ error: 'File not found' });
+      return;
+    }
+    res.json({ path: filePath, content });
+  });
+
+  app.post('/api/propose-change', async (req, res, next) => {
+    try {
+      const { filePath, newContent } = req.body || {};
+      if (typeof filePath !== 'string' || typeof newContent !== 'string') {
+        res.status(400).json({ error: 'filePath and newContent are required strings' });
+        return;
+      }
+      const relativePath = normalizeRelativePath(filePath);
+      const includeRules = parseIncludeInput(req.body.include || []);
+      if (!filter.isAllowed(relativePath) || !matchesIncludeRules(relativePath, includeRules) || !fileIndex.hasFile(relativePath)) {
+        res.status(400).json({ error: 'File is not allowed by bridge filter' });
+        return;
+      }
+
+      const proposal = await createChangeProposal(rootDir, relativePath, newContent);
+      printDiffPreview(proposal);
+      res.status(202).json({ accepted: true, filePath: proposal.filePath, patchPath: proposal.patchPath });
+      enqueueProposalConfirmation(proposal).catch((error) => {
+        console.error(`[Bridge] 应用修改失败: ${error.message}`);
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  const watcher = chokidar.watch(rootDir, {
+    ignored: (absolutePath) => {
+      const relativePath = normalizeRelativePath(path.relative(rootDir, absolutePath));
+      if (!relativePath || relativePath === '.') {
+        return false;
+      }
+      return filter.ignores(`${relativePath}/`) || (!absolutePath.endsWith(path.sep) && !filter.isAllowed(relativePath));
+    },
+    ignoreInitial: true,
+    persistent: true,
+  });
+
+  async function emitFileUpdate(absolutePath) {
+    const relativePath = normalizeRelativePath(path.relative(rootDir, absolutePath));
+    if (!filter.isAllowed(relativePath)) {
+      return;
+    }
+    try {
+      const file = await fileIndex.upsertAbsolutePath(absolutePath);
+      if (file) {
+        broadcastJson(wss, { type: 'file:update', path: file.path, content: file.content });
+      }
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        broadcastJson(wss, { type: 'file:error', path: relativePath, message: error.message });
+      }
+    }
+  }
+
+  watcher.on('add', emitFileUpdate);
+  watcher.on('change', emitFileUpdate);
+  watcher.on('unlink', (absolutePath) => {
+    const relativePath = fileIndex.removeAbsolutePath(absolutePath);
+    broadcastJson(wss, { type: 'file:delete', path: relativePath });
+  });
+
+  return {
+    app,
+    server,
+    wss,
+    watcher,
+    fileIndex,
+    rootDir,
+    port,
+    include: hostInclude,
+    listen() {
+      return new Promise((resolve) => server.listen(port, () => resolve(this)));
+    },
+    async close() {
+      await watcher.close();
+      wss.close();
+      await new Promise((resolve) => server.close(resolve));
+    },
+  };
+}
+
+function createHostPromptSession(options = {}) {
+  const input = options.input || process.stdin;
+  const output = options.output || process.stdout;
+  return readline.createInterface({ input, output });
+}
+
+async function promptHostInclude(options = {}) {
+  const output = options.output || process.stdout;
+  const rl = options.rl || createHostPromptSession(options);
+  try {
+    output.write('请输入本次允许前端访问的 include（逗号分隔；为空则不启动）\n');
+    output.write('示例：src/main/java/**/dto/**,src/main/java/**/controller/**,README.md,AGENTS.md\n');
+    return await rl.question('include > ');
+  } finally {
+    if (!options.rl) {
+      rl.close();
+    }
+  }
+}
+
+async function runBackendHost(argv = process.argv.slice(2)) {
+  const cliInclude = parseIncludeInput(parseRepeatedOption(argv, '--include'));
+  const include = cliInclude.length ? cliInclude : parseIncludeInput(await promptHostInclude());
+  if (!include.length) {
+    console.log('[Bridge] 未设置后端 include，host 未启动。');
+    return null;
+  }
+  const host = await createBackendHost({ port: parsePort(argv, 'BRIDGE_PORT', DEFAULT_HOST_PORT), include });
+  await host.listen();
+  console.log(`Bridge backend host listening on http://0.0.0.0:${host.port}`);
+  console.log(`[Bridge] Host include: ${host.include.join(', ')}`);
+  return host;
+}
+
+module.exports = {
+  DEFAULT_HOST_PORT,
+  assertSafeRelativePath,
+  confirmAndApplyProposal,
+  createBackendHost,
+  createChangeProposal,
+  createFileIndex,
+  createHostPromptSession,
+  createUnifiedDiff,
+  enqueueProposalConfirmation,
+  printDiffPreview,
+  promptHostInclude,
+  runBackendHost,
+};

package/src/config.js

@@ -0,0 +1,233 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const ignore = require('ignore');
+
+const ALLOWED_EXTENSIONS = new Set(['.java', '.ts', '.js', '.go', '.py']);
+const GUIDANCE_FILE_NAMES = new Set(['README.md', 'AGENTS.md', 'CLAUDE.md', 'GEMINI.md', 'SKILL.md']);
+const GUIDANCE_DIRECTORIES = ['.cursor/rules/', '.claude/skills/', 'skills/'];
+const DEFAULT_IGNORE_RULES = [
+  'node_modules/',
+  'dist/',
+  'build/',
+  'target/',
+  'out/',
+  'coverage/',
+  '.git/',
+  '.idea/',
+  '.vscode/',
+  '*.log',
+  '*.map',
+  '*.min.js',
+  '*.zip',
+  '*.tar',
+  '*.gz',
+  '*.png',
+  '*.jpg',
+  '*.jpeg',
+  '*.gif',
+  '*.webp',
+  '*.pdf',
+  '*.class',
+  '*.jar',
+];
+
+function normalizeRelativePath(filePath) {
+  return filePath.split(path.sep).join('/').replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function isAllowedExtension(filePath) {
+  return ALLOWED_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+
+function isGuidanceFile(filePath) {
+  const relativePath = normalizeRelativePath(filePath);
+  const baseName = path.posix.basename(relativePath);
+  return GUIDANCE_FILE_NAMES.has(baseName)
+    || GUIDANCE_DIRECTORIES.some((directory) => relativePath.startsWith(directory) && relativePath.endsWith('.md'));
+}
+
+async function readBridgeIgnore(rootDir) {
+  const projectBridgeIgnore = await readIgnoreFile(path.join(rootDir, '.bridgeignore'));
+  if (projectBridgeIgnore) {
+    return projectBridgeIgnore;
+  }
+
+  const projectGitIgnore = await readIgnoreFile(path.join(rootDir, '.gitignore'));
+  if (projectGitIgnore) {
+    return projectGitIgnore;
+  }
+
+  const bundledBridgeIgnore = await readIgnoreFile(path.join(__dirname, '..', '.bridgeignore'));
+  return bundledBridgeIgnore || DEFAULT_IGNORE_RULES;
+}
+
+async function readIgnoreFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return content.split(/\r?\n/).filter((line) => line.trim() && !line.trim().startsWith('#'));
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function createBridgeFilter(rootDir) {
+  const backendConfig = arguments.length > 1 ? arguments[1] : await loadBackendBridgeConfig(rootDir);
+  const bridgeRules = await readBridgeIgnore(rootDir);
+  const matcher = ignore().add(DEFAULT_IGNORE_RULES).add(bridgeRules);
+  const includeRules = normalizeIncludeRules(backendConfig.include);
+
+  return {
+    isAllowed(filePath) {
+      const relativePath = normalizeRelativePath(filePath);
+      return (isAllowedExtension(relativePath) || isGuidanceFile(relativePath))
+        && matchesIncludeRules(relativePath, includeRules)
+        && !matcher.ignores(relativePath);
+    },
+    ignores(filePath) {
+      const relativePath = normalizeRelativePath(filePath);
+      return !directoryCouldMatchInclude(relativePath, includeRules) || matcher.ignores(relativePath);
+    },
+  };
+}
+
+async function loadBackendBridgeConfig(rootDir = process.cwd()) {
+  try {
+    const content = await fs.readFile(path.join(rootDir, 'bridge.config.json'), 'utf8');
+    const config = JSON.parse(content);
+    return { include: Array.isArray(config.include) ? config.include : [] };
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return { include: [] };
+    }
+    throw error;
+  }
+}
+
+function normalizeIncludeRules(include = []) {
+  return include.map((rule) => normalizeRelativePath(String(rule).trim())).filter(Boolean);
+}
+
+function parseIncludeInput(input) {
+  if (Array.isArray(input)) {
+    return normalizeIncludeRules(input);
+  }
+  return normalizeIncludeRules(String(input || '').split(','));
+}
+
+function matchesIncludeRules(filePath, includeRules) {
+  if (!includeRules.length) {
+    return true;
+  }
+  const relativePath = normalizeRelativePath(filePath);
+  return includeRules.some((rule) => matchesIncludeRule(relativePath, rule));
+}
+
+function matchesAllIncludeScopes(filePath, includeScopes) {
+  return includeScopes.every((scope) => matchesIncludeRules(filePath, normalizeIncludeRules(scope)));
+}
+
+function matchesIncludeRule(relativePath, rule) {
+  if (rule.endsWith('/**')) {
+    return relativePath.startsWith(rule.slice(0, -2));
+  }
+  if (rule.endsWith('/')) {
+    return relativePath.startsWith(rule);
+  }
+  return relativePath === rule || relativePath.startsWith(`${rule}/`);
+}
+
+function directoryCouldMatchInclude(directoryPath, includeRules) {
+  if (!includeRules.length) {
+    return true;
+  }
+  const normalizedDirectory = normalizeRelativePath(directoryPath).replace(/\/?$/, '/');
+  return includeRules.some((rule) => {
+    const normalizedRule = rule.endsWith('/**') ? rule.slice(0, -2) : rule;
+    const directoryRule = normalizedRule.endsWith('/') ? normalizedRule : `${normalizedRule}/`;
+    return directoryRule.startsWith(normalizedDirectory) || normalizedDirectory.startsWith(directoryRule);
+  });
+}
+
+async function walkAllowedFiles(rootDir, filter, currentDir = rootDir, output = []) {
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const absolutePath = path.join(currentDir, entry.name);
+    const relativePath = normalizeRelativePath(path.relative(rootDir, absolutePath));
+
+    if (entry.isDirectory()) {
+      if (!filter.ignores(`${relativePath}/`)) {
+        await walkAllowedFiles(rootDir, filter, absolutePath, output);
+      }
+      continue;
+    }
+
+    if (entry.isFile() && filter.isAllowed(relativePath)) {
+      output.push(relativePath);
+    }
+  }
+
+  return output.sort();
+}
+
+async function readTextFile(rootDir, relativePath) {
+  return fs.readFile(path.join(rootDir, relativePath), 'utf8');
+}
+
+async function createFileSnapshot(rootDir, filter) {
+  const files = await walkAllowedFiles(rootDir, filter);
+  const snapshotFiles = [];
+
+  for (const filePath of files) {
+    snapshotFiles.push({ path: filePath, content: await readTextFile(rootDir, filePath) });
+  }
+
+  return { files: snapshotFiles };
+}
+
+async function loadBridgeConfig(rootDir = process.cwd()) {
+  const configPath = path.join(rootDir, 'bridge.config.json');
+  const content = await fs.readFile(configPath, 'utf8');
+  return JSON.parse(content);
+}
+
+function parsePort(argv, envName, fallback) {
+  const portIndex = argv.indexOf('--port');
+  if (portIndex >= 0 && argv[portIndex + 1]) {
+    return Number(argv[portIndex + 1]);
+  }
+  return Number(process.env[envName] || fallback);
+}
+
+function parseRepeatedOption(argv, optionName) {
+  const values = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    if (argv[index] === optionName && argv[index + 1]) {
+      values.push(argv[index + 1]);
+      index += 1;
+    }
+  }
+  return values;
+}
+
+module.exports = {
+  ALLOWED_EXTENSIONS,
+  DEFAULT_IGNORE_RULES,
+  GUIDANCE_DIRECTORIES,
+  GUIDANCE_FILE_NAMES,
+  createBridgeFilter,
+  createFileSnapshot,
+  isGuidanceFile,
+  loadBackendBridgeConfig,
+  loadBridgeConfig,
+  matchesAllIncludeScopes,
+  matchesIncludeRules,
+  normalizeRelativePath,
+  parseIncludeInput,
+  parsePort,
+  parseRepeatedOption,
+  readTextFile,
+};