Three doc tickets in one commit, since two of them are the same check: run everything the docs claim and see what fails. 8cc254c: the add example in the kanban skill passed -t twice, once where -g for tags was meant, and gave -p three bare positional values instead of three flags. Clap rejected it with exit 2, reproduced verbatim. Rewritten, with a line saying why -t is not tags and why each step needs its own -p, since the example alone does not explain the trap. The "--due (or --due)" filler is gone; --due and --priority have no short form and now say so. a1dbd60: only title is required in the add schema now. The other six fields were unmarked, so the model had to invent a value for every field on every ticket. The other four tool schemas were checked and are already right: ls is fully optional, and the required arguments on show, mv and comment are genuinely required. Every add field was already guarded in execute, so an omitted field adds no flag. 47aa0fe: the README row it describes was already fixed in passing byddbd45e, which rewrote it for the priority work. "ls --status" appears nowhere. What was left was the second criterion, and running every example turned up a different problem: the 141 exit code documented for a truncated pipe only happens when the output exceeds the 64 KiB a pipe holds. A short listing lands in the buffer whole and reports 0. That was my own wording fromb28ddb9and it is now precise. Every example in both files was run against the built binary, with real ids substituted where they use placeholders, and the four documented exit codes were measured rather than assumed. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
273 lines
9.2 KiB
TypeScript
273 lines
9.2 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 || ".");
|
|
}
|
|
|
|
/**
|
|
* Run worklane and return its stdout, throwing with its stderr on failure.
|
|
*
|
|
* Both streams have to be piped. Bun defaults stderr to inherit, so it went to
|
|
* this process and never reached the model, and Bun.$ throws a ShellError whose
|
|
* message is only "Failed with exit code 1". Either way the CLI explained itself
|
|
* and nothing relayed the explanation.
|
|
*
|
|
* stdout is the fallback, not the source: worklane writes errors to stderr.
|
|
*/
|
|
async function run(cmd: string[], context: ToolContext): Promise<string> {
|
|
const proc = Bun.spawn(["worklane", ...cmd], {
|
|
cwd: resolveWorklaneDir(context),
|
|
stdout: "pipe",
|
|
stderr: "pipe",
|
|
});
|
|
|
|
const [stdout, stderr, exitCode] = await Promise.all([
|
|
new Response(proc.stdout).text(),
|
|
new Response(proc.stderr).text(),
|
|
proc.exited,
|
|
]);
|
|
|
|
if (exitCode !== 0) {
|
|
// anyhow prefixes its own "Error: ", and every caller here adds a prefix of
|
|
// its own, so drop it rather than relaying "Error adding comment: Error: ...".
|
|
const reason = stderr.trim().replace(/^Error:\s*/, "");
|
|
throw new Error(reason || stdout.trim() || `worklane exited with code ${exitCode}`);
|
|
}
|
|
|
|
return stdout.trim();
|
|
}
|
|
|
|
/**
|
|
* Description lines as worklane wants them, one --description value per line,
|
|
* blank ones included.
|
|
*
|
|
* cmd_add joins the values with a single newline, so an empty value is how a
|
|
* paragraph break is spelled. Dropping the blanks here, which is what the old
|
|
* filter(Boolean) did, collapsed every multi paragraph description into a single
|
|
* paragraph, against this tool's own instruction to separate paragraphs with
|
|
* newlines.
|
|
*
|
|
* Only the ends are trimmed, and only trailing whitespace within a line. Leading
|
|
* whitespace is content: it is what makes a nested markdown list or an indented
|
|
* block survive the trip.
|
|
*/
|
|
function descriptionLines(text: string): string[] {
|
|
const lines = text.split("\n").map((line: string) => line.trimEnd());
|
|
|
|
let start = 0;
|
|
let end = lines.length;
|
|
while (start < end && lines[start] === "") start++;
|
|
while (end > start && lines[end - 1] === "") end--;
|
|
|
|
return lines.slice(start, end);
|
|
}
|
|
|
|
/** One value per non-empty line, for the arguments that hold a list of items. */
|
|
function itemLines(text: string): string[] {
|
|
return text
|
|
.split("\n")
|
|
.map((line: string) => line.trim())
|
|
.filter(Boolean);
|
|
}
|
|
|
|
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 {
|
|
return await run(["init"], context);
|
|
} catch (err: any) {
|
|
return `Error initializing worklane: ${err.message}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
export const add = tool({
|
|
description:
|
|
"Add a new ticket to the worklane backlog. Requires a title. Description, acceptance criteria, and plan each support multiple lines (one item per line). Tags are comma-separated.",
|
|
// Title is the only required field. Every other flag is left off entirely when
|
|
// the field is omitted, so an unmarked schema only forced the model to invent a
|
|
// value for fields it had nothing to say about.
|
|
args: {
|
|
title: tool.schema
|
|
.string()
|
|
.describe("Ticket title (required)"),
|
|
description: tool.schema
|
|
.string()
|
|
.describe("Description text. Use newlines between paragraphs.")
|
|
.optional(),
|
|
acceptance: tool.schema
|
|
.string()
|
|
.describe("Acceptance criteria, one per line. Put each criterium on its own line.")
|
|
.optional(),
|
|
plan: tool.schema
|
|
.string()
|
|
.describe("Implementation plan steps, one per line. Put each step on its own line.")
|
|
.optional(),
|
|
tags: tool.schema
|
|
.string()
|
|
.describe("Comma-separated tags, e.g. 'bug,frontend,urgent'")
|
|
.optional(),
|
|
due: tool.schema
|
|
.string()
|
|
.describe("Due date in YYYY-MM-DD format")
|
|
.optional(),
|
|
owner: tool.schema
|
|
.string()
|
|
.describe("Ticket owner name. If omitted, defaults to the git user.")
|
|
.optional(),
|
|
priority: tool.schema
|
|
.string()
|
|
.describe("Priority level, 1 (most urgent) to 5 (least). Left unset if omitted.")
|
|
.optional(),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
if (!args.title) {
|
|
return "Error adding ticket: title is required";
|
|
}
|
|
const cmd: string[] = ["add", "--title", args.title];
|
|
if (args.description) {
|
|
descriptionLines(args.description).forEach((line: string) =>
|
|
cmd.push("--description", line),
|
|
);
|
|
}
|
|
|
|
// Blanks are dropped from these two on purpose: each value is one criterium or
|
|
// one step, so an empty line between them is spacing rather than content.
|
|
if (args.acceptance) {
|
|
itemLines(args.acceptance).forEach((line: string) =>
|
|
cmd.push("--acceptance", line),
|
|
);
|
|
}
|
|
|
|
if (args.plan) {
|
|
itemLines(args.plan).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);
|
|
if (args.priority) cmd.push("--priority", String(args.priority));
|
|
|
|
try {
|
|
return await run(cmd, context);
|
|
} catch (err: any) {
|
|
return `Error adding ticket: ${err.message}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
export const ls = tool({
|
|
description:
|
|
"List all worklane tickets, sorted by priority then title. Optionally filter by status and by priority.",
|
|
args: {
|
|
status: tool.schema
|
|
.enum(["backlog", "committed", "reviewing", "done"])
|
|
.describe("Filter by status")
|
|
.optional(),
|
|
priority: tool.schema
|
|
.string()
|
|
.describe("Only show tickets at this priority, 1 (most urgent) to 5 (least)")
|
|
.optional(),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
const cmd = args.status ? ["ls", args.status] : ["ls"];
|
|
if (args.priority) cmd.push("--priority", String(args.priority));
|
|
try {
|
|
return await run(cmd, context);
|
|
} catch (err: any) {
|
|
// The directory is worth naming here: the usual failure is that there is
|
|
// no .worklane above it.
|
|
return `Error listing tickets: ${err.message}, Dir: ${resolveWorklaneDir(context)}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
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 prefix (4+ chars) or title substring (required)"),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
if (!args.id) {
|
|
return "Error showing ticket: id is required";
|
|
}
|
|
try {
|
|
return await run(["show", args.id], context);
|
|
} 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 prefix (4+ chars) or title substring (required)"),
|
|
status: tool.schema
|
|
.enum(["backlog", "committed", "reviewing", "done"])
|
|
.describe("Target status (required)"),
|
|
force: tool.schema
|
|
.boolean()
|
|
.describe("Force move (allows non-sequential moves like done -> backlog). Use with caution.")
|
|
.optional(),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
if (!args.ticket) {
|
|
return "Error moving ticket: ticket is required";
|
|
}
|
|
if (!args.status) {
|
|
return "Error moving ticket: status is required. Must be one of: backlog, committed, reviewing, done";
|
|
}
|
|
const cmd: string[] = ["mv", args.ticket, "--status", args.status];
|
|
if (args.force) cmd.push("--force");
|
|
|
|
try {
|
|
return await run(cmd, context);
|
|
} catch (err: any) {
|
|
return `Error moving ticket: ${err.message}`;
|
|
}
|
|
},
|
|
});
|
|
|
|
export const comment = tool({
|
|
description: "Add a comment to an existing ticket. The comment body supports markdown and newlines. Use it to add review feedback, notes, or status updates.",
|
|
args: {
|
|
ticket: tool.schema
|
|
.string()
|
|
.describe("Ticket UUID prefix (4+ chars) or title substring (required)"),
|
|
body: tool.schema
|
|
.string()
|
|
.describe("Comment body text (required). Supports markdown formatting and multiple paragraphs separated by newlines."),
|
|
owner: tool.schema
|
|
.string()
|
|
.describe("Comment author. If omitted, defaults to the git user.")
|
|
.optional(),
|
|
},
|
|
async execute(args: Record<string, any>, context: ToolContext) {
|
|
if (!args.ticket) {
|
|
return "Error adding comment: ticket is required";
|
|
}
|
|
if (!args.body) {
|
|
return "Error adding comment: body is required";
|
|
}
|
|
|
|
const cmd: string[] = ["comment", args.ticket, args.body];
|
|
if (args.owner) cmd.push("--owner", args.owner);
|
|
|
|
try {
|
|
return await run(cmd, context);
|
|
} catch (err: any) {
|
|
return `Error adding comment: ${err.message}`;
|
|
}
|
|
},
|
|
});
|