@sanqianx/claude-ai-workbench 0.11.0

package/src/backend/lib/data-dir.js

@@ -0,0 +1,169 @@
+// _site/lib/data-dir.js
+//
+// Resolves a stable, version-independent data directory for project-knowledge
+// runtime state. Runtime data lives OUTSIDE the npm install directory so that
+// `npm install -g project-knowledge` upgrades do not destroy user config
+// (project registry, AI profiles with API keys, generated knowledge bases,
+// logs, AI workspaces).
+//
+// Resolution order (highest priority first):
+//   1. KB_DATA_DIR env var — used by tests and power users who want a custom
+//      location. Set to "." to use the current working directory.
+//   2. <os.homedir()>/.project-knowledge — the default user-specific location.
+//
+// On first run after upgrade from a 1.x install, the legacy runtime files
+// (which lived inside the npm package directory) are silently migrated into
+// the new data dir. After that, all updates keep the data dir untouched and
+// data survives every future `npm install -g project-knowledge`.
+
+const fs = require('fs');
+const path = require('path');
+const { resolveDataDir } = require('./runtime-config');
+
+let _resolved = null;
+
+function getDataDir() {
+  const dataDir = resolveDataDir();
+  if (_resolved === dataDir) return _resolved;
+  try {
+    fs.mkdirSync(dataDir, { recursive: true });
+  } catch (err) {
+    // Best-effort. Callers will surface a write error when they actually
+    // try to write inside the dir; we don't want to crash here just because
+    // the user's homedir is read-only or the path is bogus.
+  }
+  _resolved = dataDir;
+  return dataDir;
+}
+
+// Reset the cached resolution. Tests use this to switch KB_DATA_DIR between
+// cases without re-requiring the module.
+function _resetCache() {
+  _resolved = null;
+}
+
+function hasMigrated() {
+  return fs.existsSync(path.join(getDataDir(), 'projects.json'));
+}
+
+// Legacy 1.x locations — these lived inside the npm package root. The
+// package root for an installed package is the directory that contains
+// _site/server.js, _site/lib/, package.json, etc.
+const LEGACY_FILE_PATHS = [
+  'projects.json',
+  'ai-profiles.json',
+  'knowledge-store.json',
+  'logging.json',
+  '.jobs-log.json',
+  'claude-prompts.json',
+  '.hook-trigger-errors.log',
+];
+
+const LEGACY_DIR_PATHS = [
+  'projects',  // generated KB trees
+  'logs',      // structured logs
+];
+
+const LEGACY_AI_DIR = path.join('_site', '_ai');  // per-project AI workspaces lived under _site/_ai/
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const from = path.join(src, entry.name);
+    const to = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(from, to);
+    else if (entry.isFile()) fs.copyFileSync(from, to);
+  }
+}
+
+function migrateFromLegacy({ legacyRoot, logger } = {}) {
+  // Test escape hatch. Set KB_SKIP_MIGRATION=1 to run against a clean data
+  // dir without pulling the user's real registry in from the package root.
+  if (process.env.KB_SKIP_MIGRATION === '1') {
+    return { ok: true, migrated: false, reason: 'skipped via KB_SKIP_MIGRATION=1' };
+  }
+  if (!legacyRoot) {
+    return { ok: true, migrated: false, reason: 'no legacy root provided' };
+  }
+  if (!fs.existsSync(legacyRoot)) {
+    return { ok: true, migrated: false, reason: 'legacy root does not exist' };
+  }
+  const dataDir = getDataDir();
+  // Safety check: if the legacy root equals the data dir, there's nothing
+  // to migrate (we'd be copying onto ourselves).
+  if (path.resolve(legacyRoot) === path.resolve(dataDir)) {
+    return { ok: true, migrated: false, reason: 'legacy root equals data dir' };
+  }
+  if (hasMigrated()) {
+    return { ok: true, migrated: false, reason: 'already migrated' };
+  }
+
+  const result = {
+    ok: true,
+    migrated: false,
+    files: 0,
+    dirs: 0,
+    source: legacyRoot,
+    target: dataDir,
+  };
+
+  for (const rel of LEGACY_FILE_PATHS) {
+    const from = path.join(legacyRoot, rel);
+    const to = path.join(dataDir, rel);
+    if (fs.existsSync(from) && !fs.existsSync(to)) {
+      try {
+        fs.mkdirSync(path.dirname(to), { recursive: true });
+        fs.copyFileSync(from, to);
+        result.files++;
+      } catch (err) {
+        result.ok = false;
+        result.error = `failed to migrate ${rel}: ${err.message}`;
+        return result;
+      }
+    }
+  }
+  for (const rel of LEGACY_DIR_PATHS) {
+    const from = path.join(legacyRoot, rel);
+    const to = path.join(dataDir, rel);
+    if (fs.existsSync(from) && !fs.existsSync(to)) {
+      try {
+        copyDir(from, to);
+        result.dirs++;
+      } catch (err) {
+        result.ok = false;
+        result.error = `failed to migrate ${rel}/: ${err.message}`;
+        return result;
+      }
+    }
+  }
+  const aiFrom = path.join(legacyRoot, LEGACY_AI_DIR);
+  const aiTo = path.join(dataDir, '_ai');
+  if (fs.existsSync(aiFrom) && !fs.existsSync(aiTo)) {
+    try {
+      copyDir(aiFrom, aiTo);
+      result.dirs++;
+    } catch (err) {
+      result.ok = false;
+      result.error = `failed to migrate _site/_ai/: ${err.message}`;
+      return result;
+    }
+  }
+
+  if (result.files > 0 || result.dirs > 0) {
+    result.migrated = true;
+    if (logger) {
+      logger(`migrated runtime data to ${dataDir} (${result.files} files, ${result.dirs} dirs from ${legacyRoot})`);
+    }
+  }
+  return result;
+}
+
+module.exports = {
+  getDataDir,
+  hasMigrated,
+  migrateFromLegacy,
+  LEGACY_FILE_PATHS,
+  LEGACY_DIR_PATHS,
+  LEGACY_AI_DIR,
+  _resetCache,
+};

package/src/backend/lib/llm-client.js

@@ -0,0 +1,176 @@
+// _site/lib/llm-client.js
+//
+// Tiny Anthropic Messages API client. Zero npm deps; supports HTTPS and HTTP
+// Anthropic-compatible endpoints. Connection settings are resolved from an AI
+// profile first, then environment variables as fallback:
+//
+//   profile.baseUrl       or ANTHROPIC_BASE_URL
+//   profile.apiKey        or ANTHROPIC_AUTH_TOKEN
+//   profile.mainModel     or ANTHROPIC_MODEL
+//   profile.timeoutMs     or API_TIMEOUT_MS
+//
+// This lets the local UI persist model settings in ai-profiles.json while still
+// keeping env vars useful for scripts and temporary overrides.
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+const DEFAULT_BASE = 'https://api.anthropic.com';
+const DEFAULT_VERSION = '2023-06-01';
+const DEFAULT_MODEL = 'claude-haiku-4-5';
+const { getDataDir } = require('./data-dir');
+
+function aiProfilesPath() {
+  return path.join(getDataDir(), 'ai-profiles.json');
+}
+
+function readProfilesFile() {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(aiProfilesPath(), 'utf-8'));
+    return Array.isArray(cfg.profiles) ? cfg.profiles : [];
+  } catch {
+    return [];
+  }
+}
+
+function findProfile(profileId) {
+  if (!profileId) return null;
+  return readProfilesFile().find(profile => profile && profile.id === profileId) || null;
+}
+
+function readConfig(options = {}) {
+  const profileId = typeof options === 'string' ? options : options.profileId;
+  const inlineProfile = options && typeof options === 'object' && options.profile && typeof options.profile === 'object'
+    ? options.profile
+    : null;
+  const profile = inlineProfile || findProfile(profileId) || {};
+  const timeoutMs = Number(profile.timeoutMs || process.env.API_TIMEOUT_MS || 60_000);
+  return {
+    profileId: profile.id || profileId || null,
+    baseUrl: profile.baseUrl || profile.apiBaseUrl || profile.anthropicBaseUrl || process.env.ANTHROPIC_BASE_URL || DEFAULT_BASE,
+    apiKey: profile.apiKey || profile.authToken || profile.anthropicAuthToken || process.env.ANTHROPIC_AUTH_TOKEN || '',
+    model: profile.mainModel || profile.model || process.env.ANTHROPIC_MODEL || DEFAULT_MODEL,
+    version: DEFAULT_VERSION,
+    timeoutMs: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 60_000,
+  };
+}
+
+function buildRequestPath(base, p) {
+  if (!p.startsWith('/')) return p;
+  const basePath = base.pathname.endsWith('/') ? base.pathname.slice(0, -1) : base.pathname;
+  return basePath + p;
+}
+
+function postJson({ baseUrl, path: p, body, apiKey, version, timeoutMs = 60_000 }) {
+  return new Promise((resolve, reject) => {
+    try {
+      const base = new URL(baseUrl);
+      const transport = base.protocol === 'http:' ? http : https;
+      const data = JSON.stringify(body);
+      const req = transport.request({
+        host: base.hostname,
+        port: base.port || (base.protocol === 'http:' ? 80 : 443),
+        path: buildRequestPath(base, p),
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': apiKey,
+          'anthropic-version': version,
+          'Content-Length': Buffer.byteLength(data),
+        },
+        timeout: timeoutMs,
+      }, res => {
+        const chunks = [];
+        res.on('data', c => chunks.push(c));
+        res.on('end', () => {
+          const text = Buffer.concat(chunks).toString('utf-8');
+          if (res.statusCode < 200 || res.statusCode >= 300) {
+            return reject(new Error(`HTTP ${res.statusCode}: ${text.slice(0, 500)}`));
+          }
+          try { resolve(JSON.parse(text)); }
+          catch (e) { reject(new Error(`bad JSON: ${e.message}; body head: ${text.slice(0, 200)}`)); }
+        });
+      });
+      req.on('error', reject);
+      req.on('timeout', () => req.destroy(new Error(`timeout after ${timeoutMs}ms`)));
+      req.write(data);
+      req.end();
+    } catch (e) {
+      reject(new Error(`bad baseUrl: ${baseUrl}: ${e.message}`));
+    }
+  });
+}
+
+async function completeText({ system, user, maxTokens = 512, model, profileId, profile }) {
+  const cfg = readConfig({ profileId, profile });
+  if (!cfg.apiKey) {
+    const id = profileId ? ` for profile ${profileId}` : '';
+    throw new Error(`API key not set${id}`);
+  }
+  const body = {
+    model: model || cfg.model,
+    max_tokens: maxTokens,
+    messages: [{ role: 'user', content: user }],
+  };
+  if (system) body.system = system;
+
+  const raw = await postJson({
+    baseUrl: cfg.baseUrl,
+    path: '/v1/messages',
+    body,
+    apiKey: cfg.apiKey,
+    version: cfg.version,
+    timeoutMs: cfg.timeoutMs,
+  });
+
+  const text = (raw.content || [])
+    .filter(block => block && block.type === 'text' && typeof block.text === 'string')
+    .map(block => block.text)
+    .join('\n')
+    .trim();
+
+  return {
+    text,
+    raw,
+    usage: raw.usage || null,
+    model: raw.model || body.model,
+    profileId: cfg.profileId,
+  };
+}
+
+async function completeJson({ system, user, schema, maxTokens = 2048, model, profileId, profile }) {
+  const schemaHint = schema ? `\n\nThe output MUST be a JSON object matching this schema:\n${schema}\n` : '';
+  const finalUser = `${user}${schemaHint}\n\nRespond with ONLY the JSON object, no prose, no markdown fences.`;
+  const result = await completeText({ system, user: finalUser, maxTokens, model, profileId, profile });
+  const text = result.text;
+
+  let parsed = null;
+  let parseError = null;
+  const candidates = [
+    text,
+    text.replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/, ''),
+  ];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      parsed = JSON.parse(candidate);
+      parseError = null;
+      break;
+    } catch (e) {
+      parseError = e;
+    }
+  }
+
+  return { ...result, parsed, parseError };
+}
+
+module.exports = {
+  completeJson,
+  completeText,
+  readConfig,
+  findProfile,
+  aiProfilesPath,
+};

package/src/backend/lib/model-context-windows.js

@@ -0,0 +1,82 @@
+// Per-family context window sizes (in tokens) for common models.
+// Match strategy: lowercase the model name, then prefix-match — first hit wins.
+// Entry order matters: more specific prefixes (e.g. 'claude-opus-4') precede
+// broader ones (e.g. 'claude'). Keep specific entries above generic ones.
+const MODEL_CONTEXT_WINDOWS = [
+  // Anthropic Claude — full family 200K
+  ['claude-opus-4', 200000],
+  ['claude-sonnet-4', 200000],
+  ['claude-haiku-4', 200000],
+  ['claude-3-7', 200000],
+  ['claude-3-5', 200000],
+  ['claude-3', 200000],
+  ['claude', 200000],
+
+  // MiniMax
+  ['minimax-m3', 1048576],
+  ['minimax-m2', 1048576],
+  ['minimax', 1048576],
+
+  // Zhipu GLM
+  ['glm-5', 1048576],
+  ['glm-4.6', 1048576],
+  ['glm-4.5', 128000],
+  ['glm-4-plus', 128000],
+  ['glm-4', 128000],
+  ['glm', 128000],
+
+  // DeepSeek
+  ['deepseek-v3', 128000],
+  ['deepseek-r1', 128000],
+  ['deepseek', 64000],
+
+  // OpenAI
+  ['gpt-5', 200000],
+  ['gpt-4.1', 1047576],
+  ['gpt-4o', 128000],
+  ['gpt-4-turbo', 128000],
+  ['gpt-4', 8192],
+  ['o3', 200000],
+  ['o4-mini', 200000],
+  ['o1', 200000],
+
+  // Qwen
+  ['qwen3', 131072],
+  ['qwen-max', 32768],
+  ['qwen', 32768],
+
+  // Google Gemini
+  ['gemini-2.5', 1048576],
+  ['gemini-1.5', 1048576],
+  ['gemini', 32768],
+];
+
+function normalizeModelName(model) {
+  return String(model || '').trim().toLowerCase();
+}
+
+function lookupContextWindow(modelName) {
+  const name = normalizeModelName(modelName);
+  if (!name) return null;
+  for (const [prefix, size] of MODEL_CONTEXT_WINDOWS) {
+    if (name.startsWith(prefix)) return size;
+  }
+  return null;
+}
+
+// Resolution order: explicit profile override → model table → env var → fallback.
+function resolveContextWindow({ profileContextWindow, model, env = process.env, fallback = 200000 } = {}) {
+  const explicit = Number(profileContextWindow);
+  if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
+  const tableHit = lookupContextWindow(model);
+  if (tableHit) return tableHit;
+  const envValue = Number(env && env.CLAUDE_CONTEXT_WINDOW);
+  if (Number.isFinite(envValue) && envValue > 0) return Math.floor(envValue);
+  return fallback;
+}
+
+module.exports = {
+  MODEL_CONTEXT_WINDOWS,
+  lookupContextWindow,
+  resolveContextWindow,
+};

package/src/backend/lib/prompt-registry.js

@@ -0,0 +1,166 @@
+// Prompt Registry — reads/writes claude-prompts.json and renders templated prompts.
+//
+// File location: <KB_ROOT>/claude-prompts.json
+// Schema: { schema: 'claude-prompts/v1', prompts: { <key>: { description, model, permissionMode,
+//            allowedTools, systemPrompt, userPrompt } } }
+//
+// Variable interpolation: {{KEY}} placeholders in systemPrompt/userPrompt are replaced
+// with values from the `vars` argument. Unknown placeholders are left untouched (so
+// incomplete prompts don't crash — they show the raw token for diagnosis).
+
+const fs = require('fs');
+const path = require('path');
+
+const { getDataDir } = require('./data-dir');
+const { getWorkbenchConfig } = require('./runtime-config');
+const SCHEMA = 'claude-prompts/v1';
+
+const PLACEHOLDER_RE = /\{\{\s*([A-Z_][A-Z0-9_]*)\s*\}\}/g;
+
+function normalizePromptsConfig(cfg) {
+  const normalized = cfg && typeof cfg === 'object' ? cfg : {};
+  if (!normalized.prompts || typeof normalized.prompts !== 'object') normalized.prompts = {};
+  if (!normalized.schema) normalized.schema = SCHEMA;
+  return normalized;
+}
+
+function promptsPath() {
+  const cfg = getWorkbenchConfig();
+  return path.join(getDataDir(), cfg.promptsFileName || 'claude-prompts.json');
+}
+
+function bundledPromptsPath() {
+  const cfg = getWorkbenchConfig();
+  return cfg.bundledPromptsPath || path.resolve(__dirname, '..', '..', 'assets', 'claude-prompts.json');
+}
+
+function readBundledPrompts() {
+  const file = bundledPromptsPath();
+  if (!fs.existsSync(file)) return { schema: SCHEMA, prompts: {} };
+  try {
+    return normalizePromptsConfig(JSON.parse(fs.readFileSync(file, 'utf-8')));
+  } catch {
+    return { schema: SCHEMA, prompts: {} };
+  }
+}
+
+function persistPrompts(cfg) {
+  const file = promptsPath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+}
+
+function withBundledDefaults(cfg) {
+  const current = normalizePromptsConfig(cfg);
+  const bundled = readBundledPrompts();
+  let changed = false;
+  const prompts = { ...current.prompts };
+  for (const [key, prompt] of Object.entries(bundled.prompts || {})) {
+    if (!Object.prototype.hasOwnProperty.call(prompts, key)) {
+      prompts[key] = prompt;
+      changed = true;
+    }
+  }
+  return {
+    cfg: {
+      schema: current.schema || bundled.schema || SCHEMA,
+      prompts,
+    },
+    changed,
+  };
+}
+
+function readPrompts() {
+  const file = promptsPath();
+  if (!fs.existsSync(file)) {
+    const seeded = withBundledDefaults({ schema: SCHEMA, prompts: {} }).cfg;
+    if (Object.keys(seeded.prompts).length) {
+      persistPrompts(seeded);
+    }
+    return seeded;
+  }
+  try {
+    const result = withBundledDefaults(JSON.parse(fs.readFileSync(file, 'utf-8')));
+    if (result.changed) persistPrompts(result.cfg);
+    return result.cfg;
+  } catch (e) {
+    throw new Error(`failed to parse ${file}: ${e.message}`);
+  }
+}
+
+function writePrompts(cfg) {
+  if (!cfg || typeof cfg !== 'object') throw new Error('prompts config must be an object');
+  if (cfg.prompts && typeof cfg.prompts !== 'object') throw new Error('prompts field must be an object');
+  const normalized = {
+    schema: cfg.schema || SCHEMA,
+    prompts: cfg.prompts || {},
+  };
+  for (const [key, val] of Object.entries(normalized.prompts)) {
+    if (!key || typeof key !== 'string') throw new Error(`invalid prompt key: ${key}`);
+    if (!val || typeof val !== 'object') throw new Error(`prompt "${key}" must be an object`);
+    if (typeof val.userPrompt !== 'string' || !val.userPrompt) {
+      throw new Error(`prompt "${key}" must have a non-empty userPrompt`);
+    }
+  }
+  persistPrompts(normalized);
+  return normalized;
+}
+
+function listPromptKeys() {
+  return Object.keys(readPrompts().prompts);
+}
+
+function getPrompt(key) {
+  const cfg = readPrompts();
+  const p = cfg.prompts[key];
+  if (!p) return null;
+  return p;
+}
+
+function interpolate(text, vars) {
+  if (typeof text !== 'string') return text;
+  if (!vars || typeof vars !== 'object') return text;
+  return text.replace(PLACEHOLDER_RE, (_, name) => {
+    if (Object.prototype.hasOwnProperty.call(vars, name)) {
+      const v = vars[name];
+      return v == null ? '' : String(v);
+    }
+    return `{{${name}}}`;
+  });
+}
+
+// Render the prompt for a given key, returning all fields needed to spawn claude.
+// Returns null if key doesn't exist.
+function renderPrompt(key, vars) {
+  const p = getPrompt(key);
+  if (!p) return null;
+  const safeVars = vars || {};
+  return {
+    key,
+    description: p.description || '',
+    model: p.model || 'sonnet',
+    permissionMode: p.permissionMode || 'bypassPermissions',
+    allowedTools: Array.isArray(p.allowedTools) ? p.allowedTools.slice() : ['Read', 'Grep', 'Glob'],
+    systemPrompt: interpolate(p.systemPrompt || '', safeVars),
+    userPrompt: interpolate(p.userPrompt, safeVars),
+  };
+}
+
+const exported = {
+  promptsPath,
+  bundledPromptsPath,
+  SCHEMA,
+  readPrompts,
+  writePrompts,
+  listPromptKeys,
+  getPrompt,
+  renderPrompt,
+  interpolate,
+};
+
+Object.defineProperties(exported, {
+  PROMPTS_PATH: { enumerable: true, get: promptsPath },
+  BUNDLED_PROMPTS_PATH: { enumerable: true, get: bundledPromptsPath },
+});
+
+module.exports = exported;