@gzmagyari/kanbanboard 1.0.0

package/repo-grounding.mjs

@@ -0,0 +1,417 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+
+function parseArgsEnv(val) {
+  const s = String(val ?? '').trim();
+  if (!s) return [];
+  // Allow JSON array for safer args passing: '["--foo","bar"]'
+  if (s.startsWith('[')) {
+    try {
+      const arr = JSON.parse(s);
+      if (Array.isArray(arr)) return arr.map((x) => String(x));
+    } catch {
+      // fall through
+    }
+  }
+  // Fallback: whitespace split
+  return s.split(/\s+/g).filter(Boolean);
+}
+
+export function getRepoGroundingConfig() {
+  const cmd = String(process.env.REPO_GROUND_CLI_CMD || process.env.CLAUDE_CLI_CMD || 'claude').trim();
+  const args = parseArgsEnv(process.env.REPO_GROUND_CLI_ARGS || process.env.CLAUDE_CLI_ARGS || '');
+
+  const timeout_ms = Number(process.env.REPO_GROUND_TIMEOUT_MS || 120_000);
+  const max_output_bytes = Number(process.env.REPO_GROUND_MAX_OUTPUT_BYTES || 2_000_000);
+
+  return {
+    cmd,
+    args,
+    timeout_ms: Number.isFinite(timeout_ms) ? timeout_ms : 120_000,
+    max_output_bytes: Number.isFinite(max_output_bytes) ? max_output_bytes : 2_000_000
+  };
+}
+
+/**
+ * Runs an external CLI (intended for Claude CLI) in `cwd=repoPath`.
+ * Sends `prompt` to stdin, captures stdout/stderr.
+ *
+ * Configure via:
+ * - REPO_GROUND_CLI_CMD (default: "claude")
+ * - REPO_GROUND_CLI_ARGS (string, whitespace-split OR JSON array string)
+ * - REPO_GROUND_TIMEOUT_MS (default: 120000)
+ * - REPO_GROUND_MAX_OUTPUT_BYTES (default: 2000000)
+ */
+export function runRepoGrounding({ repoPath, prompt, timeout_ms, max_output_bytes } = {}) {
+  const cfg = getRepoGroundingConfig();
+  const cmd = cfg.cmd;
+  const args = cfg.args;
+  const timeout = Number.isFinite(timeout_ms) ? timeout_ms : cfg.timeout_ms;
+  const maxBytes = Number.isFinite(max_output_bytes) ? max_output_bytes : cfg.max_output_bytes;
+
+  if (!cmd) {
+    const err = new Error('Repo grounding CLI is not configured (set REPO_GROUND_CLI_CMD)');
+    err.code = 'REPO_GROUNDING_NOT_CONFIGURED';
+    throw err;
+  }
+
+  const started = Date.now();
+
+  return new Promise((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+    let outBytes = 0;
+    let errBytes = 0;
+    let timed_out = false;
+    let killed_for_limit = false;
+
+    const child = spawn(cmd, args, {
+      cwd: repoPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: true
+    });
+
+    const timer = setTimeout(() => {
+      timed_out = true;
+      try {
+        child.kill('SIGKILL');
+      } catch {
+        // ignore
+      }
+    }, timeout);
+
+    child.on('error', (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+
+    child.stdout.on('data', (chunk) => {
+      outBytes += Buffer.byteLength(chunk, 'utf8');
+      if (outBytes > maxBytes) {
+        killed_for_limit = true;
+        clearTimeout(timer);
+        try {
+          child.kill('SIGKILL');
+        } catch {
+          // ignore
+        }
+        return reject(new Error(`Repo grounding stdout exceeded limit (${maxBytes} bytes)`));
+      }
+      stdout += chunk;
+    });
+
+    child.stderr.on('data', (chunk) => {
+      errBytes += Buffer.byteLength(chunk, 'utf8');
+      if (errBytes > maxBytes) {
+        killed_for_limit = true;
+        clearTimeout(timer);
+        try {
+          child.kill('SIGKILL');
+        } catch {
+          // ignore
+        }
+        return reject(new Error(`Repo grounding stderr exceeded limit (${maxBytes} bytes)`));
+      }
+      stderr += chunk;
+    });
+
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+      resolve({
+        cmd,
+        args,
+        repoPath,
+        code: code ?? 0,
+        signal: signal ?? null,
+        stdout,
+        stderr,
+        timed_out,
+        killed_for_limit,
+        duration_ms: Date.now() - started
+      });
+    });
+
+    try {
+      child.stdin.write(String(prompt ?? ''), 'utf8');
+      child.stdin.end();
+    } catch (e) {
+      clearTimeout(timer);
+      reject(e);
+    }
+  });
+}
+
+/**
+ * Streaming variant of runRepoGrounding.
+ * Spawns Claude CLI with `--output-format stream-json --verbose` and reads
+ * NDJSON events line-by-line from stdout, calling `onEvent(event)` for each.
+ *
+ * The final `result` event's `result` field (a string) contains the CLI's
+ * text output. This is placed in `stdout` on the returned object so callers
+ * can use `extractFirstJsonObject()` as usual.
+ *
+ * Returns the same shape as runRepoGrounding().
+ */
+export function runRepoGroundingStreaming({ repoPath, prompt, timeout_ms, max_output_bytes, onEvent } = {}) {
+  const cfg = getRepoGroundingConfig();
+  const cmd = cfg.cmd;
+  const baseArgs = cfg.args;
+  const timeout = Number.isFinite(timeout_ms) ? timeout_ms : cfg.timeout_ms;
+  const maxBytes = Number.isFinite(max_output_bytes) ? max_output_bytes : cfg.max_output_bytes;
+
+  if (!cmd) {
+    const err = new Error('Repo grounding CLI is not configured (set REPO_GROUND_CLI_CMD)');
+    err.code = 'REPO_GROUNDING_NOT_CONFIGURED';
+    throw err;
+  }
+
+  // Add streaming flags to args
+  const args = ['-p', '--output-format', 'stream-json', '--verbose', ...baseArgs];
+
+  const started = Date.now();
+
+  return new Promise((resolve, reject) => {
+    let stderr = '';
+    let outBytes = 0;
+    let errBytes = 0;
+    let timed_out = false;
+    let killed_for_limit = false;
+
+    // Track result event and last assistant text as fallback
+    let resultEvent = null;
+    const lastAssistantTexts = [];
+
+    const child = spawn(cmd, args, {
+      cwd: repoPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: true
+    });
+
+    const timer = setTimeout(() => {
+      timed_out = true;
+      try { child.kill('SIGKILL'); } catch { /* ignore */ }
+    }, timeout);
+
+    child.on('error', (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+
+    // Read stdout line-by-line as NDJSON
+    const rl = createInterface({ input: child.stdout });
+    rl.on('line', (line) => {
+      outBytes += Buffer.byteLength(line, 'utf8') + 1; // +1 for newline
+      if (outBytes > maxBytes) {
+        killed_for_limit = true;
+        clearTimeout(timer);
+        rl.close();
+        try { child.kill('SIGKILL'); } catch { /* ignore */ }
+        return reject(new Error(`Repo grounding stdout exceeded limit (${maxBytes} bytes)`));
+      }
+
+      if (!line.trim()) return;
+
+      let event;
+      try { event = JSON.parse(line); } catch { return; } // skip non-JSON lines
+
+      // Track result event (final output)
+      if (event.type === 'result') {
+        resultEvent = event;
+      }
+      // Track assistant text blocks as fallback
+      if (event.type === 'assistant') {
+        for (const block of (event.message?.content || [])) {
+          if (block.type === 'text' && block.text?.trim()) {
+            lastAssistantTexts.push(block.text.trim());
+          }
+        }
+      }
+
+      // Notify caller
+      if (onEvent) {
+        try { onEvent(event); } catch { /* ignore callback errors */ }
+      }
+    });
+
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+      errBytes += Buffer.byteLength(chunk, 'utf8');
+      if (errBytes > maxBytes) {
+        killed_for_limit = true;
+        clearTimeout(timer);
+        try { child.kill('SIGKILL'); } catch { /* ignore */ }
+        return reject(new Error(`Repo grounding stderr exceeded limit (${maxBytes} bytes)`));
+      }
+      stderr += chunk;
+    });
+
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+
+      // Extract stdout text: prefer result event's `result` field, then last assistant text
+      let stdout = '';
+      if (resultEvent) {
+        stdout = String(resultEvent.result ?? '');
+      }
+      if (!stdout && lastAssistantTexts.length) {
+        stdout = lastAssistantTexts[lastAssistantTexts.length - 1];
+      }
+
+      resolve({
+        cmd,
+        args: baseArgs, // return original args (without streaming flags) for consistency
+        repoPath,
+        code: code ?? 0,
+        signal: signal ?? null,
+        stdout,
+        stderr,
+        timed_out,
+        killed_for_limit,
+        duration_ms: Date.now() - started
+      });
+    });
+
+    try {
+      child.stdin.write(String(prompt ?? ''), 'utf8');
+      child.stdin.end();
+    } catch (e) {
+      clearTimeout(timer);
+      reject(e);
+    }
+  });
+}
+
+/**
+ * Agent-oriented streaming variant of runRepoGrounding.
+ * Extends runRepoGroundingStreaming with support for:
+ * - Session persistence via --resume <sessionId>
+ * - System prompt injection via --append-system-prompt-file
+ * - Tool restrictions via --allowedTools
+ * - Permission bypass via --dangerously-skip-permissions
+ * - Session ID extraction from stream events
+ *
+ * Returns the same shape as runRepoGroundingStreaming plus `session_id`.
+ */
+export function runAgentStreaming({
+  repoPath,
+  prompt,
+  resumeSessionId,
+  appendSystemPromptFile,
+  allowedTools,
+  dangerouslySkipPermissions,
+  onEvent
+} = {}) {
+  const cfg = getRepoGroundingConfig();
+  const cmd = cfg.cmd;
+  const baseArgs = cfg.args;
+
+  if (!cmd) {
+    const err = new Error('Repo grounding CLI is not configured (set REPO_GROUND_CLI_CMD)');
+    err.code = 'REPO_GROUNDING_NOT_CONFIGURED';
+    throw err;
+  }
+
+  // Build args dynamically based on agent config
+  const args = ['-p', '--output-format', 'stream-json', '--verbose'];
+  if (resumeSessionId) {
+    args.push('--resume', resumeSessionId);
+  }
+  if (appendSystemPromptFile) {
+    args.push('--append-system-prompt-file', appendSystemPromptFile);
+  }
+  if (dangerouslySkipPermissions) {
+    args.push('--dangerously-skip-permissions');
+  } else if (allowedTools) {
+    const tools = allowedTools.split(',').map(t => t.trim()).filter(Boolean);
+    if (tools.length > 0) {
+      args.push('--allowedTools');
+      args.push(...tools);
+    }
+  }
+  args.push(...baseArgs);
+
+  const started = Date.now();
+
+  return new Promise((resolve, reject) => {
+    let stderr = '';
+    let resultEvent = null;
+    const lastAssistantTexts = [];
+    let initSessionId = null;
+
+    const child = spawn(cmd, args, {
+      cwd: repoPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: true
+    });
+
+    child.on('error', (e) => reject(e));
+
+    const rl = createInterface({ input: child.stdout });
+    rl.on('line', (line) => {
+      if (!line.trim()) return;
+
+      let event;
+      try { event = JSON.parse(line); } catch { return; }
+
+      if (event.type === 'system' && event.subtype === 'init') {
+        initSessionId = event.session_id || null;
+      }
+      if (event.type === 'result') {
+        resultEvent = event;
+      }
+      if (event.type === 'assistant') {
+        for (const block of (event.message?.content || [])) {
+          if (block.type === 'text' && block.text?.trim()) {
+            lastAssistantTexts.push(block.text.trim());
+          }
+        }
+      }
+
+      if (onEvent) {
+        try { onEvent(event); } catch { /* ignore */ }
+      }
+    });
+
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+
+    child.on('close', (code, signal) => {
+      let stdout = '';
+      if (resultEvent) {
+        stdout = String(resultEvent.result ?? '');
+      }
+      if (!stdout && lastAssistantTexts.length) {
+        stdout = lastAssistantTexts[lastAssistantTexts.length - 1];
+      }
+
+      let sessionId = null;
+      if (resultEvent && typeof resultEvent.session_id === 'string') {
+        sessionId = resultEvent.session_id;
+      } else if (initSessionId) {
+        sessionId = initSessionId;
+      }
+
+      resolve({
+        cmd,
+        args: baseArgs,
+        repoPath,
+        code: code ?? 0,
+        signal: signal ?? null,
+        stdout,
+        stderr,
+        duration_ms: Date.now() - started,
+        session_id: sessionId
+      });
+    });
+
+    try {
+      child.stdin.write(String(prompt ?? ''), 'utf8');
+      child.stdin.end();
+    } catch (e) {
+      reject(e);
+    }
+  });
+}