mirror of
https://github.com/github/awesome-copilot.git
synced 2026-06-24 16:37:36 +00:00
github-actions[bot]
707 lines
22 KiB
JavaScript
707 lines
22 KiB
JavaScript
import { CanvasError, createCanvas, joinSession } from "@github/copilot-sdk/extension";
|
|
import http from "node:http";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { spawnSync } from "node:child_process";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
const EXTENSION_NAME = "accessibility-kanban";
|
|
const STATE_FILE_PREFIX = "repository-issues-kanban-state";
|
|
const COLUMNS = ["backlog", "plan", "ready", "implement", "done"];
|
|
const VALID_COLUMNS = new Set(COLUMNS);
|
|
|
|
let repoInfoCache = null;
|
|
let githubTokenCache;
|
|
let sessionRef = null;
|
|
|
|
function getWorkspaceCwd() {
|
|
return sessionRef?.workspacePath || process.cwd();
|
|
}
|
|
|
|
// ─── Repo resolution ───
|
|
|
|
function runCommand(command, args, cwd = process.cwd()) {
|
|
try {
|
|
const result = spawnSync(command, args, { cwd, encoding: "utf8" });
|
|
if (result.status === 0 && !result.error) {
|
|
return (result.stdout || "").trim();
|
|
}
|
|
} catch {
|
|
// Ignore and fall through to empty string.
|
|
}
|
|
return "";
|
|
}
|
|
|
|
function normalizeRepo(repo) {
|
|
if (typeof repo !== "string") return null;
|
|
const cleaned = repo
|
|
.trim()
|
|
.replace(/^https?:\/\/github\.com\//i, "")
|
|
.replace(/\.git$/i, "");
|
|
if (!/^[^/\s]+\/[^/\s]+$/.test(cleaned)) return null;
|
|
return cleaned;
|
|
}
|
|
|
|
function parseRepoFromRemoteUrl(remoteUrl) {
|
|
if (!remoteUrl) return null;
|
|
const cleaned = remoteUrl.trim().replace(/\.git$/i, "");
|
|
|
|
const sshMatch = cleaned.match(/^[^@]+@[^:]+:([^/]+\/[^/]+)$/);
|
|
if (sshMatch) return sshMatch[1];
|
|
|
|
const httpMatch = cleaned.match(/^https?:\/\/[^/]+\/([^/]+\/[^/]+)$/i);
|
|
if (httpMatch) return httpMatch[1];
|
|
|
|
const fallbackMatch = cleaned.match(/[:/]([^/:]+\/[^/:]+)$/);
|
|
return fallbackMatch ? fallbackMatch[1] : null;
|
|
}
|
|
|
|
function candidateCwds(preferredCwd) {
|
|
const candidates = [
|
|
preferredCwd,
|
|
sessionRef?.workspacePath,
|
|
__dirname,
|
|
path.dirname(__dirname),
|
|
path.dirname(path.dirname(__dirname)),
|
|
path.dirname(path.dirname(path.dirname(__dirname))),
|
|
process.cwd(),
|
|
].filter(Boolean);
|
|
return [...new Set(candidates)];
|
|
}
|
|
|
|
function resolveRepoFromGit(cwd) {
|
|
const gitRoot = runCommand("git", ["rev-parse", "--show-toplevel"], cwd);
|
|
if (!gitRoot) return null;
|
|
|
|
const fromGh = normalizeRepo(runCommand("gh", ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"], gitRoot));
|
|
if (fromGh) return fromGh;
|
|
|
|
const remoteUrl = runCommand("git", ["remote", "get-url", "origin"], gitRoot) || runCommand("git", ["config", "--get", "remote.origin.url"], gitRoot);
|
|
return normalizeRepo(parseRepoFromRemoteUrl(remoteUrl));
|
|
}
|
|
|
|
function resolveCurrentRepoInfo(cwd = getWorkspaceCwd()) {
|
|
const fromEnv = normalizeRepo(process.env.GITHUB_REPOSITORY || "");
|
|
if (fromEnv) return { repo: fromEnv, error: null };
|
|
|
|
for (const candidate of candidateCwds(cwd)) {
|
|
const repo = resolveRepoFromGit(candidate);
|
|
if (repo) return { repo, error: null };
|
|
}
|
|
|
|
return {
|
|
repo: "unknown/unknown",
|
|
error: "Unable to detect the current repository from this workspace.",
|
|
};
|
|
}
|
|
|
|
function getRepoInfo() {
|
|
const cwd = getWorkspaceCwd();
|
|
if (!repoInfoCache || repoInfoCache.cwd !== cwd) {
|
|
const resolved = resolveCurrentRepoInfo(cwd);
|
|
repoInfoCache = { ...resolved, cwd };
|
|
}
|
|
return repoInfoCache;
|
|
}
|
|
|
|
// ─── State persistence ───
|
|
|
|
function copilotHome() {
|
|
return process.env.COPILOT_HOME || path.join(os.homedir(), ".copilot");
|
|
}
|
|
|
|
function stateFileName(repo) {
|
|
const key = String(repo || "unknown-unknown")
|
|
.toLowerCase()
|
|
.replace(/[^\w.-]+/g, "-");
|
|
return `${STATE_FILE_PREFIX}-${key}.json`;
|
|
}
|
|
|
|
function getStatePath(repo) {
|
|
return path.join(copilotHome(), "extensions", EXTENSION_NAME, "artifacts", stateFileName(repo));
|
|
}
|
|
|
|
function ensureStateDirectory(repo) {
|
|
fs.mkdirSync(path.dirname(getStatePath(repo)), { recursive: true });
|
|
}
|
|
|
|
function defaultState(repoInfo = getRepoInfo()) {
|
|
return {
|
|
repo: repoInfo.repo,
|
|
error: repoInfo.error,
|
|
updatedAt: new Date().toISOString(),
|
|
generation: Date.now(),
|
|
columns: COLUMNS,
|
|
availableLabels: [],
|
|
selectedLabels: [],
|
|
issues: [],
|
|
};
|
|
}
|
|
|
|
function normalizeLabelList(labels) {
|
|
const unique = new Set();
|
|
for (const label of Array.isArray(labels) ? labels : []) {
|
|
if (typeof label === "string" && label.trim()) unique.add(label.trim());
|
|
}
|
|
return [...unique];
|
|
}
|
|
|
|
function computeAvailableLabels(issues) {
|
|
const labels = new Set();
|
|
for (const issue of Array.isArray(issues) ? issues : []) {
|
|
for (const label of normalizeLabelList(issue.labels)) labels.add(label);
|
|
}
|
|
return [...labels].sort((a, b) => a.localeCompare(b));
|
|
}
|
|
|
|
function normalizeIssue(issue, repo, idx) {
|
|
if (!issue || !Number.isInteger(issue.number) || !issue.title) return null;
|
|
return {
|
|
number: issue.number,
|
|
title: issue.title,
|
|
url: issue.url || `https://github.com/${repo}/issues/${issue.number}`,
|
|
labels: normalizeLabelList(issue.labels),
|
|
column: VALID_COLUMNS.has(issue.column) ? issue.column : "backlog",
|
|
priority: issue.priority || "medium",
|
|
order: Number.isInteger(issue.order) ? issue.order : idx,
|
|
agentStatus: typeof issue.agentStatus === "string" ? issue.agentStatus : "",
|
|
agentActive: Boolean(issue.agentActive),
|
|
logs: Array.isArray(issue.logs) ? issue.logs : [],
|
|
};
|
|
}
|
|
|
|
function normalizeState(rawState, repoInfo = getRepoInfo()) {
|
|
const repo = repoInfo.repo;
|
|
const issues = Array.isArray(rawState?.issues)
|
|
? rawState.issues.map((issue, idx) => normalizeIssue(issue, repo, idx)).filter(Boolean)
|
|
: [];
|
|
const availableLabels = computeAvailableLabels(issues);
|
|
|
|
return {
|
|
repo,
|
|
error: repoInfo.error || rawState?.error || null,
|
|
updatedAt: rawState?.updatedAt || new Date().toISOString(),
|
|
generation: rawState?.generation || Date.now(),
|
|
columns: Array.isArray(rawState?.columns) && rawState.columns.length ? rawState.columns : COLUMNS,
|
|
availableLabels,
|
|
selectedLabels: normalizeLabelList(rawState?.selectedLabels).filter((label) => availableLabels.includes(label)),
|
|
issues,
|
|
};
|
|
}
|
|
|
|
function loadState(repo) {
|
|
try {
|
|
return JSON.parse(fs.readFileSync(getStatePath(repo), "utf8"));
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function saveState(state) {
|
|
ensureStateDirectory(state.repo);
|
|
fs.writeFileSync(
|
|
getStatePath(state.repo),
|
|
JSON.stringify({ ...state, updatedAt: new Date().toISOString() }, null, 2),
|
|
);
|
|
}
|
|
|
|
function currentState() {
|
|
const repoInfo = getRepoInfo();
|
|
const loaded = loadState(repoInfo.repo);
|
|
const normalized = normalizeState(loaded || defaultState(repoInfo), repoInfo);
|
|
if (!loaded) saveState(normalized);
|
|
return normalized;
|
|
}
|
|
|
|
// ─── Issue operations ───
|
|
|
|
function moveIssue(issueNumber, column) {
|
|
if (!VALID_COLUMNS.has(column)) {
|
|
throw new CanvasError("invalid_column", `Column must be one of: ${COLUMNS.join(", ")}`);
|
|
}
|
|
const state = currentState();
|
|
const issue = state.issues.find((i) => i.number === issueNumber);
|
|
if (!issue) {
|
|
throw new CanvasError("not_found", `Issue #${issueNumber} not found on the board`);
|
|
}
|
|
|
|
const prevColumn = issue.column;
|
|
issue.column = column;
|
|
issue.order = state.issues.filter((i) => i.column === column).length;
|
|
|
|
if (column === "done" || column === "backlog") {
|
|
issue.agentActive = false;
|
|
issue.agentStatus = column === "done" ? "Complete" : "";
|
|
}
|
|
|
|
saveState(state);
|
|
broadcast("state", state);
|
|
return { issue, prevColumn };
|
|
}
|
|
|
|
function updateIssueStatus(issueNumber, status, logEntry) {
|
|
const state = currentState();
|
|
const issue = state.issues.find((i) => i.number === issueNumber);
|
|
if (!issue) {
|
|
throw new CanvasError("not_found", `Issue #${issueNumber} not found on the board`);
|
|
}
|
|
|
|
if (issue.column === "backlog") return issue;
|
|
|
|
if (status !== undefined) issue.agentStatus = status;
|
|
if (logEntry) {
|
|
if (!issue.logs) issue.logs = [];
|
|
issue.logs.push({ timestamp: new Date().toISOString(), message: logEntry });
|
|
}
|
|
issue.agentActive = true;
|
|
saveState(state);
|
|
broadcast("state", state);
|
|
return issue;
|
|
}
|
|
|
|
function clearAgentStatus(issueNumber) {
|
|
const state = currentState();
|
|
const issue = state.issues.find((i) => i.number === issueNumber);
|
|
if (!issue) return;
|
|
issue.agentActive = false;
|
|
saveState(state);
|
|
broadcast("state", state);
|
|
}
|
|
|
|
function replaceIssues(issues) {
|
|
const existing = currentState();
|
|
const existingByNumber = new Map(existing.issues.map((i) => [i.number, i]));
|
|
|
|
const nextIssues = (Array.isArray(issues) ? issues : [])
|
|
.filter((i) => i && Number.isInteger(i.number) && i.title)
|
|
.map((issue, idx) => {
|
|
const prev = existingByNumber.get(issue.number);
|
|
const labels = Array.isArray(issue.labels)
|
|
? issue.labels.map((l) => (typeof l === "string" ? l : l?.name)).filter(Boolean)
|
|
: [];
|
|
return {
|
|
number: issue.number,
|
|
title: issue.title,
|
|
url: issue.url || `https://github.com/${existing.repo}/issues/${issue.number}`,
|
|
labels: normalizeLabelList(labels),
|
|
column: VALID_COLUMNS.has(issue.column) ? issue.column : prev?.column || "backlog",
|
|
priority: issue.priority || prev?.priority || "medium",
|
|
order: Number.isInteger(issue.order) ? issue.order : prev?.order ?? idx,
|
|
agentStatus: prev?.agentStatus || "",
|
|
agentActive: Boolean(prev?.agentActive),
|
|
logs: Array.isArray(prev?.logs) ? prev.logs : [],
|
|
};
|
|
});
|
|
|
|
const availableLabels = computeAvailableLabels(nextIssues);
|
|
const next = {
|
|
...existing,
|
|
issues: nextIssues,
|
|
availableLabels,
|
|
selectedLabels: normalizeLabelList(existing.selectedLabels).filter((label) => availableLabels.includes(label)),
|
|
error: getRepoInfo().error,
|
|
};
|
|
saveState(next);
|
|
broadcast("state", next);
|
|
return next;
|
|
}
|
|
|
|
function setSelectedLabels(labels) {
|
|
const state = currentState();
|
|
state.selectedLabels = normalizeLabelList(labels).filter((label) => state.availableLabels.includes(label));
|
|
saveState(state);
|
|
broadcast("state", state);
|
|
return state;
|
|
}
|
|
|
|
function resetBoard() {
|
|
const state = currentState();
|
|
const reset = {
|
|
...state,
|
|
selectedLabels: [],
|
|
issues: state.issues.map((issue, idx) => ({
|
|
...issue,
|
|
column: "backlog",
|
|
order: idx,
|
|
agentStatus: "",
|
|
agentActive: false,
|
|
logs: [],
|
|
})),
|
|
};
|
|
saveState(reset);
|
|
broadcast("state", reset);
|
|
return reset;
|
|
}
|
|
|
|
// ─── GitHub issue sync ───
|
|
|
|
function resolveGitHubToken(cwd = getWorkspaceCwd()) {
|
|
if (githubTokenCache !== undefined) return githubTokenCache;
|
|
githubTokenCache = process.env.GITHUB_TOKEN || process.env.GH_TOKEN || runCommand("gh", ["auth", "token"], cwd) || "";
|
|
return githubTokenCache;
|
|
}
|
|
|
|
function mapGitHubIssue(issue) {
|
|
return {
|
|
number: issue.number,
|
|
title: issue.title,
|
|
url: issue.html_url,
|
|
labels: (issue.labels || []).map((label) => (typeof label === "string" ? label : label.name)).filter(Boolean),
|
|
};
|
|
}
|
|
|
|
async function fetchOpenIssues(repo) {
|
|
if (!repo || repo === "unknown/unknown") {
|
|
throw new CanvasError("repo_unavailable", "Current repository could not be detected.");
|
|
}
|
|
|
|
const [owner, repoName] = repo.split("/");
|
|
const token = resolveGitHubToken();
|
|
const headers = {
|
|
Accept: "application/vnd.github+json",
|
|
"User-Agent": "repository-issues-kanban",
|
|
};
|
|
if (token) headers.Authorization = `token ${token}`;
|
|
|
|
const allIssues = [];
|
|
let page = 1;
|
|
while (page <= 10) {
|
|
const params = new URLSearchParams({
|
|
state: "open",
|
|
per_page: "100",
|
|
page: String(page),
|
|
});
|
|
|
|
const response = await fetch(`https://api.github.com/repos/${owner}/${repoName}/issues?${params}`, { headers });
|
|
if (!response.ok) {
|
|
const body = await response.text();
|
|
throw new CanvasError("github_api_error", `GitHub API request failed (${response.status}): ${body.slice(0, 200)}`);
|
|
}
|
|
|
|
const pageItems = await response.json();
|
|
const mapped = pageItems
|
|
.filter((item) => !item.pull_request)
|
|
.map(mapGitHubIssue);
|
|
allIssues.push(...mapped);
|
|
|
|
if (pageItems.length < 100) break;
|
|
page += 1;
|
|
}
|
|
|
|
return allIssues;
|
|
}
|
|
|
|
function mergeFetchedIssues(existingState, fetchedIssues) {
|
|
const existingByNumber = new Map(existingState.issues.map((issue) => [issue.number, issue]));
|
|
|
|
const mergedIssues = fetchedIssues.map((issue, idx) => {
|
|
const prev = existingByNumber.get(issue.number);
|
|
return {
|
|
number: issue.number,
|
|
title: issue.title,
|
|
url: issue.url || `https://github.com/${existingState.repo}/issues/${issue.number}`,
|
|
labels: normalizeLabelList(issue.labels),
|
|
column: VALID_COLUMNS.has(prev?.column) ? prev.column : "backlog",
|
|
priority: prev?.priority || "medium",
|
|
order: Number.isInteger(prev?.order) ? prev.order : idx,
|
|
agentStatus: prev?.agentStatus || "",
|
|
agentActive: Boolean(prev?.agentActive),
|
|
logs: Array.isArray(prev?.logs) ? prev.logs : [],
|
|
};
|
|
});
|
|
|
|
const availableLabels = computeAvailableLabels(mergedIssues);
|
|
return {
|
|
...existingState,
|
|
issues: mergedIssues,
|
|
availableLabels,
|
|
selectedLabels: normalizeLabelList(existingState.selectedLabels).filter((label) => availableLabels.includes(label)),
|
|
error: getRepoInfo().error,
|
|
};
|
|
}
|
|
|
|
async function refreshIssuesSafe() {
|
|
const state = currentState();
|
|
if (state.repo === "unknown/unknown") {
|
|
saveState(state);
|
|
broadcast("state", state);
|
|
return state;
|
|
}
|
|
|
|
try {
|
|
const fetchedIssues = await fetchOpenIssues(state.repo);
|
|
const merged = mergeFetchedIssues(state, fetchedIssues);
|
|
saveState(merged);
|
|
broadcast("state", merged);
|
|
return merged;
|
|
} catch (error) {
|
|
const failed = {
|
|
...state,
|
|
error: error instanceof Error ? error.message : String(error),
|
|
};
|
|
saveState(failed);
|
|
broadcast("state", failed);
|
|
return failed;
|
|
}
|
|
}
|
|
|
|
// ─── SSE ───
|
|
|
|
const sseClients = new Set();
|
|
|
|
function broadcast(event, data) {
|
|
const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
|
|
for (const res of sseClients) res.write(msg);
|
|
}
|
|
|
|
// ─── HTTP helpers ───
|
|
|
|
function readJson(req) {
|
|
return new Promise((resolve, reject) => {
|
|
let body = "";
|
|
req.on("data", (c) => (body += c));
|
|
req.on("end", () => resolve(body ? JSON.parse(body) : {}));
|
|
req.on("error", reject);
|
|
});
|
|
}
|
|
|
|
function json(res, code, data) {
|
|
res.writeHead(code, { "Content-Type": "application/json" });
|
|
res.end(JSON.stringify(data));
|
|
}
|
|
|
|
// ─── HTTP server ───
|
|
|
|
const server = http.createServer(async (req, res) => {
|
|
const url = new URL(req.url, `http://${req.headers.host}`);
|
|
|
|
if (url.pathname === "/events") {
|
|
res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
|
|
sseClients.add(res);
|
|
req.on("close", () => sseClients.delete(res));
|
|
res.write(`event: state\ndata: ${JSON.stringify(currentState())}\n\n`);
|
|
return;
|
|
}
|
|
|
|
if (req.method === "GET" && url.pathname === "/api/state") {
|
|
json(res, 200, await refreshIssuesSafe());
|
|
return;
|
|
}
|
|
|
|
if (req.method === "POST" && url.pathname === "/api/move") {
|
|
const input = await readJson(req);
|
|
const { issue, prevColumn } = moveIssue(input.issue_number, input.column);
|
|
|
|
if (input.column === "plan" && prevColumn !== "plan") {
|
|
const repo = currentState().repo;
|
|
session.send({
|
|
prompt: `The Repository Issues Kanban just moved issue #${issue.number} ("${issue.title}") in ${repo} into the Plan column. Start planning the implementation for this issue in a background agent. Read the GitHub issue details, analyze the repository, and produce a concrete implementation plan. Use the kanban_update_status tool to post progress and then move the issue to "ready" with kanban_move_issue when planning is complete.`,
|
|
});
|
|
}
|
|
|
|
json(res, 200, { issue, state: currentState() });
|
|
return;
|
|
}
|
|
|
|
if (req.method === "POST" && url.pathname === "/api/update-status") {
|
|
const input = await readJson(req);
|
|
const issue = updateIssueStatus(input.issue_number, input.status, input.log);
|
|
if (input.done) clearAgentStatus(input.issue_number);
|
|
json(res, 200, { issue, state: currentState() });
|
|
return;
|
|
}
|
|
|
|
if (req.method === "POST" && url.pathname === "/api/filters") {
|
|
const input = await readJson(req);
|
|
const state = setSelectedLabels(input.labels);
|
|
json(res, 200, state);
|
|
return;
|
|
}
|
|
|
|
if (req.method === "GET" && url.pathname.startsWith("/api/logs/")) {
|
|
const num = parseInt(url.pathname.split("/").pop(), 10);
|
|
const state = currentState();
|
|
const issue = state.issues.find((i) => i.number === num);
|
|
if (!issue) {
|
|
json(res, 404, { error: "not found" });
|
|
return;
|
|
}
|
|
json(res, 200, { issue_number: num, title: issue.title, logs: issue.logs || [] });
|
|
return;
|
|
}
|
|
|
|
if (req.method === "POST" && url.pathname === "/api/reset") {
|
|
resetBoard();
|
|
json(res, 200, await refreshIssuesSafe());
|
|
return;
|
|
}
|
|
|
|
if (url.pathname === "/") {
|
|
res.writeHead(200, { "Content-Type": "text/html" });
|
|
res.end(fs.readFileSync(path.join(__dirname, "public", "index.html"), "utf8"));
|
|
return;
|
|
}
|
|
|
|
res.writeHead(404);
|
|
res.end("Not found");
|
|
});
|
|
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
function getPort() {
|
|
return server.address().port;
|
|
}
|
|
|
|
// ─── Canvas declaration ───
|
|
|
|
const canvas = createCanvas({
|
|
id: "accessibility-kanban",
|
|
displayName: "Repository Issues Kanban",
|
|
description: "Kanban board for triaging open issues from the current repository into backlog, plan, ready, implement, and done lanes.",
|
|
actions: [
|
|
{
|
|
name: "get_state",
|
|
description: "Get the current board state including open repository issues and selected label filters.",
|
|
inputSchema: { type: "object", properties: {}, additionalProperties: false },
|
|
async handler() {
|
|
return refreshIssuesSafe();
|
|
},
|
|
},
|
|
{
|
|
name: "move_issue",
|
|
description: "Move an issue to a different column on the kanban board.",
|
|
inputSchema: {
|
|
type: "object",
|
|
properties: {
|
|
issue_number: { type: "number", description: "GitHub issue number" },
|
|
column: { type: "string", enum: COLUMNS, description: "Target column" },
|
|
},
|
|
required: ["issue_number", "column"],
|
|
additionalProperties: false,
|
|
},
|
|
handler({ input }) {
|
|
const { issue } = moveIssue(input.issue_number, input.column);
|
|
return { issue, state: currentState() };
|
|
},
|
|
},
|
|
{
|
|
name: "refresh_issues",
|
|
description: "Replace the board with issue data supplied by the agent.",
|
|
inputSchema: {
|
|
type: "object",
|
|
properties: {
|
|
issues: {
|
|
type: "array",
|
|
items: {
|
|
type: "object",
|
|
properties: {
|
|
number: { type: "number" },
|
|
title: { type: "string" },
|
|
url: { type: "string" },
|
|
labels: {
|
|
type: "array",
|
|
items: {
|
|
oneOf: [
|
|
{ type: "string" },
|
|
{ type: "object", properties: { name: { type: "string" } }, required: ["name"] },
|
|
],
|
|
},
|
|
},
|
|
column: { type: "string", enum: COLUMNS },
|
|
priority: { type: "string" },
|
|
order: { type: "number" },
|
|
},
|
|
required: ["number", "title"],
|
|
additionalProperties: true,
|
|
},
|
|
},
|
|
},
|
|
required: ["issues"],
|
|
additionalProperties: false,
|
|
},
|
|
handler({ input }) {
|
|
return replaceIssues(input.issues);
|
|
},
|
|
},
|
|
{
|
|
name: "set_filters",
|
|
description: "Set selected label filters (OR semantics).",
|
|
inputSchema: {
|
|
type: "object",
|
|
properties: {
|
|
labels: { type: "array", items: { type: "string" } },
|
|
},
|
|
required: ["labels"],
|
|
additionalProperties: false,
|
|
},
|
|
handler({ input }) {
|
|
return setSelectedLabels(input.labels);
|
|
},
|
|
},
|
|
{
|
|
name: "reset_state",
|
|
description: "Reset all cards to backlog and clear label filters, then refresh from live repo issues.",
|
|
inputSchema: { type: "object", properties: {}, additionalProperties: false },
|
|
async handler() {
|
|
resetBoard();
|
|
return refreshIssuesSafe();
|
|
},
|
|
},
|
|
],
|
|
async open() {
|
|
const state = await refreshIssuesSafe();
|
|
broadcast("state", state);
|
|
return {
|
|
url: `http://127.0.0.1:${getPort()}`,
|
|
title: "Repository Issues Kanban",
|
|
status: `${state.issues.length} open issues in ${state.repo}`,
|
|
};
|
|
},
|
|
});
|
|
|
|
// ─── Join session (tools + canvas) ───
|
|
|
|
const session = await joinSession({
|
|
canvases: [canvas],
|
|
tools: [
|
|
{
|
|
name: "kanban_move_issue",
|
|
description: "Move an issue on the repository issues kanban board to a new column (backlog, plan, ready, implement, done).",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
issue_number: { type: "number", description: "GitHub issue number" },
|
|
column: { type: "string", enum: COLUMNS, description: "Target column to move the issue to" },
|
|
},
|
|
required: ["issue_number", "column"],
|
|
},
|
|
handler: async (args) => {
|
|
const { issue } = moveIssue(args.issue_number, args.column);
|
|
return JSON.stringify({ moved: true, issue, state: currentState() });
|
|
},
|
|
},
|
|
{
|
|
name: "kanban_update_status",
|
|
description: "Update the agent status line and log on a kanban card while planning or implementing an issue.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
issue_number: { type: "number", description: "GitHub issue number" },
|
|
status: { type: "string", description: "Short status text shown on the card." },
|
|
log: { type: "string", description: "Detailed log entry appended to the issue's agent log." },
|
|
done: { type: "boolean", description: "Set true to stop the active glow." },
|
|
},
|
|
required: ["issue_number", "status"],
|
|
},
|
|
handler: async (args) => {
|
|
const issue = updateIssueStatus(args.issue_number, args.status, args.log);
|
|
if (args.done) clearAgentStatus(args.issue_number);
|
|
return JSON.stringify({ updated: true, issue });
|
|
},
|
|
},
|
|
],
|
|
});
|
|
|
|
sessionRef = session;
|