project-knowledge 0.1.0

package/_site/scripts/hook-trigger.js

@@ -0,0 +1,133 @@
+// _site/scripts/hook-trigger.js
+//
+// Lightweight, fire-and-forget trigger invoked by `<repo>/.git/hooks/post-commit`.
+// The hook is a tiny shim that runs `node <path-to-this-file>` with the
+// repo path as argv. This script then asks the KB server to run a `safe` job
+// for that project (scan + analyze-commits, no apply), and silently exits 0
+// even if the server is unreachable — the commit must never be blocked.
+//
+// Usage from a git hook:
+//   node "$(git rev-parse --show-toplevel)/.kb/hook-trigger.js" \
+//        --kb-root <path-to-KB-site-root> \
+//        --repo  <absolute-repo-path>
+//
+// Behavior contract (NEVER violated):
+//   * Always exits 0. The user's commit is sacred.
+//   * HTTP timeout is 2 seconds total; if the server doesn't respond fast,
+//     the trigger is abandoned and the failure is appended to a log file.
+//   * If the server is reachable, the script returns immediately after
+//     dispatching the job — it does NOT wait for the job to finish.
+//   * Failures are appended to `<kbRoot>/.hook-trigger-errors.log`.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const http = require('http');
+
+const args = process.argv.slice(2);
+function arg(name, fallback) {
+  const i = args.indexOf(name);
+  if (i < 0) return fallback;
+  return args[i + 1] || fallback;
+}
+const KB_ROOT = arg('--kb-root', '');
+const REPO = arg('--repo', '');
+const HOST = arg('--host', '127.0.0.1');
+const PORT = parseInt(arg('--port', process.env.KB_SITE_PORT || '7777'), 10);
+
+const HOOK_TIMEOUT_MS = 2000;
+const LOG_FILENAME = '.hook-trigger-errors.log';
+
+function logError(msg) {
+  if (!KB_ROOT) return; // Without kb-root we have nowhere to log
+  try {
+    const logPath = path.join(KB_ROOT, LOG_FILENAME);
+    const stamp = new Date().toISOString();
+    fs.appendFileSync(logPath, `[${stamp}] ${msg}\n`, 'utf-8');
+  } catch { /* swallow */ }
+}
+
+function postJson(p, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const req = http.request({
+      host: HOST, port: PORT, method: 'POST', path: p,
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+      timeout: HOOK_TIMEOUT_MS,
+    }, (res) => {
+      res.on('data', () => {});
+      res.on('end', () => resolve({ status: res.statusCode }));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('timeout')));
+    req.write(data);
+    req.end();
+  });
+}
+
+function getJson(p) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      host: HOST, port: PORT, method: 'GET', path: p, timeout: HOOK_TIMEOUT_MS,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf-8');
+        let json = {};
+        try { json = text ? JSON.parse(text) : {}; } catch { json = { raw: text }; }
+        resolve({ status: res.statusCode, data: json });
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('timeout')));
+    req.end();
+  });
+}
+
+async function findSlugForRepo(repoAbs) {
+  // The KB server is authoritative on which project owns this repo path.
+  // /api/state.projects[*].gitPath is the canonical mapping.
+  const r = await getJson('/api/state');
+  if (r.status !== 200 || !r.data || !r.data.projects) return null;
+  const norm = p => path.resolve(p).toLowerCase().replace(/[\\\/]+$/, '');
+  const target = norm(repoAbs);
+  for (const [slug, cfg] of Object.entries(r.data.projects)) {
+    if (cfg && cfg.gitPath && norm(cfg.gitPath) === target) return slug;
+    if (cfg && cfg.localPath && norm(cfg.localPath) === target) return slug;
+  }
+  return null;
+}
+
+(async () => {
+  if (!KB_ROOT || !REPO) {
+    // Without these we cannot do anything useful; just bail silently.
+    process.exit(0);
+  }
+
+  // 1. Resolve the project slug for this repo.
+  let slug;
+  try {
+    slug = await findSlugForRepo(REPO);
+  } catch (e) {
+    logError(`slug lookup failed for repo=${REPO}: ${e.message}`);
+    process.exit(0);
+  }
+  if (!slug) {
+    logError(`no KB project registered for repo=${REPO}`);
+    process.exit(0);
+  }
+
+  // 2. Dispatch a `safe` job for this single project. Fire-and-forget: we
+  //    do not wait for the job to finish; the server will record the result.
+  try {
+    const r = await postJson('/api/jobs/run', { mode: 'safe', slug });
+    if (r.status !== 200) {
+      logError(`dispatch non-200 for slug=${slug} repo=${REPO}: HTTP ${r.status}`);
+    }
+  } catch (e) {
+    logError(`dispatch failed for slug=${slug} repo=${REPO}: ${e.message}`);
+  }
+
+  process.exit(0);
+})();

package/_site/scripts/safe-runner.js

@@ -0,0 +1,151 @@
+// _site/scripts/safe-runner.js
+//
+// Standalone safe-mode runner. Invoked by the Windows scheduled task.
+// Performs scan + analyze-commits for every enabled project, and explicitly
+// never calls apply, so AI drafts cannot become trusted knowledge without a
+// human at the Drafts tab.
+//
+// Usage:
+//   node _site/scripts/safe-runner.js [--port 7777] [--host 127.0.0.1] [--slug ALL]
+//
+// The script does NOT spawn the server; the server must already be running.
+// If the server is unreachable, the script exits with a non-zero code so the
+// scheduled task registers a clear failure.
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+
+const args = process.argv.slice(2);
+function arg(name, fallback) {
+  const i = args.indexOf(name);
+  if (i < 0) return fallback;
+  return args[i + 1] || fallback;
+}
+const HOST = arg('--host', '127.0.0.1');
+const PORT = parseInt(arg('--port', process.env.KB_SITE_PORT || '7777'), 10);
+const SLUG = arg('--slug', 'ALL');
+
+function log(line) {
+  const stamp = new Date().toISOString();
+  process.stdout.write(`[${stamp}] ${line}\n`);
+}
+
+function postJson(path_, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const req = http.request({
+      host: HOST, port: PORT, method: 'POST', path: path_,
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+      timeout: 5000,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf-8');
+        let json = {};
+        try { json = text ? JSON.parse(text) : {}; } catch { json = { raw: text }; }
+        resolve({ status: res.statusCode, data: json });
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('request timeout')));
+    req.write(data);
+    req.end();
+  });
+}
+
+function getJson(path_) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      host: HOST, port: PORT, method: 'GET', path: path_, timeout: 5000,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf-8');
+        let json = {};
+        try { json = text ? JSON.parse(text) : {}; } catch { json = { raw: text }; }
+        resolve({ status: res.statusCode, data: json });
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('request timeout')));
+    req.end();
+  });
+}
+
+async function waitForServer(maxMs = 15000) {
+  const deadline = Date.now() + maxMs;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const r = await getJson('/api/state');
+      if (r.status >= 200 && r.status < 500) return true;
+      lastError = new Error(`HTTP ${r.status}`);
+    } catch (e) { lastError = e; }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  throw lastError || new Error('server not reachable');
+}
+
+async function pollJob(jobId, maxMs = 10 * 60 * 1000) {
+  const deadline = Date.now() + maxMs;
+  while (Date.now() < deadline) {
+    const r = await getJson(`/api/jobs/${jobId}`);
+    if (r.status === 404) {
+      // Job not in the running map and not in the persisted log yet
+      await new Promise(r => setTimeout(r, 1000));
+      continue;
+    }
+    if (r.status >= 200 && r.status < 300 && r.data && r.data.job) {
+      if (r.data.job.status === 'running') {
+        await new Promise(r => setTimeout(r, 1500));
+        continue;
+      }
+      return r.data.job;
+    }
+    throw new Error(`unexpected response: HTTP ${r.status} ${JSON.stringify(r.data).slice(0, 200)}`);
+  }
+  throw new Error('job did not complete within timeout');
+}
+
+(async () => {
+  log(`safe-runner starting: host=${HOST} port=${PORT} slug=${SLUG}`);
+
+  try {
+    await waitForServer();
+  } catch (e) {
+    log(`ERROR: server not reachable at http://${HOST}:${PORT}/ — ${e.message}`);
+    log(`(the safe-runner requires the KB site server to be running; start it with "node _site/server.js" first.)`);
+    process.exit(2);
+  }
+
+  log(`dispatching safe run (slug=${SLUG})`);
+  const start = await postJson('/api/jobs/run', { mode: 'safe', slug: SLUG });
+  if (start.status !== 200 || !start.data.ok) {
+    log(`ERROR: failed to dispatch job: HTTP ${start.status} ${JSON.stringify(start.data)}`);
+    process.exit(3);
+  }
+  const jobId = start.data.jobId;
+  log(`dispatched jobId=${jobId}`);
+
+  let job;
+  try {
+    job = await pollJob(jobId);
+  } catch (e) {
+    log(`ERROR: ${e.message}`);
+    process.exit(4);
+  }
+
+  log(`job ${jobId} finished: status=${job.status} exitCode=${job.exitCode}`);
+  if (job.summary) {
+    log(`summary: ${JSON.stringify(job.summary)}`);
+  }
+  if (job.output) {
+    const tail = job.output.split(/\r?\n/).filter(Boolean).slice(-20).join('\n');
+    if (tail) log(`tail of output:\n${tail}`);
+  }
+
+  process.exit(job.exitCode || 0);
+})();