pi-long-task 0.1.2 → 0.1.3

package/README.md

@@ -46,6 +46,18 @@ After installing, start `pi` in your target project and ask it to use the `pi_lo
 
 ## Usage
 
+Use natural language:
+
+```text
+Run a long task without commits to add tests for the parser and fix any failures.
+```
+
+```text
+Run a long task with commits to implement the TODOs in @TODO.md.
+```
+
+You can also call the tool explicitly.
+
 Run without commits:
 
 ```text
@@ -78,6 +90,8 @@ The tool has two inputs:
 - `inputText` is the request or TODO markdown to work on.
 - `commit` controls whether Pi Long Task may create git commits.
 
+For natural-language requests, Pi Long Task routes phrases like "run a long task with commits" to the tool with commits enabled. If you ask for a long task without mentioning commits, commits stay disabled.
+
 No other public options are required.
 
 ## Commits and files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-long-task",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "description": "Pi extension for breaking down and running long coding tasks safely.",
   "keywords": [

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import { runCoordinator, type CoordinatorProgressUpdate, type CoordinatorResult } from "./coordinator.ts";
+import { longTaskInputTransform } from "./input_router.ts";
 import { renderLongTaskToolCall, renderLongTaskToolResult } from "./render.ts";
 import { PiLongTaskParams } from "./types.ts";
 
@@ -22,10 +23,24 @@ function toolDetails(result: CoordinatorResult) {
 }
 
 export default function registerPiLongTaskExtension(pi: ExtensionAPI) {
+  pi.on("input", (event) => {
+    if (event.source === "extension") {
+      return { action: "continue" as const };
+    }
+
+    const transformed = longTaskInputTransform(event.text);
+    if (!transformed) {
+      return { action: "continue" as const };
+    }
+
+    return { action: "transform" as const, text: transformed };
+  });
+
   pi.registerTool({
     name: "pi_long_task",
     label: "Pi Long Task",
-    description: "Break down and run long coding tasks from a request or TODO plan.",
+    description:
+      "Run long or multi-step coding tasks from a request or TODO plan. Use this when the user asks to run/start/handle a long task; set commit true only when they ask for commits or committing as work progresses.",
     parameters: PiLongTaskParams,
     renderCall: renderLongTaskToolCall,
     renderResult: renderLongTaskToolResult,

package/src/input_router.ts

@@ -0,0 +1,57 @@
+const LONG_TASK_RE = /\b(?:long[-\s]?task|longtask|large[-\s]?task|big[-\s]?task|multi[-\s]?step(?:\s+task)?)\b/i;
+const DIRECT_LONG_TASK_REQUEST_RE =
+  /\b(?:run|start|do|handle|execute|launch|kick\s+off|use)\s+(?:a\s+|the\s+)?(?:long[-\s]?task|longtask|large[-\s]?task|big[-\s]?task|multi[-\s]?step(?:\s+task)?)\b/i;
+const WANT_LONG_TASK_RE =
+  /\b(?:please|can\s+you|could\s+you|i\s+want|i\s+need|i'd\s+like|i\s+would\s+like|let's|lets)\b[\s\S]*\b(?:long[-\s]?task|longtask|large[-\s]?task|big[-\s]?task|multi[-\s]?step(?:\s+task)?)\b/i;
+const NEGATED_LONG_TASK_RE =
+  /\b(?:do\s+not|don't|dont|never)\s+(?:run|start|do|handle|execute|launch|kick\s+off|use)\s+(?:a\s+|the\s+)?(?:long[-\s]?task|longtask|large[-\s]?task|big[-\s]?task|multi[-\s]?step(?:\s+task)?)\b/i;
+const INFORMATION_QUESTION_RE = /^\s*(?:how|what|why|when|where|who)\b/i;
+const EXPLICIT_TOOL_RE = /\bpi_long_task\b/i;
+
+const COMMIT_FALSE_RE =
+  /\b(?:without|no|disable|disabled|off)\s+commits?\b|\bcommits?\s*(?:false|off|disabled)\b|\bcommit\s*:\s*(?:false|off|no)\b|\b(?:do\s+not|don't|dont)\s+commit\b/i;
+const COMMIT_TRUE_RE =
+  /\bwith\s+commits?\b|\bcommits?\s*(?:true|on|enabled)\b|\bcommit\s*:\s*(?:true|on|yes)\b|\bcommit(?:ting)?\s+as\s+(?:you|we)\s+go\b|\b(?:make|create|include|allow|enable)\s+commits?\b/i;
+
+export function longTaskInputTransform(text: string): string | undefined {
+  if (!isNaturalLanguageLongTaskRequest(text)) {
+    return undefined;
+  }
+
+  const commit = inferCommitSetting(text) ?? false;
+  return buildLongTaskToolPrompt(text, commit);
+}
+
+export function isNaturalLanguageLongTaskRequest(text: string): boolean {
+  const trimmed = text.trim();
+  if (!trimmed || trimmed.startsWith("/") || EXPLICIT_TOOL_RE.test(trimmed)) {
+    return false;
+  }
+  if (!LONG_TASK_RE.test(trimmed) || INFORMATION_QUESTION_RE.test(trimmed) || NEGATED_LONG_TASK_RE.test(trimmed)) {
+    return false;
+  }
+  return DIRECT_LONG_TASK_REQUEST_RE.test(trimmed) || WANT_LONG_TASK_RE.test(trimmed);
+}
+
+export function inferCommitSetting(text: string): boolean | undefined {
+  if (COMMIT_FALSE_RE.test(text)) {
+    return false;
+  }
+  if (COMMIT_TRUE_RE.test(text)) {
+    return true;
+  }
+  return undefined;
+}
+
+function buildLongTaskToolPrompt(originalText: string, commit: boolean): string {
+  return [
+    "Use the pi_long_task tool for this request.",
+    `Set commit to ${commit ? "true" : "false"}.`,
+    "Set inputText to the user's original request below. Do not perform the work directly outside pi_long_task.",
+    "",
+    "Original request:",
+    "```text",
+    originalText.trim(),
+    "```",
+  ].join("\n");
+}

package/src/types.ts

@@ -5,8 +5,13 @@ import type { SessionOutcome } from "./worker_session.ts";
 
 export const PiLongTaskParams = Type.Object(
   {
-    inputText: Type.String({ description: "TODO file content or long-task instructions to process." }),
-    commit: Type.Boolean({ description: "Whether Pi Long Task may commit completed worker changes." }),
+    inputText: Type.String({
+      description: "TODO file content or the user's long-task instructions to process.",
+    }),
+    commit: Type.Boolean({
+      description:
+        "Whether Pi Long Task may commit completed worker changes. Use true when the user asks for commits or committing as work progresses; otherwise use false.",
+    }),
   },
   { additionalProperties: false },
 );