project-knowledge 0.1.0 → 1.0.1

package/_site/lib/kb-validator.js

@@ -37,6 +37,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { isV3Kb, V3_TOP_LEVEL } = require('./kb-v3');
 
 const MANIFEST_SCHEMA = 'kb-manifest/v1';
 const REQUIRED_DRAFT_AREAS = ['_ai/drafts/', '_ai/runs/', '_ai/context-packs/'];
@@ -57,6 +58,65 @@ function isInsideDraftArea(rel) {
   return norm === '_ai' || norm.startsWith('_ai/');
 }
 
+function walkTrustedFiles(root, dir = root, prefix = '') {
+  const out = [];
+  let entries = [];
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.name.startsWith('.')) continue;
+    if (entry.name === '_ai' || entry.name === '_meta' || entry.name === 'node_modules') continue;
+    const rel = (prefix ? `${prefix}/` : '') + entry.name;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walkTrustedFiles(root, full, rel));
+    else if (entry.isFile() && entry.name.endsWith('.md')) {
+      out.push({ path: rel, content: fs.readFileSync(full, 'utf-8'), size: fs.statSync(full).size });
+    }
+  }
+  return out;
+}
+
+function validateV3Kb(kbPath, info) {
+  const errors = [];
+  const warnings = [];
+  const required = [
+    ['README.md', 'file'],
+    ['GOAL.md', 'file'],
+    ['ARCHITECTURE.md', 'file'],
+    ['modules', 'dir'],
+    ['changes', 'dir'],
+    ['modules/00-index.md', 'file'],
+    ['changes/00-index.md', 'file'],
+  ];
+  for (const [rel, kind] of required) {
+    const abs = path.join(kbPath, rel);
+    if (!fs.existsSync(abs)) {
+      errors.push(`${rel} missing`);
+      continue;
+    }
+    const stat = fs.statSync(abs);
+    if (kind === 'file' && !stat.isFile()) errors.push(`${rel} must be a file`);
+    if (kind === 'dir' && !stat.isDirectory()) errors.push(`${rel} must be a directory`);
+  }
+  const top = fs.readdirSync(kbPath).filter(name => !name.startsWith('.')).sort();
+  const unexpected = top.filter(name => !V3_TOP_LEVEL.includes(name));
+  if (unexpected.length) errors.push(`unexpected top-level KB v3 items: ${unexpected.join(', ')}`);
+  if (fs.existsSync(path.join(kbPath, '_ai'))) errors.push('_ai must not live inside a KB v3 directory');
+  if (fs.existsSync(path.join(kbPath, 'kb-manifest.json'))) errors.push('kb-manifest.json must not exist in KB v3');
+  info.schemaVersion = 'v3';
+  info.manifestExists = false;
+  info.goalStatus = fs.existsSync(path.join(kbPath, 'GOAL.md')) ? 'accepted-or-draft' : 'missing';
+  info.analysisStatus = fs.existsSync(path.join(kbPath, 'ARCHITECTURE.md')) ? 'present' : 'missing';
+  info.trustedKnowledgeEntries = walkTrustedFiles(kbPath).length;
+  return {
+    ok: errors.length === 0,
+    status: errors.length ? 422 : 200,
+    info,
+    errors,
+    warnings,
+    manifest: null,
+  };
+}
+
 function validateKb(kbPath) {
   const errors = [];
   const warnings = [];
@@ -77,6 +137,10 @@ function validateKb(kbPath) {
     return { ok: false, status: 400, error: `kbPath is not a directory: ${kbPath}` };
   }
 
+  if (isV3Kb(kbPath)) {
+    return validateV3Kb(kbPath, info);
+  }
+
   const manifestPath = path.join(kbPath, 'kb-manifest.json');
   if (!fs.existsSync(manifestPath)) {
     return { ok: false, status: 422, error: 'kb-manifest.json missing', info, errors: ['manifest missing'] };
@@ -186,6 +250,25 @@ function buildPrContextPack(kbPath) {
   const v = validateKb(kbPath);
   if (!v.ok) return { ok: false, status: v.status || 422, error: 'kb invalid', validation: v };
   const manifest = v.manifest;
+  if (v.info && v.info.schemaVersion === 'v3') {
+    const files = walkTrustedFiles(kbPath);
+    const readFile = rel => files.find(item => item.path === rel) || null;
+    return {
+      ok: true,
+      pack: {
+        schema: 'pr-context-pack/v1',
+        generatedAt: new Date().toISOString(),
+        project: path.basename(kbPath),
+        goal: readFile('GOAL.md'),
+        analysis: readFile('ARCHITECTURE.md'),
+        indexes: {
+          modules: readFile('modules/00-index.md'),
+          changes: readFile('changes/00-index.md'),
+        },
+        trustedKnowledge: files,
+      },
+    };
+  }
   const read = rel => {
     if (!rel || !existsAny(kbPath, rel)) return null;
     const abs = path.resolve(kbPath, rel);
@@ -221,4 +304,5 @@ module.exports = {
   REQUIRED_DRAFT_AREAS,
   validateKb,
   buildPrContextPack,
+  walkTrustedFiles,
 };

package/_site/lib/knowledge-store.js

@@ -0,0 +1,141 @@
+const fs = require('fs');
+const path = require('path');
+
+const SCHEMA = 'knowledge-store/v1';
+
+function defaultConfig(appRoot) {
+  return {
+    schema: SCHEMA,
+    rootPath: path.join(appRoot, 'projects'),
+    git: {
+      enabled: false,
+      remoteUrl: '',
+      branch: 'main',
+      autoCommit: false,
+      autoPush: false,
+    },
+    configured: false,
+  };
+}
+
+function normalizeConfig(input, appRoot) {
+  const base = defaultConfig(appRoot);
+  const source = input && typeof input === 'object' ? input : {};
+  const git = source.git && typeof source.git === 'object' ? source.git : {};
+  return {
+    schema: SCHEMA,
+    rootPath: path.resolve(source.rootPath || base.rootPath),
+    git: {
+      enabled: git.enabled === true,
+      remoteUrl: typeof git.remoteUrl === 'string' ? git.remoteUrl : '',
+      branch: typeof git.branch === 'string' && git.branch.trim() ? git.branch.trim() : 'main',
+      autoCommit: git.autoCommit === true,
+      autoPush: git.autoPush === true,
+    },
+    configured: source.configured === true,
+  };
+}
+
+function readConfig(configPath, appRoot) {
+  if (!fs.existsSync(configPath)) return defaultConfig(appRoot);
+  try {
+    return normalizeConfig(JSON.parse(fs.readFileSync(configPath, 'utf-8')), appRoot);
+  } catch {
+    return defaultConfig(appRoot);
+  }
+}
+
+function writeConfig(configPath, appRoot, config) {
+  const normalized = normalizeConfig({ ...config, configured: true }, appRoot);
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(normalized, null, 2) + '\n', 'utf-8');
+  return normalized;
+}
+
+function validateRoot(rootPath) {
+  if (!rootPath || typeof rootPath !== 'string') {
+    return { ok: false, error: 'rootPath is required' };
+  }
+  const resolved = path.resolve(rootPath);
+  try {
+    fs.mkdirSync(resolved, { recursive: true });
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) return { ok: false, rootPath: resolved, error: 'rootPath is not a directory' };
+    return { ok: true, rootPath: resolved };
+  } catch (e) {
+    return { ok: false, rootPath: resolved, error: e.message };
+  }
+}
+
+function defaultProjectKbPath(slug, configPath, appRoot) {
+  const cfg = readConfig(configPath, appRoot);
+  return path.join(cfg.rootPath, slug);
+}
+
+function isInside(child, parent) {
+  const rel = path.relative(path.resolve(parent), path.resolve(child));
+  return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+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 buildMigrationPlan({ projects, appRoot, storeConfig }) {
+  const legacyRoot = path.join(appRoot, 'projects');
+  const items = [];
+  for (const [slug, cfg] of Object.entries(projects || {})) {
+    const current = path.resolve(cfg.kbPath || path.join(legacyRoot, slug));
+    if (!isInside(current, legacyRoot)) continue;
+    const target = path.join(storeConfig.rootPath, slug);
+    if (path.resolve(current) === path.resolve(target)) continue;
+    items.push({
+      slug,
+      from: current,
+      to: target,
+      exists: fs.existsSync(current),
+      targetExists: fs.existsSync(target),
+    });
+  }
+  return items;
+}
+
+function migrateProjects({ projects, appRoot, storeConfig, overwrite = false, move = false }) {
+  const plan = buildMigrationPlan({ projects, appRoot, storeConfig });
+  const migrated = [];
+  for (const item of plan) {
+    if (!item.exists) {
+      projects[item.slug].kbPath = item.to;
+      migrated.push({ ...item, copied: false, reason: 'source missing; path updated only' });
+      continue;
+    }
+    if (item.targetExists && !overwrite) {
+      migrated.push({ ...item, copied: false, skipped: true, reason: 'target exists' });
+      continue;
+    }
+    if (item.targetExists && overwrite) fs.rmSync(item.to, { recursive: true, force: true });
+    copyDir(item.from, item.to);
+    if (move) fs.rmSync(item.from, { recursive: true, force: true });
+    projects[item.slug].kbPath = item.to;
+    migrated.push({ ...item, copied: true, moved: !!move });
+  }
+  return { plan, migrated };
+}
+
+module.exports = {
+  SCHEMA,
+  defaultConfig,
+  readConfig,
+  writeConfig,
+  validateRoot,
+  defaultProjectKbPath,
+  buildMigrationPlan,
+  migrateProjects,
+  isInside,
+};

package/_site/lib/llm-client.js

@@ -1,56 +1,76 @@
 // _site/lib/llm-client.js
 //
-// Tiny Anthropic Messages API client. Zero npm deps; uses node:https.
-// Reads connection settings from env (so the same adapter works against
-// the real Anthropic API, the system-level proxy at api.minimaxi.com,
-// or any other Anthropic-compatible endpoint):
+// 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:
 //
-//   ANTHROPIC_BASE_URL   default "https://api.anthropic.com"
-//   ANTHROPIC_AUTH_TOKEN required
-//   ANTHROPIC_MODEL      default "claude-haiku-4-5"
-//   ANTHROPIC_VERSION    default "2023-06-01"
+//   profile.baseUrl       or ANTHROPIC_BASE_URL
+//   profile.apiKey        or ANTHROPIC_AUTH_TOKEN
+//   profile.model         or ANTHROPIC_MODEL
+//   profile.version       or ANTHROPIC_VERSION
+//   profile.timeoutMs     or API_TIMEOUT_MS
 //
-// The client returns { text, usage, raw }. Callers are responsible for
-// parsing the model output (usually as JSON) and for any retries.
+// 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 AI_PROFILES_PATH = path.resolve(__dirname, '..', '..', 'ai-profiles.json');
 
-function readConfig() {
+function readProfilesFile() {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(AI_PROFILES_PATH, '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 profile = findProfile(profileId) || {};
+  const apiKeyFromEnvName = profile.apiKeyEnv ? process.env[profile.apiKeyEnv] : '';
+  const timeoutMs = Number(profile.timeoutMs || process.env.API_TIMEOUT_MS || 60_000);
   return {
-    baseUrl: process.env.ANTHROPIC_BASE_URL || DEFAULT_BASE,
-    apiKey: process.env.ANTHROPIC_AUTH_TOKEN || '',
-    model: process.env.ANTHROPIC_MODEL || DEFAULT_MODEL,
-    version: process.env.ANTHROPIC_VERSION || DEFAULT_VERSION,
+    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 || apiKeyFromEnvName || process.env.ANTHROPIC_AUTH_TOKEN || '',
+    model: profile.model || process.env.ANTHROPIC_MODEL || DEFAULT_MODEL,
+    version: profile.version || profile.anthropicVersion || process.env.ANTHROPIC_VERSION || DEFAULT_VERSION,
+    temperature: profile.temperature,
+    maxTokens: profile.maxTokens,
+    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) => {
-    let url;
     try {
-      // Allow baseUrl to contain a path prefix (e.g. "https://api.x.com/anthropic").
-      // We resolve `p` relative to that base, but the result must be treated
-      // as the final URL — no further prefix insertion.
       const base = new URL(baseUrl);
-      // base.pathname is already a valid path; we replace naively if p starts with /
-      let fullPath;
-      if (p.startsWith('/')) {
-        // Strip a trailing slash from base.pathname, then concatenate.
-        const basePath = base.pathname.endsWith('/') ? base.pathname.slice(0, -1) : base.pathname;
-        fullPath = basePath + p;
-      } else {
-        fullPath = p;
-      }
+      const transport = base.protocol === 'http:' ? http : https;
       const data = JSON.stringify(body);
-      const req = https.request({
-        host: base.host,
-        port: base.port || 443,
-        path: fullPath,
+      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',
@@ -75,52 +95,79 @@ function postJson({ baseUrl, path: p, body, apiKey, version, timeoutMs = 60_000
       req.on('timeout', () => req.destroy(new Error(`timeout after ${timeoutMs}ms`)));
       req.write(data);
       req.end();
-    } catch (e) { return reject(new Error(`bad baseUrl: ${baseUrl}: ${e.message}`)); }
+    } catch (e) {
+      reject(new Error(`bad baseUrl: ${baseUrl}: ${e.message}`));
+    }
   });
 }
 
-async function completeJson({ system, user, schema, maxTokens = 2048, temperature = 0.2, model }) {
-  const cfg = readConfig();
-  if (!cfg.apiKey) throw new Error('ANTHROPIC_AUTH_TOKEN not set');
-  const useModel = model || cfg.model;
-  // Wrap the user content in a directive that asks for strict JSON. The
-  // adapter is also told the schema; it must return JSON that the KB
-  // orchestrator's validateOutput can check.
-  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 messages = [{ role: 'user', content: finalUser }];
+async function completeText({ system, user, maxTokens = 512, temperature = 0.2, model, profileId }) {
+  const cfg = readConfig({ profileId });
+  if (!cfg.apiKey) {
+    const id = profileId ? ` for profile ${profileId}` : '';
+    throw new Error(`API key not set${id}`);
+  }
   const body = {
-    model: useModel,
-    max_tokens: maxTokens,
-    temperature,
-    messages,
+    model: model || cfg.model,
+    max_tokens: maxTokens || cfg.maxTokens || 512,
+    temperature: temperature != null ? temperature : (cfg.temperature != null ? cfg.temperature : 0.2),
+    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,
   });
-  // The Messages API returns content as an array of blocks; we expect one text block.
+
   const text = (raw.content || [])
-    .filter(b => b && b.type === 'text' && typeof b.text === 'string')
-    .map(b => b.text)
+    .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, temperature = 0.2, model, profileId }) {
+  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, temperature, model, profileId });
+  const text = result.text;
+
   let parsed = null;
   let parseError = null;
-  // First try direct parse; if that fails, strip a leading ```json fence.
   const candidates = [
     text,
     text.replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/, ''),
   ];
-  for (const c of candidates) {
-    if (!c) continue;
-    try { parsed = JSON.parse(c); parseError = null; break; } catch (e) { parseError = e; }
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      parsed = JSON.parse(candidate);
+      parseError = null;
+      break;
+    } catch (e) {
+      parseError = e;
+    }
   }
-  return { text, parsed, parseError, raw };
+
+  return { ...result, parsed, parseError };
 }
 
-module.exports = { completeJson, readConfig };
+module.exports = {
+  completeJson,
+  completeText,
+  readConfig,
+  findProfile,
+};

package/_site/lib/prompt-registry.js

@@ -0,0 +1,102 @@
+// 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 KB_ROOT = path.resolve(__dirname, '..', '..');
+const PROMPTS_PATH = path.join(KB_ROOT, 'claude-prompts.json');
+const SCHEMA = 'claude-prompts/v1';
+
+const PLACEHOLDER_RE = /\{\{\s*([A-Z_][A-Z0-9_]*)\s*\}\}/g;
+
+function readPrompts() {
+  if (!fs.existsSync(PROMPTS_PATH)) {
+    return { schema: SCHEMA, prompts: {} };
+  }
+  try {
+    const cfg = JSON.parse(fs.readFileSync(PROMPTS_PATH, 'utf-8'));
+    if (!cfg || typeof cfg !== 'object') return { schema: SCHEMA, prompts: {} };
+    if (!cfg.prompts || typeof cfg.prompts !== 'object') cfg.prompts = {};
+    if (!cfg.schema) cfg.schema = SCHEMA;
+    return cfg;
+  } catch (e) {
+    throw new Error(`failed to parse ${PROMPTS_PATH}: ${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`);
+    }
+  }
+  fs.writeFileSync(PROMPTS_PATH, JSON.stringify(normalized, null, 2) + '\n', 'utf-8');
+  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),
+  };
+}
+
+module.exports = {
+  PROMPTS_PATH,
+  SCHEMA,
+  readPrompts,
+  writePrompts,
+  listPromptKeys,
+  getPrompt,
+  renderPrompt,
+  interpolate,
+};