pi-project-gate 1.0.0 → 1.2.0

package/src/tools/issues.ts

@@ -0,0 +1,328 @@
+import { Type } from "typebox";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../config";
+import { resolveGitea, giteaApi } from "../helpers";
+import { validateIssueTemplate } from "../validate";
+
+// ─── Create Issue ───────────────────────────────────────────────────────────────
+
+export const createTool = {
+  name: "project_create_issue" as const,
+  label: "Create Issue",
+  description:
+    "Create a new issue with structured body. Validates required template sections before creation.",
+  parameters: Type.Object({
+    title: Type.String({ description: "Issue title" }),
+    body: Type.String({ description: "Issue body in markdown (must include required sections)" }),
+    labels: Type.Optional(Type.Array(Type.String({}), { description: "Labels to apply" })),
+    milestone: Type.Optional(Type.String({ description: "Milestone title or ID" })),
+    assignee: Type.Optional(Type.String({ description: "Username to assign" })),
+  }),
+  async execute(_id: string, params: any, _s: any, _u: any, ctx: ExtensionContext) {
+    const config = loadConfig(ctx.cwd);
+    const opts = resolveGitea(ctx.cwd);
+
+    // Validate template
+    const tpl = validateIssueTemplate(params.body, config);
+    if (!tpl.ok) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `❌ Issue body is missing required sections:\n  - ${tpl.missingSections.join("\n  - ")}`,
+          },
+        ],
+        isError: true,
+        details: { missingSections: tpl.missingSections },
+      };
+    }
+
+    // Detect complexity from body
+    const complexity = config.complexityLevels.find((l) =>
+      params.body.toLowerCase().includes(l.toLowerCase()),
+    );
+
+    // Build payload
+    const payload: Record<string, unknown> = {
+      title: params.title,
+      body: params.body,
+    };
+    if (params.labels && params.labels.length > 0) payload.labels = params.labels;
+    if (params.milestone) payload.milestone = params.milestone;
+    if (params.assignee) payload.assignee = params.assignee;
+
+    const r = giteaApi("/issues", "POST", payload, opts, ctx.cwd);
+    if (!r.ok || !r.data) {
+      return {
+        content: [{ type: "text", text: `❌ Failed to create issue: ${r.error || "unknown error"}` }],
+        isError: true,
+        details: {},
+      };
+    }
+
+    const issue = r.data as Record<string, unknown>;
+    const lines = [
+      `✅ Issue #${issue.number} created: "${issue.title}"`,
+      `   URL: ${issue.html_url || `http://127.0.0.1:3001/${opts.repo}/issues/${issue.number}`}`,
+    ];
+    if (complexity) lines.push(`   Complexity: ${complexity}`);
+    if (params.labels?.length) lines.push(`   Labels: ${params.labels.join(", ")}`);
+    if (params.milestone) lines.push(`   Milestone: ${params.milestone}`);
+    if (params.assignee) lines.push(`   Assignee: ${params.assignee}`);
+
+    return {
+      content: [{ type: "text", text: lines.join("\n") }],
+      details: { issueId: issue.number, url: issue.html_url },
+    };
+  },
+};
+
+// ─── Update Issue ───────────────────────────────────────────────────────────────
+
+export const updateTool = {
+  name: "project_update_issue" as const,
+  label: "Update Issue",
+  description:
+    "Update an existing issue — title, body, state (open/closed), labels, milestone, or assignee.",
+  parameters: Type.Object({
+    issue_id: Type.String({ description: "Issue number or ID" }),
+    title: Type.Optional(Type.String({ description: "New title" })),
+    body: Type.Optional(Type.String({ description: "New body in markdown" })),
+    state: Type.Optional(
+      Type.String({ description: 'State: "open" or "closed"' }),
+    ),
+    labels: Type.Optional(Type.Array(Type.String({}), { description: "Replacement labels" })),
+    milestone: Type.Optional(Type.String({ description: "Milestone title or ID, or null to remove" })),
+    assignee: Type.Optional(Type.String({ description: "Username to assign, or empty string to unassign" })),
+  }),
+  async execute(_id: string, params: any, _s: any, _u: any, ctx: ExtensionContext) {
+    const config = loadConfig(ctx.cwd);
+    const opts = resolveGitea(ctx.cwd);
+    const issueId = String(params.issue_id).replace(/^#/, "");
+
+    // Fetch current issue to verify it exists
+    const current = giteaApi(`/issues/${issueId}`, "GET", null, opts, ctx.cwd);
+    if (!current.ok || !current.data) {
+      return {
+        content: [{ type: "text", text: `❌ Issue #${issueId} not found.` }],
+        isError: true,
+        details: {},
+      };
+    }
+
+    // Validate body template if body is being updated
+    if (params.body) {
+      const tpl = validateIssueTemplate(params.body, config);
+      if (!tpl.ok) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `❌ Updated body is missing required sections:\n  - ${tpl.missingSections.join("\n  - ")}`,
+            },
+          ],
+          isError: true,
+          details: { missingSections: tpl.missingSections },
+        };
+      }
+    }
+
+    // Build patch payload — only include fields that were provided
+    const payload: Record<string, unknown> = {};
+    if (params.title !== undefined) payload.title = params.title;
+    if (params.body !== undefined) payload.body = params.body;
+    if (params.state !== undefined) payload.state = params.state;
+    if (params.labels !== undefined) payload.labels = params.labels;
+    if (params.milestone !== undefined) payload.milestone = params.milestone;
+    if (params.assignee !== undefined) payload.assignee = params.assignee;
+
+    if (Object.keys(payload).length === 0) {
+      return {
+        content: [{ type: "text", text: "⚠️ No fields to update." }],
+        isError: true,
+        details: {},
+      };
+    }
+
+    const r = giteaApi(`/issues/${issueId}`, "PATCH", payload, opts, ctx.cwd);
+    if (!r.ok || !r.data) {
+      return {
+        content: [{ type: "text", text: `❌ Failed to update issue: ${r.error || "unknown error"}` }],
+        isError: true,
+        details: {},
+      };
+    }
+
+    const issue = r.data as Record<string, unknown>;
+    const changes: string[] = [];
+    if (params.title !== undefined) changes.push("title");
+    if (params.body !== undefined) changes.push("body");
+    if (params.state !== undefined) changes.push(`state → ${params.state}`);
+    if (params.labels !== undefined) changes.push("labels");
+    if (params.milestone !== undefined) changes.push("milestone");
+    if (params.assignee !== undefined) changes.push("assignee");
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `✅ Issue #${issueId} updated: "${issue.title}"\n   Changed: ${changes.join(", ")}`,
+        },
+      ],
+      details: { issueId, changed: changes },
+    };
+  },
+};
+
+// ─── List Issues ────────────────────────────────────────────────────────────────
+
+export const listTool = {
+  name: "project_list_issues" as const,
+  label: "List Issues",
+  description:
+    "Search and list issues with optional filters: state, labels, milestone, assignee, keyword, and pagination.",
+  parameters: Type.Object({
+    state: Type.Optional(Type.String({ description: 'Filter by state: "open" or "closed" (default: open)' })),
+    labels: Type.Optional(Type.String({ description: "Comma-separated label names" })),
+    milestone: Type.Optional(Type.String({ description: "Filter by milestone title" })),
+    assignee: Type.Optional(Type.String({ description: "Filter by assignee username" })),
+    q: Type.Optional(Type.String({ description: "Full-text search query (searches title + body)" })),
+    limit: Type.Optional(Type.Number({ description: "Max issues to return (default: 20, max: 100)" })),
+    page: Type.Optional(Type.Number({ description: "Page number (default: 1)" })),
+  }),
+  async execute(_id: string, params: any, _s: any, _u: any, ctx: ExtensionContext) {
+    const opts = resolveGitea(ctx.cwd);
+    const queryParts: string[] = [];
+    queryParts.push(`state=${params.state || "open"}`);
+    queryParts.push(`limit=${Math.min(params.limit || 20, 100)}`);
+    queryParts.push(`page=${params.page || 1}`);
+    if (params.labels) queryParts.push(`labels=${encodeURIComponent(params.labels)}`);
+    if (params.milestone) queryParts.push(`milestone=${encodeURIComponent(params.milestone)}`);
+    if (params.assignee) queryParts.push(`assignee=${encodeURIComponent(params.assignee)}`);
+    if (params.q) queryParts.push(`q=${encodeURIComponent(params.q)}`);
+
+    const r = giteaApi(`/issues?${queryParts.join("&")}`, "GET", null, opts, ctx.cwd);
+    if (!r.ok) {
+      return {
+        content: [{ type: "text", text: `❌ Failed to list issues: ${r.error || "unknown error"}` }],
+        isError: true,
+        details: {},
+      };
+    }
+
+    const issues = Array.isArray(r.data) ? r.data : [];
+    if (issues.length === 0) {
+      return {
+        content: [{ type: "text", text: "No issues found." }],
+        details: { count: 0 },
+      };
+    }
+
+    const lines = [`📋 Issues (${issues.length} found)`];
+    if (params.q) lines.push(`   Search: "${params.q}"`);
+    lines.push("");
+
+    for (const issue of issues as any[]) {
+      const labels =
+        issue.labels && issue.labels.length > 0
+          ? ` [${issue.labels.map((l: any) => l.name).join(", ")}]`
+          : "";
+      const assignee = issue.assignee ? ` (👤 ${issue.assignee.login})` : "";
+      lines.push(
+        `   #${issue.number} ${issue.state === "closed" ? "🔒" : "🟢"} ${issue.title}${labels}${assignee}`,
+      );
+    }
+
+    return {
+      content: [{ type: "text", text: lines.join("\n") }],
+      details: { count: issues.length, issues: issues.map((i: any) => i.number) },
+    };
+  },
+};
+
+// ─── Get Issue ───────────────────────────────────────────────────────────────────
+
+export const getTool = {
+  name: "project_get_issue" as const,
+  label: "Get Issue",
+  description:
+    "Get full details of an issue including its body, labels, milestone, assignee, and recent comments.",
+  parameters: Type.Object({
+    issue_id: Type.String({ description: "Issue number or ID" }),
+    include_comments: Type.Optional(
+      Type.Boolean({ description: "Include recent comments (default: true)" }),
+    ),
+  }),
+  async execute(_id: string, params: any, _s: any, _u: any, ctx: ExtensionContext) {
+    const opts = resolveGitea(ctx.cwd);
+    const issueId = String(params.issue_id).replace(/^#/, "");
+
+    const r = giteaApi(`/issues/${issueId}`, "GET", null, opts, ctx.cwd);
+    if (!r.ok || !r.data) {
+      return {
+        content: [{ type: "text", text: `❌ Issue #${issueId} not found.` }],
+        isError: true,
+        details: {},
+      };
+    }
+
+    const issue = r.data as Record<string, unknown>;
+    const labels = Array.isArray(issue.labels)
+      ? (issue.labels as any[]).map((l) => l.name).join(", ")
+      : "(none)";
+
+    const lines = [
+      `📋 Issue #${issueId}`,
+      `   Title: ${issue.title}`,
+      `   State: ${issue.state}  |  Created: ${String(issue.created_at).slice(0, 10)}`,
+      `   Author: ${(issue.user as any)?.login || "?"}`,
+      `   Assignee: ${(issue.assignee as any)?.login || "(unassigned)"}`,
+      `   Milestone: ${(issue.milestone as any)?.title || "(none)"}`,
+      `   Labels: ${labels}`,
+      `   URL: ${issue.html_url || `http://127.0.0.1:3001/${opts.repo}/issues/${issueId}`}`,
+      "",
+      "─── Body ───",
+      issue.body || "(empty)",
+      "",
+    ];
+
+    // Fetch comments
+    const includeComments = params.include_comments !== false;
+    if (includeComments) {
+      const cr = giteaApi(
+        `/issues/${issueId}/comments?limit=20`,
+        "GET",
+        null,
+        opts,
+        ctx.cwd,
+      );
+      const comments = Array.isArray(cr.data) ? cr.data : [];
+      if (comments.length > 0) {
+        lines.push(`─── Comments (${comments.length}) ───`);
+        for (const c of comments as any[]) {
+          const date = String(c.created_at).slice(0, 10);
+          const user = c.user?.login || "?";
+          const body = (c.body || "").split("\n").slice(0, 5).join("\n");
+          lines.push(`\n   [${date}] ${user}:`);
+          for (const bl of body.split("\n")) {
+            lines.push(`   ${bl}`);
+          }
+          if ((c.body || "").split("\n").length > 5) lines.push("   ...");
+        }
+      } else {
+        lines.push("─── Comments ───");
+        lines.push("   (none)");
+      }
+    }
+
+    return {
+      content: [{ type: "text", text: lines.join("\n") }],
+      details: {
+        issueId,
+        state: issue.state,
+        title: issue.title,
+        url: issue.html_url,
+      },
+    };
+  },
+};

package/src/tools/project.ts

@@ -0,0 +1,113 @@
+import { Type } from "typebox";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../config";
+import { exec, currentBranch, resolveGitea, giteaApi } from "../helpers";
+import { validateIssueTemplate, parseDependencies, parseConventionalCommits } from "../validate";
+
+const LABELS: Record<string, string> = { feat: "🚀 Features", fix: "🐛 Bug Fixes", perf: "⚡ Performance", refactor: "♻️ Refactoring", chore: "🔧 Chores", docs: "📝 Documentation", test: "✅ Tests", ci: "👷 CI/CD", build: "📦 Build", other: "📌 Other" };
+
+export const checkTool = {
+  name: "project_check" as const, label: "Check Issue Readiness",
+  description: "Validate that an issue is ready to be worked on.",
+  parameters: Type.Object({ issue_id: Type.String({}) }),
+  async execute(_id: string, params: any, _s: any, _u: any, ctx: ExtensionContext) {
+    const config = loadConfig(ctx.cwd); const opts = resolveGitea(ctx.cwd);
+    const issueId = params.issue_id.replace(/^#/, "");
+    const r = giteaApi(`/issues/${issueId}`, "GET", null, opts, ctx.cwd);
+    if (!r.ok || !r.data) return { content: [{ type: "text", text: `Issue #${issueId} not found.` }], isError: true, details: {} };
+    const issue = r.data as Record<string, unknown>;
+    const lines: string[] = []; const issues: string[] = [];
+    lines.push(`📋 Issue #${issueId}: ${issue.title}`);
+    const body = (issue.body as string) || "";
+    const tpl = validateIssueTemplate(body, config);
+    if (!tpl.ok) issues.push(`❌ Missing sections: ${tpl.missingSections.join(", ")}`);
+    else lines.push("   Template: ✅");
+    const complexity = config.complexityLevels.find(l => body.toLowerCase().includes(l.toLowerCase()));
+    lines.push(`   Complexity: ${complexity || "?"}`);
+    const deps = parseDependencies(body, config);
+    if (deps.length > 0) {
+      const blocked: string[] = [];
+      for (const dep of deps) { const dr = giteaApi(`/issues/${dep}`, "GET", null, opts, ctx.cwd); if (dr.ok && (dr.data as any)?.state === "open") blocked.push(dep); }
+      if (blocked.length > 0) issues.push(`🔒 Blocked by: #${blocked.join(", #")}`);
+      else lines.push("   Dependencies: ✅");
+    }
+    if (issue.assignee) issues.push(`⚠️ Assigned to ${(issue.assignee as any)?.login}`);
+    if (issues.length > 0) { lines.push(""); for (const i of issues) lines.push(`   ${i}`); }
+    const blocked = issues.some(i => i.startsWith("❌") || i.startsWith("🔒"));
+    lines.push("", blocked ? "❌ Not ready." : issues.length === 0 ? "✅ Ready!" : "⚠️ Warnings but can start.");
+    return { content: [{ type: "text", text: lines.join("\n") }], details: { ready: !blocked } };
+  },
+};
+
+export const startTool = {
+  name: "project_start" as const, label: "Start Work",
+  description: "Mark an issue as in-progress. Checks WIP limits, dependencies, template.",
+  parameters: Type.Object({ issue_id: Type.String({}) }),
+  async execute(_id: string, params: any, _s: any, _u: any, ctx: ExtensionContext) {
+    const config = loadConfig(ctx.cwd); const opts = resolveGitea(ctx.cwd);
+    const issueId = params.issue_id.replace(/^#/, "");
+    const r = giteaApi(`/issues/${issueId}`, "GET", null, opts, ctx.cwd);
+    if (!r.ok || !r.data) return { content: [{ type: "text", text: `Issue #${issueId} not found.` }], isError: true, details: {} };
+    const issue = r.data as Record<string, unknown>;
+    const body = (issue.body as string) || "";
+    const tpl = validateIssueTemplate(body, config);
+    if (!tpl.ok) return { content: [{ type: "text", text: `❌ Missing sections: ${tpl.missingSections.join(", ")}` }], isError: true, details: {} };
+    const deps = parseDependencies(body, config);
+    if (deps.length > 0) {
+      const blocked: string[] = [];
+      for (const dep of deps) { const dr = giteaApi(`/issues/${dep}`, "GET", null, opts, ctx.cwd); if (dr.ok && (dr.data as any)?.state === "open") blocked.push(dep); }
+      if (blocked.length > 0) return { content: [{ type: "text", text: `🔒 Blocked: #${blocked.join(", #")}` }], isError: true, details: {} };
+    }
+    const wipR = giteaApi("/pulls?state=open&limit=100", "GET", null, opts, ctx.cwd);
+    const prs = Array.isArray(wipR.data) ? wipR.data : [];
+    const author = (issue.user as any)?.login || "factory";
+    const currentWip = prs.filter((p: any) => p.user?.login === author).length;
+    if (currentWip >= config.maxWip) return { content: [{ type: "text", text: `⚠️ WIP limit reached (${currentWip}/${config.maxWip}).` }], isError: true, details: {} };
+    (globalThis as any).__project_issueId = issueId;
+    return { content: [{ type: "text", text: `✅ Work started on #${issueId}: "${issue.title}" (WIP ${currentWip + 1}/${config.maxWip})` }], details: { issueId } };
+  },
+};
+
+export const statusTool = {
+  name: "project_status" as const, label: "Project Status",
+  description: "Show project board — active issues, WIP, blockers.",
+  parameters: Type.Object({}),
+  async execute(_id: string, _p: any, _s: any, _u: any, ctx: ExtensionContext) {
+    const config = loadConfig(ctx.cwd); const opts = resolveGitea(ctx.cwd);
+    const lines = ["📊 Project Status", ""];
+    const wipR = giteaApi("/pulls?state=open&limit=100", "GET", null, opts, ctx.cwd);
+    const prs = Array.isArray(wipR.data) ? wipR.data : [];
+    const byAuthor: Record<string, number> = {};
+    for (const pr of prs) { const a = (pr as any).user?.login || "?"; byAuthor[a] = (byAuthor[a] || 0) + 1; }
+    lines.push(`🏗 WIP: ${prs.length} open PRs (limit: ${config.maxWip})`);
+    for (const [a, c] of Object.entries(byAuthor).sort(([, a], [, b]) => b - a)) lines.push(`   ${a}: ${c}/${config.maxWip} ${c >= config.maxWip ? "⚠️" : "✅"}`);
+    const issuesR = giteaApi("/issues?state=open&limit=10", "GET", null, opts, ctx.cwd);
+    if (issuesR.ok && Array.isArray(issuesR.data)) {
+      const assigned = (issuesR.data as any[]).filter((i: any) => i.assignee).slice(0, 5);
+      if (assigned.length > 0) { lines.push("", "In Progress:"); for (const i of assigned) lines.push(`   - #${i.number} [${i.assignee?.login}] ${i.title}`); }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }], details: {} };
+  },
+};
+
+export const releaseTool = {
+  name: "project_release_notes" as const, label: "Generate Release Notes",
+  description: "Generate release notes from conventional commits.",
+  parameters: Type.Object({ from: Type.Optional(Type.String({})), to: Type.Optional(Type.String({})) }),
+  async execute(_id: string, params: any, _s: any, _u: any, ctx: ExtensionContext) {
+    const config = loadConfig(ctx.cwd);
+    let from = params.from || exec("git describe --tags --abbrev=0 2>/dev/null || echo ''", ctx.cwd).stdout;
+    const to = params.to || "HEAD";
+    if (!from) from = exec("git rev-list --max-parents=0 HEAD", ctx.cwd).stdout;
+    const range = from ? `${from}..${to}` : to;
+    const log = exec(`git log ${range} --format="commit %H%n%B%n---" --no-merges`, ctx.cwd);
+    const commits = parseConventionalCommits(log.stdout || "");
+    const sections: Record<string, string[]> = {};
+    for (const g of config.releaseNoteGroups) sections[g] = [];
+    sections["other"] = [];
+    for (const c of commits) { const prefix = config.releaseNoteIncludeHashes ? `- ${c.hash} ` : "- "; const line = `${prefix}${c.scope ? `**${c.scope}**: ` : ""}${c.subject}`; (sections[c.type] || sections["other"]).push(line); }
+    const lines = [`# Release ${to} (${new Date().toISOString().split("T")[0]})`, ""];
+    for (const [group, entries] of Object.entries(sections)) { if (entries.length === 0) continue; lines.push(`### ${LABELS[group] || group}`, ""); for (const e of entries) lines.push(e); lines.push(""); }
+    return { content: [{ type: "text", text: lines.join("\n") }], details: {} };
+  },
+};

package/src/validate.ts

@@ -0,0 +1,31 @@
+import type { ProjectConfig } from "./config";
+
+export function validateIssueTemplate(body: string, config: ProjectConfig): { ok: true } | { ok: false; missingSections: string[] } {
+  const missing = config.requiredSections.filter(s => !body.includes(s));
+  return missing.length > 0 ? { ok: false, missingSections: missing } : { ok: true };
+}
+
+export function parseDependencies(body: string, config: ProjectConfig): string[] {
+  const pattern = new RegExp(config.dependencyPattern, "gi");
+  const deps = new Set<string>();
+  let match;
+  while ((match = pattern.exec(body)) !== null) deps.add(match[1]);
+  return [...deps];
+}
+
+export interface CommitEntry { hash: string; type: string; scope: string; subject: string; }
+
+export function parseConventionalCommits(log: string): CommitEntry[] {
+  const entries: CommitEntry[] = [];
+  const commits = log.split(/\n(?=commit )/);
+  for (const block of commits) {
+    const hashMatch = block.match(/^commit (\S+)/m);
+    if (!hashMatch) continue;
+    const subjectLine = block.split("\n").find(l => l.trim() && !l.startsWith("commit ") && !l.startsWith("Author:") && !l.startsWith("Date:"));
+    if (!subjectLine) continue;
+    const convMatch = subjectLine.trim().match(/^(feat|fix|perf|refactor|chore|docs|style|test|ci|build|revert)(?:\(([^)]+)\))?:\s(.+)$/);
+    if (!convMatch) continue;
+    entries.push({ hash: hashMatch[1].slice(0, 8), type: convMatch[1], scope: convMatch[2] || "", subject: convMatch[3].trim() });
+  }
+  return entries;
+}