@sanqianx/claude-ai-workbench 0.11.0

package/src/backend/http/ai-profile-routes.js

@@ -0,0 +1,61 @@
+const { AI_VENDOR_PRESETS, listVendorPresetNames } = require('../lib/ai-vendor-presets');
+const { listAdapters } = require('../lib/ai-adapter');
+const { sendJson, readBody } = require('./node-helpers');
+
+async function handleAiProfileRoutes(req, res, options = {}) {
+  const store = options.store || options.profileStore;
+  const basePath = options.basePath || '/api/ai-profiles';
+  const vendorPath = options.vendorPath || '/api/ai-vendor-presets';
+  const url = options.url || new URL(req.url, 'http://127.0.0.1');
+  const pathname = url.pathname;
+  if (pathname !== basePath && pathname !== vendorPath && !pathname.startsWith(`${basePath}/`)) return false;
+  if (!store) {
+    sendJson(res, 503, { ok: false, error: 'AI profile store is not available' });
+    return true;
+  }
+
+  try {
+    if (req.method === 'GET' && pathname === basePath) {
+      const publicConfig = store.publicConfig();
+      sendJson(res, 200, {
+        ok: true,
+        ...publicConfig,
+        adapters: listAdapters(),
+      });
+      return true;
+    }
+
+    if (req.method === 'GET' && pathname === vendorPath) {
+      sendJson(res, 200, { ok: true, presets: AI_VENDOR_PRESETS, names: listVendorPresetNames() });
+      return true;
+    }
+
+    if (req.method === 'PUT' && pathname === basePath) {
+      const body = await readBody(req);
+      const saved = store.writeConfig(body);
+      sendJson(res, 200, { ok: true, config: saved });
+      return true;
+    }
+
+    if (req.method === 'POST' && pathname === `${basePath}/test`) {
+      const body = await readBody(req);
+      const result = await store.testProfile({
+        profileId: body.profileId,
+        profile: body.profile,
+        prompt: body.prompt || 'what model are you?',
+      });
+      sendJson(res, 200, result);
+      return true;
+    }
+  } catch (error) {
+    sendJson(res, error.status || 400, { ok: false, error: error.message, errors: error.errors || undefined });
+    return true;
+  }
+
+  sendJson(res, 404, { ok: false, error: 'unknown AI profile route' });
+  return true;
+}
+
+module.exports = {
+  handleAiProfileRoutes,
+};

package/src/backend/http/claude-routes.js

@@ -0,0 +1,170 @@
+const { sendJson, readBody, writeSseHeaders, writeSse } = require('./node-helpers');
+
+function sessionIdFromPath(pathname, basePath) {
+  const rest = pathname.slice(basePath.length).replace(/^\/+/, '');
+  const parts = rest.split('/');
+  return parts[0] === 'sessions' ? parts[1] || '' : '';
+}
+
+function ensureRunner(runner) {
+  if (!runner || typeof runner.listSessions !== 'function') {
+    throw new Error('Claude runner is not available');
+  }
+}
+
+async function handleClaudeRoutes(req, res, options = {}) {
+  const runner = options.runner;
+  const basePath = options.basePath || '/api/claude';
+  const url = options.url || new URL(req.url, 'http://127.0.0.1');
+  const pathname = url.pathname;
+  if (pathname !== basePath && !pathname.startsWith(`${basePath}/`)) return false;
+
+  try {
+    ensureRunner(runner);
+  } catch (error) {
+    sendJson(res, 503, { ok: false, error: error.message });
+    return true;
+  }
+
+  if (req.method === 'GET' && pathname === `${basePath}/sessions`) {
+    const projectSlug = url.searchParams.get('slug') || url.searchParams.get('projectSlug') || null;
+    sendJson(res, 200, { ok: true, sessions: runner.listSessions({ projectSlug }) });
+    return true;
+  }
+
+  if (req.method === 'GET' && pathname === `${basePath}/sessions-stream`) {
+    writeSseHeaders(res);
+    writeSse(res, 'claude/snapshot', { sessions: runner.listSessions({}) });
+    const unsubscribe = runner.subscribeList(event => {
+      try { writeSse(res, 'claude/sessions-changed', event); } catch {}
+    });
+    const heartbeat = setInterval(() => {
+      try { res.write(`: keepalive ${Date.now()}\n\n`); } catch {}
+    }, 15000);
+    const cleanup = () => {
+      clearInterval(heartbeat);
+      try { unsubscribe(); } catch {}
+    };
+    req.on('close', cleanup);
+    req.on('error', cleanup);
+    return true;
+  }
+
+  if (req.method === 'POST' && pathname.startsWith(`${basePath}/projects/`) && pathname.endsWith('/start')) {
+    const slug = pathname.slice(`${basePath}/projects/`.length).replace(/\/start$/, '');
+    const resolveProject = options.resolveProject || options.projectResolver;
+    if (typeof resolveProject !== 'function') {
+      sendJson(res, 500, { ok: false, error: 'resolveProject option is required' });
+      return true;
+    }
+    const project = await resolveProject(slug, req);
+    if (!project) {
+      sendJson(res, 404, { ok: false, error: `project not found: ${slug}` });
+      return true;
+    }
+    const started = runner.startChatSession({
+      slug: project.slug || slug,
+      projectPath: project.projectPath || project.gitPath || project.localPath || project.path,
+      kbPath: project.kbPath || project.workPath || project.projectPath || project.path,
+      aiProfile: project.aiProfile || null,
+      permissionMode: project.permissionMode || 'default',
+    });
+    sendJson(res, 200, { ok: true, slug, ...started, aiProfileId: project.aiProfile && project.aiProfile.id || null });
+    return true;
+  }
+
+  const sessionId = sessionIdFromPath(pathname, basePath);
+  if (!sessionId) {
+    sendJson(res, 404, { ok: false, error: 'unknown Claude route' });
+    return true;
+  }
+
+  if (req.method === 'GET' && pathname === `${basePath}/sessions/${sessionId}`) {
+    const state = runner.getState(sessionId);
+    if (!state) sendJson(res, 404, { ok: false, error: 'session not found' });
+    else sendJson(res, 200, { ok: true, ...state });
+    return true;
+  }
+
+  if (req.method === 'GET' && pathname === `${basePath}/sessions/${sessionId}/token-usage`) {
+    if (!runner.getSession(sessionId)) sendJson(res, 404, { ok: false, error: 'session not found' });
+    else sendJson(res, 200, { ok: true, sessionId, ...runner.getSessionTokenUsage(sessionId) });
+    return true;
+  }
+
+  if (req.method === 'GET' && pathname === `${basePath}/sessions/${sessionId}/stream`) {
+    if (!runner.getSession(sessionId)) {
+      sendJson(res, 404, { ok: false, error: 'session not found' });
+      return true;
+    }
+    writeSseHeaders(res);
+    writeSse(res, 'claude/hello', { sessionId, time: new Date().toISOString() });
+    const session = runner.getSession(sessionId);
+    const events = Array.isArray(session && session.outputBuffer) ? session.outputBuffer : [];
+    for (const event of events.slice(-1000)) {
+      if (event && event.type) writeSse(res, event.type, event);
+    }
+    const unsubscribe = runner.subscribe(sessionId, event => {
+      try { writeSse(res, event.type, event); } catch {}
+    });
+    const heartbeat = setInterval(() => {
+      try { res.write(`: keepalive ${Date.now()}\n\n`); } catch {}
+    }, 15000);
+    const cleanup = () => {
+      clearInterval(heartbeat);
+      try { unsubscribe(); } catch {}
+    };
+    req.on('close', cleanup);
+    req.on('error', cleanup);
+    return true;
+  }
+
+  if (req.method === 'POST' && pathname === `${basePath}/sessions/${sessionId}/input`) {
+    if (!runner.getSession(sessionId)) {
+      sendJson(res, 404, { ok: false, error: 'session not found' });
+      return true;
+    }
+    const body = await readBody(req);
+    if (!body || typeof body.text !== 'string' || !body.text.trim()) {
+      sendJson(res, 400, { ok: false, error: 'body.text is required' });
+      return true;
+    }
+    const resolveProfile = options.resolveProfile || options.profileResolver;
+    const profile = typeof resolveProfile === 'function'
+      ? await resolveProfile(runner.getState(sessionId), body, req)
+      : null;
+    const result = await runner.sendInput(sessionId, body.text, profile, {
+      permissionMode: typeof body.permissionMode === 'string' ? body.permissionMode : undefined,
+      allowedTools: Array.isArray(body.allowedTools) ? body.allowedTools : undefined,
+    });
+    sendJson(res, 200, { ok: true, sessionId, pendingPermission: result && result.pendingPermission || null, aiProfileId: profile && profile.id || null });
+    return true;
+  }
+
+  if (req.method === 'POST' && pathname === `${basePath}/sessions/${sessionId}/permission`) {
+    const body = await readBody(req);
+    if (!body || typeof body.requestId !== 'string') {
+      sendJson(res, 400, { ok: false, error: 'body.requestId is required' });
+      return true;
+    }
+    const result = runner.resolvePermission(sessionId, body.requestId, {
+      allow: body.allow === true,
+      message: typeof body.message === 'string' ? body.message : '',
+    });
+    sendJson(res, 200, { ok: true, sessionId, ...result });
+    return true;
+  }
+
+  if (req.method === 'POST' && pathname === `${basePath}/sessions/${sessionId}/abort`) {
+    runner.abort(sessionId);
+    sendJson(res, 200, { ok: true, sessionId });
+    return true;
+  }
+
+  sendJson(res, 404, { ok: false, error: 'unknown Claude route' });
+  return true;
+}
+
+module.exports = {
+  handleClaudeRoutes,
+};

package/src/backend/http/node-helpers.js

@@ -0,0 +1,45 @@
+function sendJson(res, status, payload) {
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store',
+  });
+  res.end(JSON.stringify(payload));
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', chunk => chunks.push(chunk));
+    req.on('end', () => {
+      if (!chunks.length) return resolve({});
+      const text = Buffer.concat(chunks).toString('utf8');
+      try {
+        resolve(JSON.parse(text));
+      } catch (error) {
+        reject(new Error(`invalid JSON body: ${error.message}`));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+function writeSseHeaders(res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-store, no-transform',
+    Connection: 'keep-alive',
+    'X-Accel-Buffering': 'no',
+  });
+}
+
+function writeSse(res, event, data) {
+  res.write(`event: ${event}\n`);
+  res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+
+module.exports = {
+  sendJson,
+  readBody,
+  writeSseHeaders,
+  writeSse,
+};

package/src/backend/index.js

@@ -0,0 +1,21 @@
+const runtimeConfig = require('./lib/runtime-config');
+
+module.exports = {
+  ...runtimeConfig,
+  dataDir: require('./lib/data-dir'),
+  aiWorkspace: require('./lib/ai-workspace'),
+  automationConfig: require('./lib/automation-config'),
+  modelContextWindows: require('./lib/model-context-windows'),
+  llmClient: require('./lib/llm-client'),
+  promptRegistry: require('./lib/prompt-registry'),
+  aiVendorPresets: require('./lib/ai-vendor-presets'),
+  aiAdapter: require('./lib/ai-adapter'),
+  aiProfiles: require('./lib/ai-profile-store'),
+  createRunner() {
+    return require('./lib/claude-cli-runner');
+  },
+  http: {
+    ...require('./http/claude-routes'),
+    ...require('./http/ai-profile-routes'),
+  },
+};

package/src/backend/lib/ai-adapter.js

@@ -0,0 +1,144 @@
+// AI analyzer adapter interface (TASK-005 + TASK-008).
+// Each adapter implements the same shape so the orchestrator can swap implementations.
+//
+//   analyzeCommitBatch({ project, commits, contextPack }) -> { changes: [...] }
+//   validateOutput(output) -> { valid: boolean, errors: string[] }
+//
+// All adapters MUST return objects that pass validateOutput. The orchestrator never
+// writes drafts to disk unless the output validates.
+
+const fs = require('fs');
+const path = require('path');
+
+function isString(v) { return typeof v === 'string'; }
+function isNonEmptyString(v) { return isString(v) && v.length > 0; }
+function isStringArray(v) { return Array.isArray(v) && v.every(isString); }
+function isObject(v) { return v && typeof v === 'object' && !Array.isArray(v); }
+
+function normalizeKnowledgeLanguage(value) {
+  return value === 'en-US' ? 'en-US' : 'zh-CN';
+}
+
+function languageName(value) {
+  return normalizeKnowledgeLanguage(value) === 'en-US' ? 'English' : 'Simplified Chinese';
+}
+
+const changeEntrySchema = {
+  commit: isNonEmptyString,
+  classification: (v) => ['new-feature', 'existing-feature-update', 'bug-fix', 'refactor', 'infrastructure', 'test-only', 'docs-only'].includes(v),
+  developmentIntent: isNonEmptyString,
+  goalImpact: isNonEmptyString,
+  evidence: isStringArray,
+  proposedOps: (v) => Array.isArray(v) && v.every(op => isObject(op) && isNonEmptyString(op.op) && isNonEmptyString(op.path)),
+};
+
+function validateCommitBatchOutput(output) {
+  const errors = [];
+  if (!isObject(output)) { errors.push('output is not an object'); return { valid: false, errors }; }
+  if (!Array.isArray(output.changes)) { errors.push('missing or invalid: changes'); return { valid: false, errors }; }
+  for (let i = 0; i < output.changes.length; i++) {
+    const c = output.changes[i];
+    if (!isObject(c)) { errors.push(`change[${i}] is not an object`); continue; }
+    for (const [key, check] of Object.entries(changeEntrySchema)) {
+      if (!(key in c)) { errors.push(`change[${i}] missing: ${key}`); continue; }
+      if (!check(c[key])) errors.push(`change[${i}].${key} is invalid`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// ---- claude-code-agent: real LLM via Anthropic-compatible API ----
+//
+// This adapter calls an Anthropic Messages API (real Anthropic or any
+// compatible proxy such as api.minimaxi.com/anthropic). The model returns
+// JSON that the KB orchestrator validates against the existing schemas.
+//
+// The adapter is intentionally minimal: it does ONE call per commit batch
+// and asks the model to return a strict JSON object matching the schema.
+// Validation happens in `validateOutput`; if the model misbehaves, the run
+// is marked failed and the user can re-trigger.
+
+const { completeJson } = require('./llm-client');
+
+const COMMIT_SYSTEM = `You are a senior software architect reviewing a batch of git commits. For each commit, decide what useful knowledge should be recorded in the project's knowledge base. Respond with a single JSON object matching the schema in the user message. Do not invent file paths. Cite the provided evidence (context pack entries) whenever possible. Summarize the user's development intent; do not preserve raw prompts. Do not propose operations that would write outside changes/, modules/, README.md, GOAL.md, or ARCHITECTURE.md.`;
+
+function buildCommitUser({ project, commits, contextPack }) {
+  const outputLanguage = languageName(project && project.knowledgeLanguage);
+  const ctx = (contextPack && contextPack.entries || []).slice(0, 30).map(e => `- ${e.path}: ${(e.summary || '').slice(0, 200)}`).join('\n');
+  const list = (commits || []).map(c => `- full=${c.hash} | short=${c.short || c.hash.slice(0,7)} | ${c.date || ''} | ${c.author || ''} | ${c.subject || ''}`).join('\n');
+  return `Project slug: ${project.slug}
+Knowledge output language: ${normalizeKnowledgeLanguage(project.knowledgeLanguage)} (${outputLanguage})
+
+Pending commits (chronological order, oldest first). For each line, the "full=" value is the COMPLETE 40-character commit hash; you MUST copy that exact value into the JSON "commit" field:
+${list || '(no commits)'}
+
+Context pack excerpts:
+${ctx || '(no context pack available)'}
+
+Return a JSON object of the form:
+{
+  "changes": [
+    {
+      "commit": string,                // FULL 40-char commit hash copied from the input
+      "classification": "new-feature" | "existing-feature-update" | "bug-fix" | "refactor" | "infrastructure" | "test-only" | "docs-only",
+      "developmentIntent": string,     // concise summary of the user's request or prompt intent; never raw prompt logs
+      "goalImpact": string,            // one short sentence
+      "evidence": [string],            // paths cited from the context pack
+      "proposedOps": [{ "op": "create-file" | "append-section" | "update-section", "path": string, "fromTemplate"?: string }]
+    }
+  ]
+}
+
+Constraints:
+- All human-readable natural language string values MUST be written in ${outputLanguage}. Keep JSON keys, enum values, file paths, and commit hashes exactly as specified.
+- One entry per commit in the input list, in the same order.
+- "commit" MUST be the full 40-character hash from the input (the value after "full="), NOT the short hash.
+- proposedOps[].path MUST be a relative path under changes/ or modules/, or exactly README.md, GOAL.md, or ARCHITECTURE.md. Goal and architecture edits require human review.
+- Do not include any text outside the JSON object.`;
+}
+
+const claudeCodeAgent = {
+  id: 'claude-code-agent',
+  name: 'Claude Code Agent (Anthropic-compatible)',
+  description: 'Real LLM through an Anthropic-compatible Messages API. AI profiles can reuse this implementation with different model providers.',
+  async analyzeCommitBatch({ project, commits, contextPack }) {
+    const user = buildCommitUser({ project, commits, contextPack });
+    const r = await completeJson({ system: COMMIT_SYSTEM, user, maxTokens: 4096, profileId: project && project.aiProfileId });
+    if (!r.parsed) {
+      console.error(`[claude-code-agent] LLM did not return valid JSON. text head: ${r.text.slice(0, 500)} ... text tail: ${r.text.slice(-500)}`);
+      const e = new Error(`LLM returned no parseable JSON (${r.parseError && r.parseError.message || 'no output'})`);
+      e.llmText = r.text;
+      throw e;
+    }
+    // Sanity log: how many changes did the LLM return, and what do the commits look like?
+    const changes = (r.parsed && r.parsed.changes) || [];
+    console.log(`[claude-code-agent] parsed ${changes.length} changes; first change: ${JSON.stringify(changes[0]).slice(0, 300)}`);
+    return r.parsed;
+  },
+  validateOutput(output) {
+    return validateCommitBatchOutput(output);
+  },
+};
+
+const ADAPTERS = {
+  'claude-code-agent': claudeCodeAgent,
+};
+
+function getAdapter(id) {
+  return ADAPTERS[id] || null;
+}
+
+function listAdapters() {
+  return Object.values(ADAPTERS).map(a => ({
+    id: a.id,
+    name: a.name,
+    description: a.description || null,
+  }));
+}
+
+module.exports = {
+  ADAPTERS,
+  getAdapter,
+  listAdapters,
+  validateCommitBatchOutput,
+};