forge-workflow 0.0.9 → 0.1.0-beta.2

package/lib/adapters/greptile-review-adapter.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const { execFileSync } = require('node:child_process');
+const { ReviewAdapter } = require('../review-adapter');
+
+function getReviewThreadNodes(payload) {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+
+  return payload?.data?.repository?.pullRequest?.reviewThreads?.nodes
+    || payload?.repository?.pullRequest?.reviewThreads?.nodes
+    || payload?.reviewThreads?.nodes
+    || payload?.nodes
+    || [];
+}
+
+function getFirstComment(thread) {
+  return thread?.comments?.nodes?.[0] || {};
+}
+
+class GreptileReviewAdapter extends ReviewAdapter {
+  constructor(options = {}) {
+    super({
+      id: options.id || 'greptile',
+      kind: 'review',
+      name: options.name || 'Greptile Review Adapter',
+      version: options.version,
+    });
+    this.authorPrefix = options.authorPrefix ?? 'greptile-apps';
+    this.github = options.github;
+  }
+
+  async fetchThreads(context = {}) {
+    if (this.github && typeof this.github.fetchThreads === 'function') {
+      return this.github.fetchThreads(context);
+    }
+    throw new Error('greptile.fetchThreads requires a GitHub client');
+  }
+
+  parse(payload, options = {}) {
+    const includeResolved = options.includeResolved === true;
+    const authorPrefix = options.authorPrefix ?? this.authorPrefix;
+
+    return getReviewThreadNodes(payload)
+      .filter((thread) => includeResolved || thread?.isResolved === false)
+      .map((thread) => {
+        const comment = getFirstComment(thread);
+        return {
+          id: thread.id,
+          commentId: comment.databaseId || comment.id,
+          file: comment.path,
+          line: comment.line || 0,
+          body: comment.body || '',
+          author: comment.author?.login || 'unknown',
+          isResolved: Boolean(thread.isResolved),
+          raw: thread,
+        };
+      })
+      .filter((thread) => thread.author.startsWith(authorPrefix))
+      .filter((thread) => Boolean(thread.file));
+  }
+
+  async reply(context = {}) {
+    if (this.github && typeof this.github.reply === 'function') {
+      return this.github.reply(context);
+    }
+    throw new Error('greptile.reply requires a GitHub client');
+  }
+
+  async resolve(context = {}) {
+    if (this.github && typeof this.github.resolve === 'function') {
+      return this.github.resolve(context);
+    }
+    throw new Error('greptile.resolve requires a GitHub client');
+  }
+
+  score(threads, context = {}) {
+    return matchThreadsToCommitsWithGit(threads, context.projectRoot || process.cwd(), context);
+  }
+}
+
+function matchThreadsToCommitsWithGit(threads, projectRoot, opts = {}) {
+  if (!threads || threads.length === 0) {
+    return [];
+  }
+
+  const exec = opts._exec || ((cmd, args) => {
+    return execFileSync(cmd, args, { encoding: 'utf8' });
+  });
+
+  let sinceCommit = opts.sinceCommit;
+  if (!sinceCommit) {
+    try {
+      sinceCommit = exec('git', ['-C', projectRoot, 'merge-base', 'HEAD', 'main']).trim();
+    } catch (_e) { // NOSONAR S2486
+      try {
+        sinceCommit = exec('git', ['-C', projectRoot, 'merge-base', 'HEAD', 'master']).trim();
+      } catch (_e2) { // NOSONAR S2486
+        sinceCommit = null;
+      }
+    }
+  }
+
+  return threads.map((thread) => {
+    const { file, line } = thread;
+
+    try {
+      const logArgs = [
+        '-C', projectRoot,
+        'log',
+        '--oneline',
+        '--follow',
+      ];
+      if (sinceCommit) {
+        logArgs.push(`${sinceCommit}..HEAD`);
+      }
+      logArgs.push('--', file);
+
+      const output = exec('git', logArgs);
+      const trimmed = (output || '').trim();
+
+      if (!trimmed) {
+        return { file, line, resolved: false, reason: 'no matching commit' };
+      }
+
+      const firstLine = trimmed.split('\n')[0];
+      const sha = firstLine.split(' ')[0];
+
+      return { file, line, resolved: true, sha };
+    } catch (_err) { // NOSONAR S2486
+      return { file, line, resolved: false, reason: 'no matching commit' };
+    }
+  });
+}
+
+module.exports = {
+  GreptileReviewAdapter,
+  getReviewThreadNodes,
+  matchThreadsToCommitsWithGit,
+};

package/lib/adapters/kernel-issue-adapter.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const {
+	IssueAdapter,
+	decideIssueAuthority,
+	normalizeIssueStatus,
+} = require('../issue-adapter.js');
+
+const KERNEL_ISSUE_OPERATIONS = Object.freeze({
+	list: 'list',
+	ready: 'ready',
+	search: 'search',
+	stats: 'stats',
+	blocked: 'blocked',
+	stale: 'stale',
+	orphans: 'orphans',
+	lint: 'lint',
+	children: 'children',
+	owns: 'owns',
+	claims: 'claims',
+	read: 'show',
+	show: 'show',
+	create: 'create',
+	update: 'update',
+	claim: 'claim',
+	release: 'release',
+	close: 'close',
+	comment: 'comment',
+	dep: 'dep',
+	depAdd: 'dep.add',
+	depRemove: 'dep.remove',
+});
+
+// The CLI dep surface is `forge issue dep <add|remove> <ids...>`. The adapter
+// exposes one `dep` operation that the de-beaded _issue.js routes to via a single
+// runIssueOperation('dep', ...) call; the leading action selects the broker's
+// guarded dep.add / dep.remove mutation.
+const DEP_ACTION_OPERATIONS = Object.freeze({
+	add: 'dep.add',
+	remove: 'dep.remove',
+});
+
+class KernelIssueAdapter extends IssueAdapter {
+	constructor(options = {}) {
+		super({
+			id: options.id || 'kernel-local',
+			kind: 'issue',
+			name: options.name || 'Forge Kernel Local Issue Adapter',
+			version: options.version || '0.1.0',
+		});
+		this.broker = options.broker;
+	}
+
+	run(operation, args = [], context = {}) {
+		if (!this.broker || typeof this.broker.runIssueOperation !== 'function') {
+			throw new TypeError('KernelIssueAdapter requires a broker with runIssueOperation()');
+		}
+
+		return this.broker.runIssueOperation(operation, args, context);
+	}
+
+	// Dispatch `forge issue dep <add|remove> <ids...>`: the leading positional is the
+	// action, the remaining args are the endpoint ids passed straight to the broker's
+	// dep.add / dep.remove guarded mutation. An unknown action returns a contract-shaped
+	// failure without touching the broker.
+	dep(args = [], context = {}) {
+		const [action, ...rest] = args;
+		const operation = DEP_ACTION_OPERATIONS[action];
+		if (!operation) {
+			return Promise.resolve({
+				success: false,
+				error: `Unsupported dependency action: ${action || '(missing)'}. Usage: forge issue dep <add|remove> <issue-id> <blocks-issue-id>`,
+			});
+		}
+		return this.run(operation, rest, context);
+	}
+
+	mapStatus(status, context = {}) {
+		return normalizeIssueStatus(status, context);
+	}
+
+	decideAuthority(change = {}, context = {}) {
+		return decideIssueAuthority(change, context);
+	}
+}
+
+for (const [methodName, operation] of Object.entries(KERNEL_ISSUE_OPERATIONS)) {
+	// `dep` has a hand-written dispatcher above (it parses a leading action); the
+	// generic 1:1 passthrough would clobber it, so skip it here.
+	if (methodName === 'dep') {
+		continue;
+	}
+	KernelIssueAdapter.prototype[methodName] = function issueOperation(args = [], context = {}) {
+		return this.run(operation, args, context);
+	};
+}
+
+module.exports = {
+	KERNEL_ISSUE_OPERATIONS,
+	KernelIssueAdapter,
+};