@h-rig/server 0.0.6-alpha.0

package/dist/src/server-helpers/issue-analysis.js

@@ -0,0 +1,362 @@
+// @bun
+// packages/server/src/server-helpers/issue-analysis.ts
+import { execFile } from "child_process";
+import { createHash } from "crypto";
+function stableIssueHash(issue) {
+  const labels = Array.isArray(issue.labels) ? [...issue.labels].map(String).sort() : [];
+  const body = typeof issue.body === "string" ? issue.body : "";
+  const title = typeof issue.title === "string" ? issue.title : "";
+  return createHash("sha256").update(JSON.stringify({ id: issue.id, title, body, labels, deps: issue.deps, status: issue.status })).digest("hex");
+}
+function renderIssueAnalysisPrompt(input) {
+  const issue = input.issue;
+  const neighbors = input.neighbors ?? [];
+  return [
+    "You are Rig issue analysis running inside Pi.",
+    "Return JSON only with optional metadataPatch, labelsToAdd, labelsToRemove, and generatedIssues.",
+    "Preserve all human-authored issue body content. Only propose edits for Rig-owned metadata/status sections, labels, and generated issues.",
+    "Generated issues must be concrete, minimal follow-up tasks and will be labeled rig:generated by Rig.",
+    "",
+    "Issue:",
+    JSON.stringify({
+      id: issue.id,
+      title: issue.title,
+      body: issue.body,
+      labels: issue.labels,
+      deps: issue.deps,
+      status: issue.status
+    }, null, 2),
+    "",
+    "Neighbor tasks:",
+    JSON.stringify(neighbors.map((task) => ({ id: task.id, title: task.title, status: task.status, deps: task.deps })), null, 2)
+  ].join(`
+`);
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringArray(value) {
+  if (!Array.isArray(value))
+    return;
+  return value.map(String).filter((entry) => entry.trim().length > 0);
+}
+function generatedIssues(value) {
+  if (!Array.isArray(value))
+    return;
+  return value.flatMap((entry) => {
+    if (!isRecord(entry) || typeof entry.title !== "string")
+      return [];
+    return [{
+      title: entry.title,
+      body: typeof entry.body === "string" ? entry.body : "",
+      labels: stringArray(entry.labels) ?? [],
+      ...Array.isArray(entry.dependsOn) ? { dependsOn: entry.dependsOn.map(String) } : {}
+    }];
+  });
+}
+function findJsonLikeText(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("```"))
+      return trimmed;
+    return null;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const found = findJsonLikeText(entry);
+      if (found)
+        return found;
+    }
+    return null;
+  }
+  if (!isRecord(value))
+    return null;
+  for (const key of ["text", "content", "message", "output_text", "response", "stdout"]) {
+    const found = findJsonLikeText(value[key]);
+    if (found)
+      return found;
+  }
+  for (const entry of Object.values(value)) {
+    const found = findJsonLikeText(entry);
+    if (found)
+      return found;
+  }
+  return null;
+}
+function candidateAnalysisObject(value) {
+  if (!isRecord(value))
+    return null;
+  if (isRecord(value.result))
+    return candidateAnalysisObject(value.result) ?? value.result;
+  if (isRecord(value.analysis))
+    return candidateAnalysisObject(value.analysis) ?? value.analysis;
+  if (isRecord(value.metadataPatch) || Array.isArray(value.labelsToAdd) || Array.isArray(value.labelsToRemove) || Array.isArray(value.generatedIssues)) {
+    return value;
+  }
+  const nested = findJsonLikeText(value);
+  if (nested && nested !== JSON.stringify(value)) {
+    try {
+      const parsedNested = JSON.parse(nested.match(/```(?:json)?\s*([\s\S]*?)\s*```/i)?.[1]?.trim() ?? nested);
+      return candidateAnalysisObject(parsedNested);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function parseIssueAnalysisResult(raw) {
+  let parsed = raw;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i)?.[1]?.trim();
+    try {
+      parsed = JSON.parse(fenced ?? trimmed);
+    } catch {
+      const lastJsonLine = trimmed.split(/\r?\n/).reverse().find((line) => line.trim().startsWith("{"));
+      parsed = lastJsonLine ? JSON.parse(lastJsonLine) : {};
+    }
+  }
+  const candidate = candidateAnalysisObject(parsed);
+  if (!candidate)
+    return {};
+  const result = {};
+  if (isRecord(candidate.metadataPatch))
+    result.metadataPatch = candidate.metadataPatch;
+  const add = stringArray(candidate.labelsToAdd);
+  if (add?.length)
+    result.labelsToAdd = add;
+  const remove = stringArray(candidate.labelsToRemove);
+  if (remove?.length)
+    result.labelsToRemove = remove;
+  const generated = generatedIssues(candidate.generatedIssues);
+  if (generated?.length)
+    result.generatedIssues = generated;
+  return result;
+}
+function createDefaultPiIssueAnalysisCommandRunner() {
+  return (command, args, options) => new Promise((resolve) => {
+    execFile(command, [...args], {
+      timeout: options.timeoutMs,
+      maxBuffer: 10 * 1024 * 1024,
+      env: options.env ? { ...process.env, ...options.env } : process.env
+    }, (error, stdout, stderr) => {
+      const exitCode = typeof error?.code === "number" ? error.code : error ? 1 : 0;
+      resolve({ exitCode, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+    });
+  });
+}
+function createPiIssueAnalyzer(input = {}) {
+  const piBinary = input.piBinary ?? process.env.RIG_ISSUE_ANALYSIS_PI_BINARY ?? "pi";
+  const timeoutMs = Math.max(1000, Math.trunc(input.timeoutMs ?? Number(process.env.RIG_ISSUE_ANALYSIS_TIMEOUT_MS ?? 120000)));
+  const runCommand = input.runCommand ?? createDefaultPiIssueAnalysisCommandRunner();
+  return async ({ prompt }) => {
+    const args = ["--print", "--mode", "json", "--no-session"];
+    const model = input.model?.trim() || process.env.RIG_ISSUE_ANALYSIS_MODEL?.trim() || "openai-codex/gpt-5.5";
+    if (model)
+      args.push("--model", model);
+    args.push(prompt);
+    const result = await runCommand(piBinary, args, { timeoutMs, ...input.env ? { env: input.env } : {} });
+    if (result.exitCode !== 0) {
+      throw new Error(`Pi issue analysis failed (exit ${result.exitCode}): ${result.stderr ?? result.stdout}`);
+    }
+    return parseIssueAnalysisResult(result.stdout);
+  };
+}
+function defaultStatusComment(input) {
+  const changes = [
+    input.result.metadataPatch ? "metadata" : null,
+    input.result.labelsToAdd?.length ? `labels added: ${input.result.labelsToAdd.join(", ")}` : null,
+    input.result.labelsToRemove?.length ? `labels removed: ${input.result.labelsToRemove.join(", ")}` : null,
+    input.result.generatedIssues?.length ? `generated issues: ${input.result.generatedIssues.length}` : null
+  ].filter((entry) => Boolean(entry));
+  if (changes.length === 0)
+    return null;
+  return [
+    "<!-- rig:status-comment -->",
+    "### Rig issue analysis",
+    "",
+    `Analyzed issue ${input.issue.id}${input.reason ? ` (${input.reason})` : ""}.`,
+    "",
+    ...changes.map((change) => `- ${change}`)
+  ].join(`
+`);
+}
+function uniqueLabels(labels, required = []) {
+  return [...new Set([...labels ?? [], ...required].map((label) => label.trim()).filter(Boolean))];
+}
+function createIssueAnalysisWriteBack(input) {
+  return async ({ issue, result, reason }) => {
+    if (result.metadataPatch && Object.keys(result.metadataPatch).length > 0) {
+      if (!input.target.updateTask)
+        throw new Error("Issue analysis writeback requires updateTask for metadata patches.");
+      await input.target.updateTask(issue.id, { metadata: result.metadataPatch });
+    }
+    if (result.labelsToAdd?.length) {
+      if (!input.target.addLabels)
+        throw new Error("Issue analysis writeback requires addLabels for labelsToAdd.");
+      await input.target.addLabels(issue.id, uniqueLabels(result.labelsToAdd));
+    }
+    if (result.labelsToRemove?.length) {
+      if (!input.target.removeLabels)
+        throw new Error("Issue analysis writeback requires removeLabels for labelsToRemove.");
+      await input.target.removeLabels(issue.id, uniqueLabels(result.labelsToRemove));
+    }
+    const comment = (input.buildStatusComment ?? defaultStatusComment)({ issue, result, reason });
+    if (comment?.trim()) {
+      if (!input.target.updateTask)
+        throw new Error("Issue analysis writeback requires updateTask for sticky status comments.");
+      await input.target.updateTask(issue.id, { comment });
+    }
+    for (const generated of result.generatedIssues ?? []) {
+      if (!input.target.createIssue)
+        throw new Error("Issue analysis writeback requires createIssue for generated issues.");
+      await input.target.createIssue({
+        title: generated.title,
+        body: generated.dependsOn?.length ? `${generated.body.trimEnd()}
+
+depends-on: ${generated.dependsOn.map((dep) => dep.startsWith("#") ? dep : `#${dep}`).join(", ")}
+` : generated.body,
+        labels: uniqueLabels(generated.labels, ["rig:generated"])
+      });
+    }
+  };
+}
+function sourceWithWriteBackCapabilities(source) {
+  const candidate = source;
+  if (typeof candidate.updateTask !== "function")
+    return null;
+  return {
+    get: candidate.get?.bind(candidate),
+    updateTask: candidate.updateTask.bind(candidate),
+    ...typeof candidate.addLabels === "function" ? { addLabels: candidate.addLabels.bind(candidate) } : {},
+    ...typeof candidate.removeLabels === "function" ? { removeLabels: candidate.removeLabels.bind(candidate) } : {},
+    ...typeof candidate.createIssue === "function" ? { createIssue: candidate.createIssue.bind(candidate) } : {}
+  };
+}
+function issueAnalysisEnabled(config) {
+  const issueAnalysis = config.issueAnalysis;
+  if (!issueAnalysis)
+    return false;
+  if (issueAnalysis.enabled !== true)
+    return false;
+  if (issueAnalysis.mode === "off")
+    return false;
+  if (issueAnalysis.harness && issueAnalysis.harness !== "pi")
+    return false;
+  return true;
+}
+function createConfiguredIssueAnalysisRunner(input) {
+  if (!issueAnalysisEnabled(input.context.config))
+    return null;
+  const source = input.context.taskSourceRegistry.list()[0];
+  if (!source)
+    return null;
+  const target = sourceWithWriteBackCapabilities(source);
+  if (!target)
+    return null;
+  const analyzer = input.analyzer ?? createPiIssueAnalyzer({
+    runCommand: input.runCommand,
+    model: input.context.config.issueAnalysis?.model
+  });
+  const baseWriteBack = createIssueAnalysisWriteBack({ target });
+  const service = createIssueAnalysisService({
+    analyzer,
+    writeBack: async (writeBackInput) => {
+      await baseWriteBack(writeBackInput);
+      await input.onWriteBack?.();
+    }
+  });
+  return createContinuousIssueAnalysisRunner({
+    loadIssues: async () => [...await source.list()],
+    service,
+    intervalMs: input.intervalMs,
+    reason: "continuous-issue-analysis",
+    ...input.setIntervalFn ? { setIntervalFn: input.setIntervalFn } : {},
+    ...input.clearIntervalFn ? { clearIntervalFn: input.clearIntervalFn } : {},
+    ...input.onError ? { onError: input.onError } : {}
+  });
+}
+function createIssueAnalysisService(input) {
+  const analyzedHashes = new Map;
+  return {
+    async analyze(issues, options = {}) {
+      const results = [];
+      const neighbors = options.neighbors ?? issues;
+      for (const issue of issues) {
+        const hash = stableIssueHash(issue);
+        if (analyzedHashes.get(issue.id) === hash)
+          continue;
+        const prompt = renderIssueAnalysisPrompt({ issue, neighbors: neighbors.filter((candidate) => candidate.id !== issue.id) });
+        const result = await input.analyzer({ issue, neighbors, prompt });
+        analyzedHashes.set(issue.id, hash);
+        if (result.metadataPatch || result.labelsToAdd?.length || result.labelsToRemove?.length || result.generatedIssues?.length) {
+          await input.writeBack?.({ issue, result, reason: options.reason });
+        }
+        results.push({ issue, result });
+      }
+      return results;
+    },
+    clearCache() {
+      analyzedHashes.clear();
+    }
+  };
+}
+function createContinuousIssueAnalysisRunner(input) {
+  const intervalMs = Math.max(1000, Math.trunc(input.intervalMs ?? 60000));
+  const setIntervalFn = input.setIntervalFn ?? ((callback, ms) => setInterval(() => {
+    callback();
+  }, ms));
+  const clearIntervalFn = input.clearIntervalFn ?? ((timer2) => clearInterval(timer2));
+  let timer;
+  let running = false;
+  let inFlight = null;
+  const tick = async (reason = input.reason ?? "continuous") => {
+    if (inFlight)
+      return inFlight;
+    inFlight = (async () => {
+      const issues = await input.loadIssues();
+      return input.service.analyze(issues, { reason });
+    })();
+    try {
+      return await inFlight;
+    } finally {
+      inFlight = null;
+    }
+  };
+  return {
+    start() {
+      if (running)
+        return;
+      running = true;
+      timer = setIntervalFn(async () => {
+        try {
+          await tick();
+        } catch (error) {
+          input.onError?.(error);
+        }
+      }, intervalMs);
+    },
+    stop() {
+      if (!running)
+        return;
+      running = false;
+      if (timer !== undefined)
+        clearIntervalFn(timer);
+      timer = undefined;
+    },
+    tick,
+    isRunning() {
+      return running;
+    }
+  };
+}
+export {
+  renderIssueAnalysisPrompt,
+  parseIssueAnalysisResult,
+  createPiIssueAnalyzer,
+  createIssueAnalysisWriteBack,
+  createIssueAnalysisService,
+  createDefaultPiIssueAnalysisCommandRunner,
+  createContinuousIssueAnalysisRunner,
+  createConfiguredIssueAnalysisRunner
+};

package/dist/src/server-helpers/normalizers.js

@@ -0,0 +1,31 @@
+// @bun
+// packages/server/src/server-helpers/normalizers.ts
+function normalizeString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function normalizeSequence(value) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : NaN;
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function normalizeStringArray(value) {
+  return Array.isArray(value) ? value.map((entry) => normalizeString(entry)).filter((entry) => entry !== null) : [];
+}
+function normalizeRuntimeAdapter(value) {
+  const normalized = normalizeString(value)?.toLowerCase();
+  if (!normalized) {
+    return "pi";
+  }
+  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
+    return "codex";
+  }
+  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
+    return "pi";
+  }
+  return "claude-code";
+}
+export {
+  normalizeStringArray,
+  normalizeString,
+  normalizeSequence,
+  normalizeRuntimeAdapter
+};

package/dist/src/server-helpers/notifications.js

@@ -0,0 +1,96 @@
+// @bun
+// packages/server/src/server-helpers/notifications.ts
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname } from "path";
+async function loadNotificationConfig(path) {
+  if (!existsSync(path)) {
+    const defaultConfig = { targets: [] };
+    mkdirSync(dirname(path), { recursive: true });
+    await Bun.write(path, `${JSON.stringify(defaultConfig, null, 2)}
+`);
+    return defaultConfig;
+  }
+  try {
+    const parsed = await Bun.file(path).json();
+    return {
+      targets: (parsed.targets || []).filter((target) => !!target && !!target.id && !!target.url)
+    };
+  } catch {
+    return { targets: [] };
+  }
+}
+function readRecentEvents(file, limit) {
+  if (!existsSync(file)) {
+    return [];
+  }
+  const lines = readFileSync(file, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-limit);
+  const events = [];
+  for (const line of lines) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {}
+  }
+  return events;
+}
+async function dispatchEventToTargets(event, targets) {
+  const timeoutMs = resolveNotifyTimeoutMs();
+  let sent = 0;
+  for (const target of targets) {
+    if (target.enabled === false) {
+      continue;
+    }
+    if (target.events && target.events.length > 0 && !target.events.includes(event.type)) {
+      continue;
+    }
+    const payload = buildTargetPayload(target, event);
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(target.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...target.headers || {}
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      if (response.ok) {
+        sent += 1;
+      } else {
+        console.error(`[server] failed to dispatch event ${event.type} to ${target.id}: ${response.status} ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error(`[server] failed to dispatch event ${event.type} to ${target.id}`, error);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  return sent;
+}
+function buildTargetPayload(target, event) {
+  if (target.type === "slack-webhook") {
+    return {
+      text: `[Rig] ${event.type} ${event.runId ? `(run ${event.runId})` : ""}`.trim(),
+      event
+    };
+  }
+  return {
+    source: "project-rig",
+    target: target.id,
+    summary: `${event.type}${event.runId ? `:${event.runId}` : ""}`,
+    event
+  };
+}
+function resolveNotifyTimeoutMs() {
+  const raw = process.env.RIG_NOTIFY_TIMEOUT_MS;
+  const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1e4;
+}
+export {
+  resolveNotifyTimeoutMs,
+  readRecentEvents,
+  loadNotificationConfig,
+  dispatchEventToTargets,
+  buildTargetPayload
+};