@bumpyclock/pi-tasque 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bumpyclock/pi-tasque",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Pi extension package for Tasque durable tasks plus in-session todos.",
   "type": "module",
   "license": "MIT",

package/src/bridge/import-tsq.ts

@@ -20,6 +20,11 @@ import {
 } from "../session-todos/state/state-reducer.js";
 import { commitState, getState } from "../session-todos/state/store.js";
 import type { Task, TaskStatus } from "../session-todos/tool/types.js";
+import {
+	asRecord,
+	copyKnownErrorFields,
+	isRecord,
+} from "../shared/error-utils.js";
 import {
 	errorToolDetails,
 	okToolDetails,
@@ -470,33 +475,3 @@ function serializeError(error: unknown): Record<string, unknown> {
 	}
 	return { value: String(error) };
 }
-
-function copyKnownErrorFields(error: Error): Record<string, unknown> {
-	const record = error as unknown as Record<string, unknown>;
-	const output: Record<string, unknown> = {};
-	for (const key of [
-		"code",
-		"command",
-		"details",
-		"stderr",
-		"stdout",
-		"killed",
-		"args",
-	] as const) {
-		if (record[key] !== undefined) {
-			output[key] = record[key];
-		}
-	}
-	return output;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		return undefined;
-	}
-	return value as Record<string, unknown>;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return asRecord(value) !== undefined;
-}

package/src/bridge/promote-todo.ts

@@ -5,6 +5,7 @@ import { cloneTaskState } from "../session-todos/state/state.js";
 import { applyTaskMutation } from "../session-todos/state/state-reducer.js";
 import { commitState, getState } from "../session-todos/state/store.js";
 import type { Task } from "../session-todos/tool/types.js";
+import { isRecord } from "../shared/error-utils.js";
 import {
 	errorToolDetails,
 	okToolDetails,
@@ -325,7 +326,3 @@ function serializeError(error: unknown): unknown {
 	}
 	return error;
 }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/durable-tasks/cache.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "../shared/error-utils.js";
 import { runTsqJson, type TsqRunContext } from "./runner.js";
 
 export interface TasqueStatusCacheState {
@@ -161,7 +162,3 @@ function truncateInline(text: string, maxLength: number): string {
 	}
 	return `${text.slice(0, Math.max(0, maxLength - 1))}…`;
 }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/durable-tasks/change-command-builder.ts

@@ -0,0 +1,315 @@
+export const TSQ_CHANGE_ACTIONS = [
+	"create",
+	"note",
+	"done",
+	"reopen",
+	"defer",
+	"start",
+	"claim_assign_only",
+	"block",
+	"unblock",
+	"order",
+	"unorder",
+] as const;
+
+export type TsqChangeAction = (typeof TSQ_CHANGE_ACTIONS)[number];
+
+export type ValidationResult =
+	| {
+			readonly ok: true;
+			readonly action: TsqChangeAction;
+			readonly argv: string[];
+	  }
+	| { readonly ok: false; readonly message: string };
+
+export function buildMutationCommand(
+	params: Readonly<Record<string, unknown>>,
+): ValidationResult {
+	const action = params.action;
+	if (!isTsqChangeAction(action)) {
+		return {
+			ok: false,
+			message: "action must be a supported durable task mutation",
+		};
+	}
+
+	switch (action) {
+		case "create":
+			return buildCreateArgv(params, action);
+		case "note":
+			return buildNoteArgv(params, action);
+		case "done":
+			return buildOptionalNoteArgv(params, action, "done");
+		case "reopen":
+			return buildIdOnlyArgv(params, action, "reopen");
+		case "defer":
+			return buildOptionalNoteArgv(params, action, "defer");
+		case "start":
+			return buildIdOnlyArgv(params, action, "start");
+		case "claim_assign_only":
+			return buildClaimAssignOnlyArgv(params, action);
+		case "block":
+			return buildBlockArgv(params, action, "block");
+		case "unblock":
+			return buildBlockArgv(params, action, "unblock");
+		case "order":
+			return buildOrderArgv(params, action, "order");
+		case "unorder":
+			return buildOrderArgv(params, action, "unorder");
+	}
+}
+
+export function isTsqChangeAction(value: unknown): value is TsqChangeAction {
+	return (
+		typeof value === "string" &&
+		(TSQ_CHANGE_ACTIONS as readonly string[]).includes(value)
+	);
+}
+
+// --- argv builders ---
+
+function buildCreateArgv(
+	params: Readonly<Record<string, unknown>>,
+	action: TsqChangeAction,
+): ValidationResult {
+	const title = requireNonEmptyString(params, "title");
+	if (!title.ok) {
+		return title;
+	}
+	const kind = requireNonEmptyString(params, "kind");
+	if (!kind.ok) {
+		return kind;
+	}
+	const priority = requireInteger(params, "priority");
+	if (!priority.ok) {
+		return priority;
+	}
+	const planned = getOptionalBoolean(params, "planned");
+	if (!planned.ok) {
+		return planned;
+	}
+	const needsPlan = getOptionalBoolean(params, "needsPlan");
+	if (!needsPlan.ok) {
+		return needsPlan;
+	}
+	if (planned.value === true && needsPlan.value === true) {
+		return {
+			ok: false,
+			message: "planned and needsPlan cannot both be true",
+		};
+	}
+
+	const argv = ["create", `--kind=${kind.value}`, "-p", String(priority.value)];
+	const description = appendOptionalStringFlag(
+		argv,
+		params,
+		"description",
+		"--description",
+	);
+	if (description !== undefined) {
+		return description;
+	}
+	const parent = appendOptionalStringFlag(argv, params, "parent", "--parent");
+	if (parent !== undefined) {
+		return parent;
+	}
+	if (planned.value === true) {
+		argv.push("--planned");
+	} else if (needsPlan.value === true) {
+		argv.push("--needs-plan");
+	}
+	argv.push("--", title.value);
+
+	return { ok: true, action, argv };
+}
+
+function buildNoteArgv(
+	params: Readonly<Record<string, unknown>>,
+	action: TsqChangeAction,
+): ValidationResult {
+	const id = requireNonEmptyString(params, "id");
+	if (!id.ok) {
+		return id;
+	}
+	const note = requireNonEmptyString(params, "note");
+	if (!note.ok) {
+		return note;
+	}
+	return { ok: true, action, argv: ["note", id.value, "--", note.value] };
+}
+
+function buildOptionalNoteArgv(
+	params: Readonly<Record<string, unknown>>,
+	action: TsqChangeAction,
+	command: "done" | "defer",
+): ValidationResult {
+	const id = requireNonEmptyString(params, "id");
+	if (!id.ok) {
+		return id;
+	}
+	const argv = [command, id.value];
+	const note = getOptionalNonEmptyString(params, "note");
+	if (!note.ok) {
+		return note;
+	}
+	if (note.value !== undefined) {
+		argv.push(`--note=${note.value}`);
+	}
+	return { ok: true, action, argv };
+}
+
+function buildIdOnlyArgv(
+	params: Readonly<Record<string, unknown>>,
+	action: TsqChangeAction,
+	command: "reopen" | "start",
+): ValidationResult {
+	const id = requireNonEmptyString(params, "id");
+	if (!id.ok) {
+		return id;
+	}
+	return { ok: true, action, argv: [command, id.value] };
+}
+
+function buildClaimAssignOnlyArgv(
+	params: Readonly<Record<string, unknown>>,
+	action: TsqChangeAction,
+): ValidationResult {
+	const id = requireNonEmptyString(params, "id");
+	if (!id.ok) {
+		return id;
+	}
+	const assignee = requireNonEmptyString(params, "assignee");
+	if (!assignee.ok) {
+		return assignee;
+	}
+	return {
+		ok: true,
+		action,
+		argv: ["claim", id.value, `--assignee=${assignee.value}`],
+	};
+}
+
+function buildBlockArgv(
+	params: Readonly<Record<string, unknown>>,
+	action: TsqChangeAction,
+	command: "block" | "unblock",
+): ValidationResult {
+	const child = requireNonEmptyString(params, "child");
+	if (!child.ok) {
+		return child;
+	}
+	const blocker = requireNonEmptyString(params, "blocker");
+	if (!blocker.ok) {
+		return blocker;
+	}
+	if (child.value === blocker.value) {
+		return { ok: false, message: "child and blocker cannot be the same task" };
+	}
+	return {
+		ok: true,
+		action,
+		argv: [command, child.value, "by", blocker.value],
+	};
+}
+
+function buildOrderArgv(
+	params: Readonly<Record<string, unknown>>,
+	action: TsqChangeAction,
+	command: "order" | "unorder",
+): ValidationResult {
+	const later = requireNonEmptyString(params, "later");
+	if (!later.ok) {
+		return later;
+	}
+	const earlier = requireNonEmptyString(params, "earlier");
+	if (!earlier.ok) {
+		return earlier;
+	}
+	if (later.value === earlier.value) {
+		return { ok: false, message: "later and earlier cannot be the same task" };
+	}
+	return {
+		ok: true,
+		action,
+		argv: [command, later.value, "after", earlier.value],
+	};
+}
+
+function appendOptionalStringFlag(
+	argv: string[],
+	params: Readonly<Record<string, unknown>>,
+	field: "description" | "parent",
+	flag: string,
+): ValidationResult | undefined {
+	const value = getOptionalNonEmptyString(params, field);
+	if (!value.ok) {
+		return value;
+	}
+	if (value.value !== undefined) {
+		argv.push(`${flag}=${value.value}`);
+	}
+	return undefined;
+}
+
+// --- validation helpers (params+field pattern, specific to builders) ---
+
+function requireNonEmptyString(
+	params: Readonly<Record<string, unknown>>,
+	field: string,
+):
+	| { readonly ok: true; readonly value: string }
+	| { readonly ok: false; readonly message: string } {
+	const value = params[field];
+	if (typeof value !== "string" || value.trim().length === 0) {
+		return { ok: false, message: `${field} is required` };
+	}
+	return { ok: true, value };
+}
+
+function getOptionalNonEmptyString(
+	params: Readonly<Record<string, unknown>>,
+	field: string,
+):
+	| { readonly ok: true; readonly value: string | undefined }
+	| { readonly ok: false; readonly message: string } {
+	const value = params[field];
+	if (value === undefined) {
+		return { ok: true, value: undefined };
+	}
+	if (typeof value !== "string") {
+		return { ok: false, message: `${field} must be a string` };
+	}
+	if (value.trim().length === 0) {
+		return { ok: true, value: undefined };
+	}
+	return { ok: true, value };
+}
+
+function requireInteger(
+	params: Readonly<Record<string, unknown>>,
+	field: string,
+):
+	| { readonly ok: true; readonly value: number }
+	| { readonly ok: false; readonly message: string } {
+	const value = params[field];
+	if (typeof value !== "number" || !Number.isInteger(value)) {
+		return { ok: false, message: `${field} is required` };
+	}
+	return { ok: true, value };
+}
+
+function getOptionalBoolean(
+	params: Readonly<Record<string, unknown>>,
+	field: string,
+):
+	| { readonly ok: true; readonly value: boolean | undefined }
+	| { readonly ok: false; readonly message: string } {
+	const value = params[field];
+	if (value === undefined) {
+		return { ok: true, value: undefined };
+	}
+	if (typeof value !== "boolean") {
+		return { ok: false, message: `${field} must be a boolean` };
+	}
+	return { ok: true, value };
+}

package/src/durable-tasks/runner.ts

@@ -3,6 +3,7 @@ import type {
 	ExecResult,
 	ExtensionAPI,
 } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "../shared/error-utils.js";
 import {
 	TSQ_SCHEMA_VERSION,
 	type JsonValue,
@@ -228,7 +229,3 @@ function buildProcessErrorMessage(result: ExecResult): string {
 	}
 	return `tsq failed with exit code ${result.code}${killed}: ${summary}`;
 }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/durable-tasks/status.ts

@@ -2,6 +2,7 @@ import type {
 	ExtensionAPI,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "../shared/error-utils.js";
 import {
 	createTasqueStatusCache,
 	formatTasqueStatusText,
@@ -196,7 +197,3 @@ function hasStatusUi(ctx: ExtensionContext): boolean {
 function getErrorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/durable-tasks/task-mappers.ts

@@ -0,0 +1,160 @@
+import type { TaskBridgeParams } from "../bridge/types.js";
+import { definedParams } from "../shared/validation.js";
+import type { TaskParams } from "./task-schema.js";
+import { getTodoId, hasWith } from "./task-validation.js";
+import type { TsqChangeParams } from "./tools-change.js";
+import type { TsqQueryParams } from "./tools-query.js";
+
+export function toQueryParams(params: TaskParams): TsqQueryParams {
+	switch (params.action) {
+		case "doctor":
+			return { action: "doctor" };
+		case "find":
+			if (params.view === "tree") {
+				return definedParams<TsqQueryParams>({
+					action: "find_tree",
+					id: params.task,
+				});
+			}
+			return params.tasks === "open"
+				? definedParams<TsqQueryParams>({
+						action: "find_open",
+						assignee: params.for,
+					})
+				: definedParams<TsqQueryParams>({
+						action: "find_ready",
+						lane: params.lane,
+						assignee: params.for,
+					});
+		case "show":
+			return definedParams<TsqQueryParams>({
+				action: hasWith(params, "spec") ? "show_with_spec" : "show",
+				id: params.task,
+			});
+		case "deps":
+			return definedParams<TsqQueryParams>({ action: "deps", id: params.task });
+		case "notes":
+			return definedParams<TsqQueryParams>({
+				action: "notes",
+				id: params.task,
+			});
+		case "similar":
+			return definedParams<TsqQueryParams>({
+				action: "similar",
+				query: params.query,
+			});
+		default:
+			throw new Error(`Unsupported query action: ${params.action}`);
+	}
+}
+
+export function toChangeParams(params: TaskParams): TsqChangeParams {
+	switch (params.action) {
+		case "create":
+			return definedParams<TsqChangeParams>({
+				action: "create",
+				title: params.task,
+				kind: params.kind,
+				priority: params.priority,
+				description: params.description,
+				parent: params.under,
+				planned: params.planned,
+				needsPlan: params.needsPlan,
+			});
+		case "note":
+			return definedParams<TsqChangeParams>({
+				action: "note",
+				id: params.task,
+				note: params.because,
+			});
+		case "finish":
+			return definedParams<TsqChangeParams>({
+				action: "done",
+				id: params.task,
+				note: params.because,
+			});
+		case "reopen":
+		case "start":
+			return definedParams<TsqChangeParams>({
+				action: params.action,
+				id: params.task,
+			});
+		case "defer":
+			return definedParams<TsqChangeParams>({
+				action: "defer",
+				id: params.task,
+				note: params.because,
+			});
+		case "block":
+			return definedParams<TsqChangeParams>({
+				action: "block",
+				child: params.task,
+				blocker: params.by,
+			});
+		case "unblock":
+			return definedParams<TsqChangeParams>({
+				action: "unblock",
+				child: params.task,
+				blocker: params.by,
+			});
+		case "order":
+			return definedParams<TsqChangeParams>({
+				action: "order",
+				later: params.task,
+				earlier: params.after,
+			});
+		case "unorder":
+			return definedParams<TsqChangeParams>({
+				action: "unorder",
+				later: params.task,
+				earlier: params.after,
+			});
+		default:
+			throw new Error(`Unsupported change action: ${params.action}`);
+	}
+}
+
+export function toClaimParams(
+	params: TaskParams,
+): Readonly<Record<string, unknown>> {
+	return definedParams<Readonly<Record<string, unknown>>>({
+		id: params.task,
+		assignee: params.for,
+		start: params.start,
+		requireSpec: params.requireSpec,
+		createTodo: params.todo === true,
+	});
+}
+
+export function toBridgeParams(params: TaskParams): TaskBridgeParams {
+	switch (params.action) {
+		case "link":
+			return definedParams<TaskBridgeParams>({
+				action: "link",
+				todoId: getTodoId(params.todo),
+				tsqId: params.task,
+			});
+		case "list_links":
+			return { action: "list_links" };
+		case "promote":
+			return definedParams<TaskBridgeParams>({
+				action: "promote_todo",
+				todoId: getTodoId(params.todo),
+				assignee: params.for,
+				kind: params.kind,
+				priority: params.priority,
+				description: params.description,
+				parent: params.under,
+				planned: params.planned,
+				needsPlan: params.needsPlan,
+			});
+		case "import":
+			return definedParams<TaskBridgeParams>({
+				action: "import_tsq",
+				tsqId: params.task,
+				owner: params.for,
+			});
+		default:
+			throw new Error(`Unsupported bridge action: ${params.action}`);
+	}
+}