197 lines
6.4 KiB
TypeScript
197 lines
6.4 KiB
TypeScript
import { tool, ToolContext } from "@opencode-ai/plugin";
|
|
import path from "path";
|
|
|
|
function resolveWorklaneDir(context: ToolContext): string {
|
|
return path.join(context.worktree || context.directory || ".");
|
|
}
|
|
|
|
export const init = tool({
|
|
description:
|
|
"Initialize worklane in the current project. Creates the .worklane/ directory with backlog, committed, reviewing, and done subdirectories.",
|
|
args: {},
|
|
async execute(_args: Record<string, any>, context: ToolContext) {
|
|
try {
|
|
const result = await Bun.$`worklane init`
|
|
.cwd(resolveWorklaneDir(context))
|
|
.text();
|
|
return result.trim();
|
|
} catch (err: any) {
|
|
return `Error initializing worklane: ${err.message}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
export const add = tool({
|
|
description:
|
|
"Add a new ticket to the worklane backlog. Supports title, description, acceptance criteria, implementation plan, tags, due date, and owner.",
|
|
args: {
|
|
title: tool.schema.string().describe("Ticket title (required)"),
|
|
description: tool.schema.string().describe("Multiline ticket description"),
|
|
acceptance: tool.schema
|
|
.string()
|
|
.describe("Acceptance criteria one per line"),
|
|
plan: tool.schema
|
|
.string()
|
|
.describe("Implementation plan with one step per line"),
|
|
tags: tool.schema.string().describe("Tags as comma-separated list"),
|
|
due: tool.schema.string().describe("Due date in YYYY-MM-DD format"),
|
|
owner: tool.schema.string().describe("Owner name"),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
const cmd: (string | number)[] = ["add", "--title", args.title];
|
|
if (args.description) {
|
|
args.description
|
|
.split("\n")
|
|
.map((l: string) => l.trim())
|
|
.filter(Boolean)
|
|
.forEach((line: string) => cmd.push("--description", line));
|
|
}
|
|
|
|
if (args.acceptance) {
|
|
args.acceptance
|
|
.split("\n")
|
|
.map((l: string) => l.trim())
|
|
.filter(Boolean)
|
|
.forEach((line: string) => cmd.push("--acceptance", line));
|
|
}
|
|
|
|
if (args.plan) {
|
|
args.plan
|
|
.split("\n")
|
|
.map((l: string) => l.trim())
|
|
.filter(Boolean)
|
|
.forEach((line: string) => cmd.push("--plan", line));
|
|
}
|
|
|
|
if (args.tags) cmd.push("--tags", args.tags);
|
|
if (args.due) cmd.push("--due", args.due);
|
|
if (args.owner) cmd.push("--owner", args.owner);
|
|
|
|
const workdir = resolveWorklaneDir(context);
|
|
try {
|
|
const proc = Bun.spawn(["worklane", ...cmd], { cwd: workdir });
|
|
const { exitCode, stdout, stderr } = await proc.exited;
|
|
if (exitCode !== 0) {
|
|
const stderrStr = new TextDecoder().decode(stderr);
|
|
throw new Error(stderrStr.trim() || `Exit code ${exitCode}`);
|
|
}
|
|
return new TextDecoder().decode(stdout).trim();
|
|
} catch (err: any) {
|
|
return `Error adding ticket: ${err.message}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
export const ls = tool({
|
|
description:
|
|
"List all worklane tickets. Optionally filter by status (backlog, committed, reviewing, done).",
|
|
args: {
|
|
status: tool.schema
|
|
.enum(["backlog", "committed", "reviewing", "done"])
|
|
.describe("Filter by status")
|
|
.optional(),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
const workdir = resolveWorklaneDir(context);
|
|
try {
|
|
if (args.status) {
|
|
const result = await Bun.$`worklane ls ${args.status}`
|
|
.cwd(workdir)
|
|
.text();
|
|
return result.trim();
|
|
} else {
|
|
const result = await Bun.$`worklane ls`.cwd(workdir).text();
|
|
return result.trim();
|
|
}
|
|
} catch (err: any) {
|
|
return `Error listing tickets: ${err.message}, Dir: ${workdir}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
export const show = tool({
|
|
description:
|
|
"Show a complete ticket by UUID or title. Displays title, description, acceptance criteria, implementation plan, metadata, and comments.",
|
|
args: {
|
|
id: tool.schema
|
|
.string()
|
|
.describe("Ticket UUID (8+ chars) or title substring"),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
const workdir = resolveWorklaneDir(context);
|
|
try {
|
|
const result = await Bun.$`worklane show ${args.id}`.cwd(workdir).text();
|
|
return result.trim();
|
|
} catch (err: any) {
|
|
return `Error showing ticket: ${err.message}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
export const mv = tool({
|
|
description:
|
|
"Move a ticket to a different status in the workflow (backlog -> committed -> reviewing -> done).",
|
|
args: {
|
|
ticket: tool.schema
|
|
.string()
|
|
.describe("Ticket UUID (8+ chars) or title substring"),
|
|
status: tool.schema
|
|
.enum(["backlog", "committed", "reviewing", "done"])
|
|
.describe("Target status"),
|
|
force: tool.schema
|
|
.boolean()
|
|
.describe("Force move (allows non-sequential moves like done -> backlog)")
|
|
.optional(),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
const cmd: (string | number)[] = [
|
|
"mv",
|
|
args.ticket,
|
|
"--status",
|
|
args.status,
|
|
];
|
|
if (args.force) cmd.push("--force");
|
|
|
|
const workdir = resolveWorklaneDir(context);
|
|
try {
|
|
const proc = Bun.spawn(["worklane", ...cmd], { cwd: workdir });
|
|
const { exitCode, stdout, stderr } = await proc.exited;
|
|
if (exitCode !== 0) {
|
|
const stderrStr = new TextDecoder().decode(stderr);
|
|
throw new Error(stderrStr.trim() || `Exit code ${exitCode}`);
|
|
}
|
|
return new TextDecoder().decode(stdout).trim();
|
|
} catch (err: any) {
|
|
return `Error moving ticket: ${err.message}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
export const comment = tool({
|
|
description: "Add a comment to an existing ticket.",
|
|
args: {
|
|
ticket: tool.schema
|
|
.string()
|
|
.describe("Ticket UUID (8+ chars) or title substring"),
|
|
body: tool.schema.string().describe("Comment body (required)"),
|
|
owner: tool.schema.string().describe("Comment author").optional(),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
const cmd: (string | number)[] = ["comment", args.ticket, args.body];
|
|
if (args.owner) cmd.push("--owner", args.owner);
|
|
|
|
const workdir = resolveWorklaneDir(context);
|
|
try {
|
|
const proc = Bun.spawn(["worklane", ...cmd], { cwd: workdir });
|
|
const { exitCode, stdout, stderr } = await proc.exited;
|
|
if (exitCode !== 0) {
|
|
const stderrStr = new TextDecoder().decode(stderr);
|
|
throw new Error(stderrStr.trim() || `Exit code ${exitCode}`);
|
|
}
|
|
return new TextDecoder().decode(stdout).trim();
|
|
} catch (err: any) {
|
|
return `Error adding comment: ${err.message}`;
|
|
}
|
|
},
|
|
});
|