@h-rig/github-provider-plugin 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/issue-analysis.d.ts

@@ -61,11 +61,11 @@ export interface IssueAnalysisWriteBackTarget extends Pick<RegisteredTaskSource,
 export interface IssueAnalysisPluginContext {
     config: {
         issueAnalysis?: {
-            enabled?: boolean;
-            harness?: "pi";
-            model?: string;
-            mode?: "continuous" | "off";
-        };
+            enabled?: boolean | undefined;
+            harness?: "pi" | undefined;
+            model?: string | undefined;
+            mode?: "continuous" | "off" | undefined;
+        } | undefined;
     };
     taskSourceRegistry: {
         list(): readonly RegisteredTaskSource[];

package/dist/src/issue-analysis.js

@@ -220,7 +220,7 @@ function createIssueAnalysisWriteBack(input) {
         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 });
+    const comment = (input.buildStatusComment ?? defaultStatusComment)({ issue, result, ...reason !== undefined ? { reason } : {} });
     if (comment?.trim()) {
       if (!input.target.updateTask)
         throw new Error("Issue analysis writeback requires updateTask for sticky status comments.");
@@ -245,7 +245,7 @@ function sourceWithWriteBackCapabilities(source) {
   if (typeof candidate.updateTask !== "function")
     return null;
   return {
-    get: candidate.get?.bind(candidate),
+    ...typeof candidate.get === "function" ? { 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) } : {},
@@ -274,8 +274,8 @@ function createConfiguredIssueAnalysisRunner(input) {
   if (!target)
     return null;
   const analyzer = input.analyzer ?? createPiIssueAnalyzer({
-    runCommand: input.runCommand,
-    model: input.context.config.issueAnalysis?.model
+    ...input.runCommand ? { runCommand: input.runCommand } : {},
+    ...input.context.config.issueAnalysis?.model ? { model: input.context.config.issueAnalysis.model } : {}
   });
   const baseWriteBack = createIssueAnalysisWriteBack({ target });
   const service = createIssueAnalysisService({
@@ -288,7 +288,7 @@ function createConfiguredIssueAnalysisRunner(input) {
   return createContinuousIssueAnalysisRunner({
     loadIssues: async () => [...await source.list()],
     service,
-    intervalMs: input.intervalMs,
+    ...input.intervalMs !== undefined ? { intervalMs: input.intervalMs } : {},
     reason: "continuous-issue-analysis",
     ...input.setIntervalFn ? { setIntervalFn: input.setIntervalFn } : {},
     ...input.clearIntervalFn ? { clearIntervalFn: input.clearIntervalFn } : {},
@@ -309,7 +309,7 @@ function createIssueAnalysisService(input) {
         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 });
+          await input.writeBack?.({ issue, result, ...options.reason !== undefined ? { reason: options.reason } : {} });
         }
         results.push({ issue, result });
       }

package/dist/src/lib.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Factory-free library surface for @rig/github-provider-plugin.
+ *
+ * Cross-plugin consumers (task-sources / init / cli-surface) that need the
+ * GitHub *library* API (auth store, device flow, repo probe, projects,
+ * credential-provider builders) import it from here — NOT from the package
+ * index, which additionally re-exports the plugin FACTORY (`githubProviderPlugin`).
+ * Importing a sibling plugin's factory is the coupling rule-4 forbids.
+ *
+ * Provider behavior that has a product/runtime seam (for example run identity)
+ * is exposed as a typed capability from `@rig/contracts` and provided by this
+ * plugin, not as a cross-plugin implementation import.
+ */
+export * from "@rig/github-lib";
+export * from "./issue-analysis";
+export * from "./triage-run";

package/dist/src/lib.js

@@ -0,0 +1,485 @@
+// @bun
+// packages/github-provider-plugin/src/lib.ts
+export * from "@rig/github-lib";
+
+// packages/github-provider-plugin/src/issue-analysis.ts
+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; analyze backlog dependencies, children, readiness, size, risk, and planning.",
+    "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 async (command, args, options) => {
+    const env = options.env ? { ...process.env, ...options.env } : process.env;
+    const proc = Bun.spawn([command, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env
+    });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill();
+    }, options.timeoutMs);
+    try {
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited
+      ]);
+      return {
+        exitCode: timedOut && exitCode === 0 ? 1 : exitCode,
+        stdout,
+        stderr: timedOut && stderr.trim().length === 0 ? `Pi issue analysis timed out after ${options.timeoutMs}ms` : stderr
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+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 provider = input.provider?.trim() || process.env.RIG_ISSUE_ANALYSIS_PROVIDER?.trim() || process.env.RIG_PI_PROVIDER?.trim();
+    const model = input.model?.trim() || process.env.RIG_ISSUE_ANALYSIS_MODEL?.trim() || process.env.RIG_PI_MODEL?.trim() || "openai-codex/gpt-5.5";
+    if (provider)
+      args.push("--provider", provider);
+    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 !== undefined ? { 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 {
+    ...typeof candidate.get === "function" ? { 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({
+    ...input.runCommand ? { runCommand: input.runCommand } : {},
+    ...input.context.config.issueAnalysis?.model ? { 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,
+    ...input.intervalMs !== undefined ? { 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, ...options.reason !== undefined ? { 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;
+    }
+  };
+}
+// packages/github-provider-plugin/src/triage-run.ts
+import { buildPluginHostContext } from "@rig/core/plugin-host-context";
+function summarizeResults(results) {
+  return results.reduce((summary, entry) => {
+    if (entry.result.metadataPatch && Object.keys(entry.result.metadataPatch).length > 0) {
+      summary.metadataPatches += 1;
+    }
+    summary.labelsAdded += entry.result.labelsToAdd?.length ?? 0;
+    summary.labelsRemoved += entry.result.labelsToRemove?.length ?? 0;
+    summary.generatedIssues += entry.result.generatedIssues?.length ?? 0;
+    return summary;
+  }, { metadataPatches: 0, labelsAdded: 0, labelsRemoved: 0, generatedIssues: 0 });
+}
+async function loadContext(projectRoot) {
+  const context = await buildPluginHostContext(projectRoot);
+  if (!context)
+    return null;
+  return {
+    config: {
+      ...context.config.issueAnalysis ? { issueAnalysis: context.config.issueAnalysis } : {}
+    },
+    taskSourceRegistry: context.taskSourceRegistry
+  };
+}
+async function runIssueAnalysisTriage(options) {
+  const reason = options.reason?.trim() || "triage";
+  const context = options.context ?? await loadContext(options.projectRoot);
+  if (!context) {
+    return {
+      ok: true,
+      enabled: false,
+      reason,
+      sourceId: null,
+      sourceKind: null,
+      analyzedIssues: 0,
+      metadataPatches: 0,
+      labelsAdded: 0,
+      labelsRemoved: 0,
+      generatedIssues: 0,
+      writeBackRefreshes: 0,
+      refreshedIssueCount: null,
+      skippedReason: "no-config"
+    };
+  }
+  const source = context.taskSourceRegistry.list()[0] ?? null;
+  const sourceId = source?.id ?? null;
+  const sourceKind = source?.kind ?? null;
+  if (!issueAnalysisEnabled(context.config)) {
+    return {
+      ok: true,
+      enabled: false,
+      reason,
+      sourceId,
+      sourceKind,
+      analyzedIssues: 0,
+      metadataPatches: 0,
+      labelsAdded: 0,
+      labelsRemoved: 0,
+      generatedIssues: 0,
+      writeBackRefreshes: 0,
+      refreshedIssueCount: null,
+      skippedReason: "disabled"
+    };
+  }
+  if (!source) {
+    throw new Error("Issue analysis is enabled, but no configured task source is registered.");
+  }
+  let writeBackRefreshes = 0;
+  let refreshedIssueCount = null;
+  const refreshSnapshotAfterWriteBack = async () => {
+    writeBackRefreshes += 1;
+    const refreshed = await source.list();
+    refreshedIssueCount = refreshed.length;
+    await options.onWriteBack?.();
+  };
+  const runner = createConfiguredIssueAnalysisRunner({
+    projectRoot: options.projectRoot,
+    context,
+    ...options.analyzer ? { analyzer: options.analyzer } : {},
+    ...options.runCommand ? { runCommand: options.runCommand } : {},
+    onWriteBack: refreshSnapshotAfterWriteBack
+  });
+  if (!runner) {
+    throw new Error(`Issue analysis is enabled for ${sourceKind ?? "the configured source"}, but that task source does not expose Rig write-back capabilities.`);
+  }
+  const results = await runner.tick(reason);
+  const summary = summarizeResults(results);
+  return {
+    ok: true,
+    enabled: true,
+    reason,
+    sourceId,
+    sourceKind,
+    analyzedIssues: results.length,
+    ...summary,
+    writeBackRefreshes,
+    refreshedIssueCount
+  };
+}
+export {
+  runIssueAnalysisTriage,
+  renderIssueAnalysisPrompt,
+  parseIssueAnalysisResult,
+  issueAnalysisEnabled,
+  createPiIssueAnalyzer,
+  createIssueAnalysisWriteBack,
+  createIssueAnalysisService,
+  createDefaultPiIssueAnalysisCommandRunner,
+  createContinuousIssueAnalysisRunner,
+  createConfiguredIssueAnalysisRunner
+};

package/dist/src/plugin.d.ts

@@ -1,4 +1,8 @@
 export declare const GITHUB_PROVIDER_PLUGIN_NAME = "@rig/github-provider-plugin";
-export declare const githubProviderPlugin: import("@rig/core").RigPlugin;
-export declare function createGitHubProviderPlugin(): import("@rig/core").RigPlugin;
+/** Parse an `owner/repo` slug from a github remote URL (ssh or https form). */
+export declare function parseGitHubSlugFromRemote(remoteUrl: string): string | null;
+/** Detect this checkout's GitHub `owner/repo` from `origin` — SCM-domain logic. */
+export declare function detectGitHubRepoSlug(projectRoot: string): string | null;
+export declare const githubProviderPlugin: import("@rig/core/config").RigPlugin;
+export declare function createGitHubProviderPlugin(): import("@rig/core/config").RigPlugin;
 export default githubProviderPlugin;