@aion0/forge 0.6.1 → 0.8.0

package/lib/issue-scanner-gitlab.ts

@@ -0,0 +1,281 @@
+/**
+ * GitLab Issue Scanner — sibling of issue-scanner.ts for GitHub.
+ *
+ * Per-project config (table: issue_autofix_gitlab_config):
+ *   - enabled: boolean
+ *   - interval: minutes (0 = manual only)
+ *   - labels: string[]   filter by label (empty = all)
+ *   - baseBranch: ''     default '' (auto-resolve from milestone/label/desc/default)
+ *   - baseBranchRule: 'milestone' | 'label:<prefix>' | 'desc' | 'default'
+ *   - mrTitleTemplate: string
+ *   - mrBodyTemplate: string
+ *
+ * Triggers the `gitlab-issue-fix-and-review` builtin pipeline.
+ */
+
+import { execSync } from 'node:child_process';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+import { startPipeline } from './pipeline';
+
+function db() { return getDb(getDbPath()); }
+
+export interface GitLabAutofixConfig {
+  projectPath: string;
+  projectName: string;
+  enabled: boolean;
+  interval: number;
+  labels: string[];
+  baseBranch: string;
+  baseBranchRule: string;          // 'milestone' | 'label:<prefix>' | 'desc' | 'default'
+  mrTitleTemplate: string;
+  mrBodyTemplate: string;
+  assigneeFilter: string;          // 'me' | <username> | '' (no filter)
+}
+
+// ── DB schema ────────────────────────────────────────────
+
+export function ensureTable() {
+  db().exec(`
+    CREATE TABLE IF NOT EXISTS issue_autofix_gitlab_config (
+      project_path TEXT PRIMARY KEY,
+      project_name TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 0,
+      interval_min INTEGER NOT NULL DEFAULT 30,
+      labels TEXT NOT NULL DEFAULT '[]',
+      base_branch TEXT NOT NULL DEFAULT '',
+      base_branch_rule TEXT NOT NULL DEFAULT 'milestone',
+      mr_title_template TEXT NOT NULL DEFAULT '',
+      mr_body_template TEXT NOT NULL DEFAULT '',
+      assignee_filter TEXT NOT NULL DEFAULT 'me',
+      last_scan_at TEXT
+    );
+    CREATE TABLE IF NOT EXISTS issue_autofix_gitlab_processed (
+      project_path TEXT NOT NULL,
+      issue_iid INTEGER NOT NULL,
+      pipeline_id TEXT,
+      mr_iid INTEGER,
+      status TEXT NOT NULL DEFAULT 'processing',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (project_path, issue_iid)
+    );
+  `);
+}
+
+// ── CRUD ────────────────────────────────────────────────
+
+export function getConfig(projectPath: string): GitLabAutofixConfig | null {
+  ensureTable();
+  const row = db().prepare('SELECT * FROM issue_autofix_gitlab_config WHERE project_path = ?').get(projectPath) as any;
+  if (!row) return null;
+  return {
+    projectPath: row.project_path,
+    projectName: row.project_name,
+    enabled: !!row.enabled,
+    interval: row.interval_min,
+    labels: JSON.parse(row.labels || '[]'),
+    baseBranch: row.base_branch || '',
+    baseBranchRule: row.base_branch_rule || 'milestone',
+    mrTitleTemplate: row.mr_title_template || '',
+    mrBodyTemplate: row.mr_body_template || '',
+    assigneeFilter: row.assignee_filter || 'me',
+  };
+}
+
+export function saveConfig(c: GitLabAutofixConfig): void {
+  ensureTable();
+  db().prepare(`
+    INSERT OR REPLACE INTO issue_autofix_gitlab_config
+      (project_path, project_name, enabled, interval_min, labels, base_branch, base_branch_rule, mr_title_template, mr_body_template, assignee_filter)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    c.projectPath, c.projectName, c.enabled ? 1 : 0, c.interval,
+    JSON.stringify(c.labels || []), c.baseBranch || '', c.baseBranchRule || 'milestone',
+    c.mrTitleTemplate || '', c.mrBodyTemplate || '', c.assigneeFilter || 'me',
+  );
+  refreshTimer(c);
+}
+
+export function listConfigs(): GitLabAutofixConfig[] {
+  ensureTable();
+  return (db().prepare('SELECT * FROM issue_autofix_gitlab_config').all() as any[]).map(r => ({
+    projectPath: r.project_path, projectName: r.project_name,
+    enabled: !!r.enabled, interval: r.interval_min,
+    labels: JSON.parse(r.labels || '[]'),
+    baseBranch: r.base_branch || '', baseBranchRule: r.base_branch_rule || 'milestone',
+    mrTitleTemplate: r.mr_title_template || '', mrBodyTemplate: r.mr_body_template || '',
+    assigneeFilter: r.assignee_filter || 'me',
+  }));
+}
+
+// ── GitLab remote parsing ──────────────────────────────
+
+function gitRemote(projectPath: string): string | null {
+  try {
+    return execSync(`git -C "${projectPath}" remote get-url origin`, { encoding: 'utf8', timeout: 3000 }).trim();
+  } catch { return null; }
+}
+
+/** Resolve <namespace>/<project> path from origin URL. Returns null if not a GitLab remote we can talk to. */
+function projectPathFromRemote(remote: string): string | null {
+  // git@host:group/sub/project.git  OR  https://host/group/sub/project(.git)
+  const cleaned = remote
+    .replace(/^https?:\/\/[^/]+\//, '')
+    .replace(/^git@[^:]+:/, '')
+    .replace(/\.git$/, '');
+  if (!cleaned.includes('/')) return null;
+  return cleaned;
+}
+
+// ── Fetch issues via glab ──────────────────────────────
+
+function fetchOpenIssues(projectPath: string, c: GitLabAutofixConfig): { iid: number; title: string; error?: string }[] {
+  const remote = gitRemote(projectPath);
+  if (!remote) return [{ iid: -1, title: '', error: 'No git remote configured' }];
+  const projPath = projectPathFromRemote(remote);
+  if (!projPath) return [{ iid: -1, title: '', error: `Unrecognized git remote: ${remote}` }];
+
+  const labelFilter = c.labels.length > 0 ? ` --label "${c.labels.join(',')}"` : '';
+  const assigneeFilter = c.assigneeFilter === 'me' ? ' --assignee="@me"'
+    : c.assigneeFilter ? ` --assignee="${c.assigneeFilter}"` : '';
+
+  try {
+    const out = execSync(
+      `glab issue list --state opened -R "${projPath}"${labelFilter}${assigneeFilter} --output json`,
+      { encoding: 'utf8', timeout: 30000, cwd: projectPath },
+    );
+    const parsed = JSON.parse(out);
+    return (Array.isArray(parsed) ? parsed : []).map((it: any) => ({
+      iid: Number(it.iid ?? it.id ?? -1),
+      title: it.title || '',
+    }));
+  } catch (e: any) {
+    const msg = e.stderr?.toString() || e.message || 'glab CLI failed';
+    if (/not authenticated|auth/i.test(msg)) {
+      return [{ iid: -1, title: '', error: 'glab CLI not authenticated. Run: glab auth login' }];
+    }
+    if (/glab.*not found|command not found/i.test(msg)) {
+      return [{ iid: -1, title: '', error: 'glab CLI not installed. brew install glab && glab auth login' }];
+    }
+    return [{ iid: -1, title: '', error: msg }];
+  }
+}
+
+// ── Dedup state ────────────────────────────────────────
+
+function isProcessed(projectPath: string, iid: number): boolean {
+  return !!db().prepare('SELECT 1 FROM issue_autofix_gitlab_processed WHERE project_path = ? AND issue_iid = ?').get(projectPath, iid);
+}
+
+function markProcessed(projectPath: string, iid: number, pipelineId: string): void {
+  db().prepare(`
+    INSERT OR REPLACE INTO issue_autofix_gitlab_processed (project_path, issue_iid, pipeline_id, status)
+    VALUES (?, ?, ?, 'processing')
+  `).run(projectPath, iid, pipelineId);
+}
+
+export function updateProcessedStatus(projectPath: string, iid: number, status: string, mrIid?: number): void {
+  if (mrIid != null) {
+    db().prepare('UPDATE issue_autofix_gitlab_processed SET status = ?, mr_iid = ? WHERE project_path = ? AND issue_iid = ?')
+      .run(status, mrIid, projectPath, iid);
+  } else {
+    db().prepare('UPDATE issue_autofix_gitlab_processed SET status = ? WHERE project_path = ? AND issue_iid = ?')
+      .run(status, projectPath, iid);
+  }
+}
+
+export function resetProcessedIssue(projectPath: string, iid: number): void {
+  db().prepare('DELETE FROM issue_autofix_gitlab_processed WHERE project_path = ? AND issue_iid = ?').run(projectPath, iid);
+}
+
+export function getProcessedIssues(projectPath: string): { issueIid: number; pipelineId: string; mrIid: number | null; status: string; createdAt: string }[] {
+  ensureTable();
+  return (db().prepare('SELECT * FROM issue_autofix_gitlab_processed WHERE project_path = ? ORDER BY created_at DESC').all(projectPath) as any[]).map(r => ({
+    issueIid: r.issue_iid, pipelineId: r.pipeline_id,
+    mrIid: r.mr_iid, status: r.status, createdAt: r.created_at,
+  }));
+}
+
+// ── Scan + trigger ─────────────────────────────────────
+
+function saveLastScan(projectPath: string) {
+  const now = Date.now();
+  scannerState.lastScan.set(projectPath, now);
+  try { db().prepare('UPDATE issue_autofix_gitlab_config SET last_scan_at = ? WHERE project_path = ?').run(new Date(now).toISOString(), projectPath); } catch {}
+}
+
+function loadLastScan(projectPath: string): number | null {
+  try {
+    const row = db().prepare('SELECT last_scan_at FROM issue_autofix_gitlab_config WHERE project_path = ?').get(projectPath) as any;
+    return row?.last_scan_at ? new Date(row.last_scan_at).getTime() : null;
+  } catch { return null; }
+}
+
+export function scanAndTrigger(c: GitLabAutofixConfig): { triggered: number; issues: number[]; total: number; error?: string } {
+  saveLastScan(c.projectPath);
+  const issues = fetchOpenIssues(c.projectPath, c);
+  if (issues.length === 1 && (issues[0] as any).error) {
+    return { triggered: 0, issues: [], total: 0, error: (issues[0] as any).error };
+  }
+  const triggered: number[] = [];
+  for (const it of issues) {
+    if (it.iid < 0 || isProcessed(c.projectPath, it.iid)) continue;
+    try {
+      const pipeline = startPipeline('gitlab-issue-fix-and-review', {
+        issue_id: String(it.iid),
+        project: c.projectName,
+        base_branch: c.baseBranch || 'auto',
+        base_branch_rule: c.baseBranchRule || 'milestone',
+        mr_title_template: c.mrTitleTemplate || '',
+        mr_body_template: c.mrBodyTemplate || '',
+      });
+      markProcessed(c.projectPath, it.iid, pipeline.id);
+      triggered.push(it.iid);
+      console.log(`[gl-issue-scanner] Triggered fix for !${it.iid} "${it.title}" in ${c.projectName} (pipeline: ${pipeline.id})`);
+    } catch (e) {
+      console.error(`[gl-issue-scanner] Failed to trigger for !${it.iid}:`, e);
+    }
+  }
+  return { triggered: triggered.length, issues: triggered, total: issues.length };
+}
+
+// ── Periodic scanner ───────────────────────────────────
+
+const scannerKey = Symbol.for('forge-issue-scanner-gitlab');
+const gAny = globalThis as any;
+if (!gAny[scannerKey]) gAny[scannerKey] = { timers: new Map<string, NodeJS.Timeout>(), started: false, lastScan: new Map<string, number>() };
+const scannerState = gAny[scannerKey] as { timers: Map<string, NodeJS.Timeout>; started: boolean; lastScan: Map<string, number> };
+
+function refreshTimer(c: GitLabAutofixConfig) {
+  const existing = scannerState.timers.get(c.projectPath);
+  if (existing) { clearInterval(existing); scannerState.timers.delete(c.projectPath); }
+  if (!c.enabled || c.interval <= 0) return;
+  const intervalMs = c.interval * 60 * 1000;
+  const dbLast = loadLastScan(c.projectPath);
+  if (dbLast) scannerState.lastScan.set(c.projectPath, dbLast);
+  else scannerState.lastScan.set(c.projectPath, Date.now());
+  const elapsed = Date.now() - (scannerState.lastScan.get(c.projectPath) || 0);
+  const firstDelay = Math.max(0, intervalMs - elapsed);
+  setTimeout(() => {
+    try { const cfg = getConfig(c.projectPath); if (cfg?.enabled) scanAndTrigger(cfg); } catch {}
+    const timer = setInterval(() => {
+      const cfg = getConfig(c.projectPath);
+      if (!cfg || !cfg.enabled) return;
+      try { scanAndTrigger(cfg); } catch {}
+    }, intervalMs);
+    scannerState.timers.set(c.projectPath, timer);
+  }, firstDelay);
+}
+
+export function startScanner() {
+  if (scannerState.started) return;
+  scannerState.started = true;
+  ensureTable();
+  for (const c of listConfigs()) refreshTimer(c);
+}
+
+export function stopScanner() {
+  for (const t of scannerState.timers.values()) clearInterval(t);
+  scannerState.timers.clear();
+  scannerState.started = false;
+}

package/lib/jobs/dispatcher.ts

@@ -0,0 +1,217 @@
+/**
+ * Per-item dispatch: take one new item from a Job's connector result and
+ * either trigger a Pipeline run or post a message to a Chat session.
+ *
+ * Template syntax: `{{item.<dotted.path>}}` — see docs/Jobs-Design.md §
+ * Template syntax.
+ */
+
+import type { PipelineDispatchParams, ChatDispatchParams } from './types';
+import { triggerPipeline } from '../pipeline-scheduler';
+
+const CHAT_PORT = Number(process.env.CHAT_PORT) || 8408;
+
+// ─── Template rendering ───────────────────────────────────
+
+function pickPath(obj: unknown, path: string): unknown {
+  if (!path) return obj;
+  const parts = path.split('.');
+  let cur: any = obj;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== 'object') return undefined;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function renderValue(v: unknown): string {
+  if (v == null) return '';
+  if (typeof v === 'string') return v;
+  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+  try { return JSON.stringify(v); } catch { return ''; }
+}
+
+export function renderTemplate(template: string, item: unknown): string {
+  return template.replace(/\{\{\s*item(?:\.([^}\s]+))?\s*\}\}/g, (_, path) => {
+    const v = path ? pickPath(item, path) : item;
+    return renderValue(v);
+  });
+}
+
+function renderTemplateMap(map: Record<string, string>, item: unknown): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(map)) {
+    out[k] = renderTemplate(v, item);
+  }
+  return out;
+}
+
+// ─── Pipeline dispatch ────────────────────────────────────
+
+/**
+ * Trigger a pipeline run for one new item. `dedupKey` is the Job's per-item
+ * key — purely for the audit row in job_dispatches. We DO NOT forward it to
+ * triggerPipeline's own dedup column: Jobs already enforce de-duplication
+ * at job_seen, and pipeline_runs has a UNIQUE constraint on
+ * (project_path, workflow_name, dedup_key) that would block any 'Reset
+ * dedup → Run now' replay (the row from the old run still occupies the
+ * slot). Letting pipeline_runs.dedup_key be NULL means each dispatch
+ * gets its own row.
+ */
+export function dispatchToPipeline(params: PipelineDispatchParams, item: unknown, _dedupKey: string): { target_id: string; rendered_input: Record<string, string>; empty_keys: string[] } {
+  const renderedInput = renderTemplateMap(params.input_template || {}, item);
+  // Heads-up if a template key rendered to empty — almost always means the
+  // user wrote {{item.foo}} but the item has no 'foo' field. The pipeline
+  // node usually exits 1 with "ERROR: <key> is required" which is hard to
+  // act on without knowing where the empty came from.
+  const emptyKeys: string[] = [];
+  for (const [k, v] of Object.entries(renderedInput)) {
+    if (!String(v ?? '').trim()) emptyKeys.push(k);
+  }
+  if (emptyKeys.length > 0) {
+    console.warn(
+      `[jobs] dispatchToPipeline: ${emptyKeys.length} key(s) rendered to empty — ` +
+      `pipeline will likely fail. keys=${emptyKeys.join(', ')}. ` +
+      `Check the job's input_template — '{{item.X}}' values resolve to empty if X isn't on the item.`,
+    );
+  }
+  const result = triggerPipeline(
+    params.project_path,
+    params.project_name,
+    params.workflow_name,
+    renderedInput,
+    // intentionally no dedup_key — see comment above
+  );
+  return { target_id: result.pipelineId, rendered_input: renderedInput, empty_keys: emptyKeys };
+}
+
+// ─── Chat dispatch ────────────────────────────────────────
+
+async function chatHttp(path: string, body?: unknown): Promise<any> {
+  const res = await fetch(`http://127.0.0.1:${CHAT_PORT}${path}`, {
+    method: body ? 'POST' : 'GET',
+    headers: { 'content-type': 'application/json' },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  if (!res.ok && res.status !== 202) {
+    throw new Error(`chat ${path}: HTTP ${res.status} ${(await res.text().catch(() => '')).slice(0, 200)}`);
+  }
+  if (res.status === 204) return null;
+  return res.json();
+}
+
+/** Resolve the user's persistent main session id (creates if missing). */
+async function getMainSessionId(): Promise<string> {
+  const r = await chatHttp('/api/sessions/main');
+  const id = String(r?.session?.id || '');
+  if (!id) throw new Error('main session lookup returned no id');
+  return id;
+}
+
+/**
+ * Per-job in-memory map of reused chat sessions, so all items in a `reuse_session: true`
+ * job append to one session. Lives in this module (one per Next.js worker).
+ */
+const reusedSessionByJob = new Map<string, string>();
+
+export async function dispatchToChat(params: ChatDispatchParams, item: unknown, jobId: string): Promise<{ target_id: string }> {
+  let sessionId: string | undefined;
+  if (params.target === 'main') {
+    sessionId = await getMainSessionId();
+  } else if (params.reuse_session) {
+    sessionId = reusedSessionByJob.get(jobId);
+  }
+
+  if (!sessionId) {
+    const title = params.session_title_template
+      ? renderTemplate(params.session_title_template, item)
+      : 'Job dispatch';
+    const created = await chatHttp('/api/sessions', {
+      title,
+      provider: params.agent_profile,
+      meta: { kind: 'temp', source: `job:${jobId}` },
+    });
+    sessionId = String(created?.session?.id || '');
+    if (!sessionId) throw new Error('chat session create returned no id');
+    if (params.reuse_session) reusedSessionByJob.set(jobId, sessionId);
+  }
+
+  const text = renderTemplate(params.message_template, item);
+  if (!text.trim()) throw new Error('rendered chat message is empty');
+  await chatHttp(`/api/sessions/${encodeURIComponent(sessionId)}/messages`, { text });
+  return { target_id: sessionId };
+}
+
+/**
+ * Summary-mode dispatch — fold ALL new items in this tick into ONE message
+ * sent to a single chat session. Lets the LLM analyze + summarize whatever
+ * came back from the connector instead of getting only the first item.
+ *
+ * message_template placeholders specific to this mode:
+ *   {{items}}       — JSON.stringify of the full items array
+ *   {{items_text}}  — one line per item ("id. title")
+ *   {{count}}       — items.length
+ * {{item.X}} also still works against items[0] for header lines like
+ * "Today's report for {{item.project}}".
+ */
+export async function dispatchToChatSummary(
+  params: ChatDispatchParams,
+  items: unknown[],
+  jobId: string,
+  opts: { totalMatching?: number | string | null } = {},
+): Promise<{ target_id: string; count: number }> {
+  let sessionId: string | undefined;
+  // Default target for summary mode is the main chat — that's where the
+  // user's agent already lives. They don't want a new chat tab per tick.
+  const target = params.target ?? 'main';
+  if (target === 'main') {
+    sessionId = await getMainSessionId();
+  } else if (params.reuse_session) {
+    sessionId = reusedSessionByJob.get(jobId);
+  }
+
+  if (!sessionId) {
+    const title = params.session_title_template
+      ? renderTemplate(params.session_title_template, items[0] ?? {})
+      : `Job summary (${items.length})`;
+    const created = await chatHttp('/api/sessions', {
+      title, provider: params.agent_profile,
+      meta: { kind: 'temp', source: `job:${jobId}` },
+    });
+    sessionId = String(created?.session?.id || '');
+    if (!sessionId) throw new Error('chat session create returned no id');
+    if (params.reuse_session) reusedSessionByJob.set(jobId, sessionId);
+  }
+
+  const itemsJson = JSON.stringify(items, null, 2);
+  const itemsText = items.map((it, i) => {
+    if (it && typeof it === 'object') {
+      const o = it as Record<string, unknown>;
+      const id = o.id ?? o.iid ?? o.number ?? (i + 1);
+      const title = o.title || o.summary || o.name || '';
+      return title ? `${id}. ${title}` : `${id}.`;
+    }
+    return `${i + 1}. ${String(it)}`;
+  }).join('\n');
+
+  let text = String(params.message_template || '');
+  text = text.replace(/\{\{\s*items\s*\}\}/g, itemsJson);
+  text = text.replace(/\{\{\s*items_text\s*\}\}/g, itemsText);
+  // {{count}} = items shown in this dispatch (after dedup + limit).
+  // {{total_matching}} = how many matched the filter server-side. Useful
+  // when the connector returned only first N (e.g. mantis limit=20 but
+  // 151 bugs match — caller wants "20 of 151 …").
+  text = text.replace(/\{\{\s*count\s*\}\}/g, String(items.length));
+  const tm = opts.totalMatching;
+  text = text.replace(/\{\{\s*total_matching\s*\}\}/g, tm != null ? String(tm) : String(items.length));
+  // {{item.X}} → first item, so "header" lines work the same way as per-item mode
+  text = renderTemplate(text, items[0] ?? {});
+
+  if (!text.trim()) throw new Error('rendered chat summary message is empty');
+  await chatHttp(`/api/sessions/${encodeURIComponent(sessionId)}/messages`, { text });
+  return { target_id: sessionId, count: items.length };
+}
+
+export function clearReusedSession(jobId: string): void {
+  reusedSessionByJob.delete(jobId);
+}