@h-rig/github-provider-plugin 0.0.6-alpha.156

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

@@ -0,0 +1,129 @@
+import type { RegisteredTaskSource, TaskRecord } from "@rig/contracts";
+export interface RigIssueMetadata {
+    readiness?: string;
+    risk?: string;
+    planning?: string;
+    size?: string;
+    children?: string[];
+    blockers?: string[];
+    dependencies?: string[];
+    [key: string]: unknown;
+}
+export interface IssueAnalysisResult {
+    metadataPatch?: RigIssueMetadata;
+    labelsToAdd?: string[];
+    labelsToRemove?: string[];
+    generatedIssues?: Array<{
+        title: string;
+        body: string;
+        labels: string[];
+        dependsOn?: string[];
+    }>;
+}
+export type IssueAnalyzer = (input: {
+    issue: TaskRecord;
+    neighbors: readonly TaskRecord[];
+    prompt: string;
+}) => Promise<IssueAnalysisResult>;
+export type IssueAnalysisWriteBack = (input: {
+    issue: TaskRecord;
+    result: IssueAnalysisResult;
+    reason?: string;
+}) => Promise<void>;
+export interface IssueAnalysisService {
+    analyze(issues: readonly TaskRecord[], options?: {
+        reason?: string;
+        neighbors?: readonly TaskRecord[];
+    }): Promise<Array<{
+        issue: TaskRecord;
+        result: IssueAnalysisResult;
+    }>>;
+    clearCache(): void;
+}
+export interface PiIssueAnalysisCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr?: string;
+}
+export type PiIssueAnalysisCommandRunner = (command: string, args: readonly string[], options: {
+    timeoutMs: number;
+    env?: NodeJS.ProcessEnv;
+}) => Promise<PiIssueAnalysisCommandResult>;
+export interface IssueAnalysisWriteBackTarget extends Pick<RegisteredTaskSource, "get" | "updateTask"> {
+    addLabels?(id: string, labels: readonly string[]): Promise<void>;
+    removeLabels?(id: string, labels: readonly string[]): Promise<void>;
+    createIssue?(input: {
+        title: string;
+        body?: string;
+        labels?: readonly string[];
+    }): Promise<TaskRecord>;
+}
+export interface IssueAnalysisPluginContext {
+    config: {
+        issueAnalysis?: {
+            enabled?: boolean;
+            harness?: "pi";
+            model?: string;
+            mode?: "continuous" | "off";
+        };
+    };
+    taskSourceRegistry: {
+        list(): readonly RegisteredTaskSource[];
+    };
+}
+export interface ContinuousIssueAnalysisRunner {
+    start(): void;
+    stop(): void;
+    tick(reason?: string): Promise<Array<{
+        issue: TaskRecord;
+        result: IssueAnalysisResult;
+    }>>;
+    isRunning(): boolean;
+}
+export declare function renderIssueAnalysisPrompt(input: {
+    issue: TaskRecord;
+    neighbors?: readonly TaskRecord[];
+}): string;
+export declare function parseIssueAnalysisResult(raw: string | Record<string, unknown>): IssueAnalysisResult;
+export declare function createDefaultPiIssueAnalysisCommandRunner(): PiIssueAnalysisCommandRunner;
+export declare function createPiIssueAnalyzer(input?: {
+    runCommand?: PiIssueAnalysisCommandRunner;
+    piBinary?: string;
+    provider?: string;
+    model?: string;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}): IssueAnalyzer;
+export declare function createIssueAnalysisWriteBack(input: {
+    target: IssueAnalysisWriteBackTarget;
+    buildStatusComment?: (input: {
+        issue: TaskRecord;
+        result: IssueAnalysisResult;
+        reason?: string;
+    }) => string | null | undefined;
+}): IssueAnalysisWriteBack;
+export declare function issueAnalysisEnabled(config: IssueAnalysisPluginContext["config"]): boolean;
+export declare function createConfiguredIssueAnalysisRunner(input: {
+    projectRoot: string;
+    context: IssueAnalysisPluginContext;
+    analyzer?: IssueAnalyzer;
+    runCommand?: PiIssueAnalysisCommandRunner;
+    intervalMs?: number;
+    setIntervalFn?: (callback: () => void | Promise<void>, ms: number) => unknown;
+    clearIntervalFn?: (timer: unknown) => void;
+    onError?: (error: unknown) => void;
+    onWriteBack?: () => void | Promise<void>;
+}): ContinuousIssueAnalysisRunner | null;
+export declare function createIssueAnalysisService(input: {
+    analyzer: IssueAnalyzer;
+    writeBack?: IssueAnalysisWriteBack;
+}): IssueAnalysisService;
+export declare function createContinuousIssueAnalysisRunner(input: {
+    loadIssues: () => Promise<readonly TaskRecord[]>;
+    service: IssueAnalysisService;
+    intervalMs?: number;
+    reason?: string;
+    setIntervalFn?: (callback: () => void | Promise<void>, ms: number) => unknown;
+    clearIntervalFn?: (timer: unknown) => void;
+    onError?: (error: unknown) => void;
+}): ContinuousIssueAnalysisRunner;

package/dist/src/issue-analysis.js

@@ -0,0 +1,382 @@
+// @bun
+// 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 });
+    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,
+  issueAnalysisEnabled,
+  createPiIssueAnalyzer,
+  createIssueAnalysisWriteBack,
+  createIssueAnalysisService,
+  createDefaultPiIssueAnalysisCommandRunner,
+  createContinuousIssueAnalysisRunner,
+  createConfiguredIssueAnalysisRunner
+};

package/dist/src/plugin.d.ts

@@ -0,0 +1,4 @@
+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;
+export default githubProviderPlugin;

package/dist/src/plugin.js

@@ -0,0 +1,94 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/github-provider-plugin/src/credentials.ts
+function selectedRepoTokenKey(input) {
+  return `user:${input.userId}|repo:${input.owner}/${input.repo}|workspace:${input.workspaceId}`;
+}
+function cleanToken(value) {
+  const trimmed = value?.trim() ?? "";
+  return trimmed.length > 0 ? trimmed : null;
+}
+function createGitHubCredentialProvider(options = {}) {
+  const sessionTokens = options.sessionTokens ?? {};
+  const hostToken = cleanToken(options.hostToken ?? process.env.GH_TOKEN ?? null);
+  return {
+    async resolveGitHubToken(input) {
+      const owner = input.owner.trim();
+      const repo = input.repo.trim();
+      const workspaceId = input.workspaceId.trim();
+      const userId = input.userId?.trim() ?? "";
+      if (input.purpose === "selected-repo") {
+        if (!owner || !repo || !workspaceId || !userId) {
+          throw new Error("No signed-in GitHub token is available for the selected repo; sign in to GitHub for this workspace.");
+        }
+        const token = cleanToken(sessionTokens[selectedRepoTokenKey({ owner, repo, workspaceId, userId })]);
+        if (!token) {
+          throw new Error("No signed-in GitHub token is available for the selected repo; sign in to GitHub for this workspace.");
+        }
+        return { token, source: "signed-in-user" };
+      }
+      if (hostToken) {
+        return { token: hostToken, source: "host-admin-fallback" };
+      }
+      throw new Error("No host GitHub token is configured for the explicit admin fallback operation.");
+    }
+  };
+}
+var init_credentials = () => {};
+
+// packages/github-provider-plugin/src/service.ts
+var exports_service = {};
+__export(exports_service, {
+  githubProviderService: () => githubProviderService
+});
+var githubProviderService;
+var init_service = __esm(() => {
+  init_credentials();
+  githubProviderService = {
+    createCredentialProvider: (options) => createGitHubCredentialProvider(options)
+  };
+});
+
+// packages/github-provider-plugin/src/plugin.ts
+import { definePlugin } from "@rig/core/config";
+import { GITHUB_PROVIDER_CAPABILITY_ID } from "@rig/contracts";
+var GITHUB_PROVIDER_PLUGIN_NAME = "@rig/github-provider-plugin";
+var githubProviderPlugin = definePlugin({
+  name: GITHUB_PROVIDER_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  contributes: {
+    capabilities: [
+      {
+        id: GITHUB_PROVIDER_CAPABILITY_ID,
+        title: "GitHub SCM provider",
+        description: "Resolve GitHub credentials for the configured SCM provider.",
+        run: async () => (await Promise.resolve().then(() => (init_service(), exports_service))).githubProviderService
+      }
+    ]
+  }
+});
+function createGitHubProviderPlugin() {
+  return githubProviderPlugin;
+}
+var plugin_default = githubProviderPlugin;
+export {
+  githubProviderPlugin,
+  plugin_default as default,
+  createGitHubProviderPlugin,
+  GITHUB_PROVIDER_PLUGIN_NAME
+};

package/dist/src/projects.d.ts

@@ -0,0 +1,31 @@
+import type { GitHubProjectStatusField, GitHubProjectSummary } from "@rig/contracts";
+export type { GitHubProjectStatusField, GitHubProjectSummary };
+export type GitHubGraphQLFetch = (query: string, variables: Record<string, unknown>, token: string) => Promise<unknown>;
+export declare function listGitHubProjects(input: {
+    owner: string;
+    token: string;
+    first?: number;
+    fetchGraphQL?: GitHubGraphQLFetch;
+}): Promise<GitHubProjectSummary[]>;
+export declare function resolveProjectStatusField(input: {
+    projectId: string;
+    token: string;
+    fetchGraphQL?: GitHubGraphQLFetch;
+}): Promise<GitHubProjectStatusField>;
+export declare function ensureIssueProjectItem(input: {
+    projectId: string;
+    issueNodeId: string;
+    token: string;
+    fetchGraphQL?: GitHubGraphQLFetch;
+}): Promise<{
+    id: string;
+    created: boolean;
+}>;
+export declare function updateIssueProjectStatus(input: {
+    projectId: string;
+    itemId: string;
+    fieldId: string;
+    optionId: string;
+    token: string;
+    fetchGraphQL?: GitHubGraphQLFetch;
+}): Promise<void>;