@e0ipso/ai-task-manager 1.36.1 → 1.37.0

package/templates/harness/skills/task-execute-blueprint/scripts/validate-plan-blueprint.cjs

@@ -0,0 +1,375 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/skill-scripts/validate-plan-blueprint.ts
+var validate_plan_blueprint_exports = {};
+__export(validate_plan_blueprint_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(validate_plan_blueprint_exports);
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+
+// src/skill-scripts/shared/root.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var EXPECTED_SCHEMA = true ? 1 : 1;
+var isValidTaskManagerRoot = (taskManagerPath) => {
+  try {
+    if (!fs.existsSync(taskManagerPath)) return false;
+    if (!fs.lstatSync(taskManagerPath).isDirectory()) return false;
+    const metadataPath = path.join(taskManagerPath, ".init-metadata.json");
+    if (!fs.existsSync(metadataPath)) return false;
+    const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+    return metadata && typeof metadata === "object" && "version" in metadata;
+  } catch (_err) {
+    return false;
+  }
+};
+var getTaskManagerAt = (directory) => {
+  const taskManagerPath = path.join(directory, ".ai", "task-manager");
+  return isValidTaskManagerRoot(taskManagerPath) ? taskManagerPath : null;
+};
+var getParentPaths = (currentPath, acc = []) => {
+  const absolutePath = path.resolve(currentPath);
+  const nextAcc = [...acc, absolutePath];
+  const parentPath = path.dirname(absolutePath);
+  if (parentPath === absolutePath) return nextAcc;
+  return getParentPaths(parentPath, nextAcc);
+};
+var checkWorkspaceSchema = (metadataPath) => {
+  let metadata;
+  try {
+    metadata = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+  } catch {
+    return;
+  }
+  const actual = typeof metadata.workspaceSchemaVersion === "number" ? metadata.workspaceSchemaVersion : 1;
+  if (actual === EXPECTED_SCHEMA) return;
+  if (actual < EXPECTED_SCHEMA) {
+    process.stderr.write(
+      `Workspace schema v${actual} is older than this skill requires (v${EXPECTED_SCHEMA}). Re-run \`npx @e0ipso/ai-task-manager init\` with the latest CLI to update.
+`
+    );
+  } else {
+    process.stderr.write(
+      `This skill (built for workspace schema v${EXPECTED_SCHEMA}) is older than the workspace (v${actual}). Re-run \`npx skills add e0ipso/ai-task-manager\` to update skills.
+`
+    );
+  }
+  process.exit(1);
+};
+var findTaskManagerRoot = (startPath = process.cwd()) => {
+  const paths = getParentPaths(startPath);
+  const found = paths.find((p) => getTaskManagerAt(p));
+  if (!found) return null;
+  const root = getTaskManagerAt(found);
+  if (root) checkWorkspaceSchema(path.join(root, ".init-metadata.json"));
+  return root;
+};
+
+// src/skill-scripts/shared/plan-scan.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/skill-scripts/shared/frontmatter.ts
+var ID_PATTERNS = [
+  /^\s*["']?id["']?\s*:\s*["']?([+-]?\d+)["']?\s*(?:#.*)?$/im,
+  /^\s*id\s*:\s*([+-]?\d+)\s*(?:#.*)?$/im,
+  /^\s*["']?id["']?\s*:\s*"([+-]?\d+)"\s*(?:#.*)?$/im,
+  /^\s*["']?id["']?\s*:\s*'([+-]?\d+)'\s*(?:#.*)?$/im,
+  /^\s*["']id["']\s*:\s*([+-]?\d+)\s*(?:#.*)?$/im,
+  /^\s*id\s*:\s*[|>]\s*([+-]?\d+)\s*$/im
+];
+var validateId = (rawId) => {
+  const id = parseInt(rawId, 10);
+  if (Number.isNaN(id) || id < 0 || id > Number.MAX_SAFE_INTEGER) return null;
+  return id;
+};
+var extractIdFromMarkdown = (content) => {
+  const frontmatterMatch = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatterMatch || !frontmatterMatch[1]) return null;
+  const block = frontmatterMatch[1];
+  for (const pattern of ID_PATTERNS) {
+    const match = block.match(pattern);
+    if (match && match[1]) {
+      const id = validateId(match[1]);
+      if (id !== null) return id;
+    }
+  }
+  return null;
+};
+var extractIdFromHtml = (content) => {
+  const headMatch = content.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+  const scope = headMatch && headMatch[1] ? headMatch[1] : content;
+  const metaPatterns = [
+    /<meta\s+[^>]*name\s*=\s*["']id["'][^>]*content\s*=\s*["']([+-]?\d+)["'][^>]*\/?>/i,
+    /<meta\s+[^>]*content\s*=\s*["']([+-]?\d+)["'][^>]*name\s*=\s*["']id["'][^>]*\/?>/i
+  ];
+  for (const pattern of metaPatterns) {
+    const match = scope.match(pattern);
+    if (match && match[1]) {
+      const id = validateId(match[1]);
+      if (id !== null) return id;
+    }
+  }
+  return null;
+};
+var extractPlanId = (content, filePath) => {
+  if (filePath.toLowerCase().endsWith(".html")) return extractIdFromHtml(content);
+  return extractIdFromMarkdown(content);
+};
+
+// src/skill-scripts/shared/plan-scan.ts
+var PLAN_EXTENSIONS = [".md", ".html"];
+var scanPlanDir = (planDirPath, dirName, isArchive) => {
+  let entries;
+  try {
+    entries = fs2.readdirSync(planDirPath, { withFileTypes: true });
+  } catch (_err) {
+    return [];
+  }
+  return entries.filter((e) => e.isFile() && PLAN_EXTENSIONS.some((ext) => e.name.endsWith(ext))).flatMap((e) => {
+    const filePath = path2.join(planDirPath, e.name);
+    try {
+      const content = fs2.readFileSync(filePath, "utf8");
+      const id = extractPlanId(content, filePath);
+      if (id === null) return [];
+      return [{ id, file: filePath, dir: planDirPath, isArchive, name: dirName }];
+    } catch (_err) {
+      return [];
+    }
+  });
+};
+var getAllPlans = (taskManagerRoot) => {
+  const sources = [
+    { dir: path2.join(taskManagerRoot, "plans"), isArchive: false },
+    { dir: path2.join(taskManagerRoot, "archive"), isArchive: true }
+  ];
+  return sources.flatMap(({ dir, isArchive }) => {
+    if (!fs2.existsSync(dir)) return [];
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch (_err) {
+      return [];
+    }
+    return entries.filter((e) => e.isDirectory()).flatMap((e) => scanPlanDir(path2.join(dir, e.name), e.name, isArchive));
+  });
+};
+
+// src/skill-scripts/shared/plan-resolve.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var isValidRootDir = (taskManagerPath) => {
+  try {
+    if (!fs3.existsSync(taskManagerPath)) return false;
+    if (!fs3.lstatSync(taskManagerPath).isDirectory()) return false;
+    const metadataPath = path3.join(taskManagerPath, ".init-metadata.json");
+    if (!fs3.existsSync(metadataPath)) return false;
+    const metadata = JSON.parse(fs3.readFileSync(metadataPath, "utf8"));
+    return metadata && typeof metadata === "object" && "version" in metadata;
+  } catch (_err) {
+    return false;
+  }
+};
+var checkStandardRootShortcut = (filePath) => {
+  const planDir = path3.dirname(filePath);
+  const parentDir = path3.dirname(planDir);
+  const possibleRoot = path3.dirname(parentDir);
+  const parentBase = path3.basename(parentDir);
+  if (parentBase !== "plans" && parentBase !== "archive") return null;
+  if (path3.basename(possibleRoot) !== "task-manager") return null;
+  const dotAiDir = path3.dirname(possibleRoot);
+  if (path3.basename(dotAiDir) !== ".ai") return null;
+  return isValidRootDir(possibleRoot) ? possibleRoot : null;
+};
+var resolveByPath = (absolutePath) => {
+  let content;
+  try {
+    content = fs3.readFileSync(absolutePath, "utf8");
+  } catch (_err) {
+    return null;
+  }
+  const planId = extractPlanId(content, absolutePath);
+  if (planId === null) return null;
+  const tmRoot = checkStandardRootShortcut(absolutePath) || findTaskManagerRoot(path3.dirname(absolutePath));
+  if (!tmRoot) return null;
+  return {
+    planFile: absolutePath,
+    planDir: path3.dirname(absolutePath),
+    taskManagerRoot: tmRoot,
+    planId
+  };
+};
+var resolveByIdInAncestry = (planId, startPath, searched = /* @__PURE__ */ new Set()) => {
+  const tmRoot = findTaskManagerRoot(startPath);
+  if (!tmRoot) return null;
+  const normalized = path3.normalize(tmRoot);
+  if (searched.has(normalized)) return null;
+  searched.add(normalized);
+  const plans = getAllPlans(tmRoot);
+  const match = plans.find((p) => p.id === planId);
+  if (match) {
+    return {
+      planFile: match.file,
+      planDir: match.dir,
+      taskManagerRoot: tmRoot,
+      planId
+    };
+  }
+  const parentOfRoot = path3.dirname(path3.dirname(tmRoot));
+  if (parentOfRoot === tmRoot) return null;
+  return resolveByIdInAncestry(planId, parentOfRoot, searched);
+};
+var resolvePlan = (input, startPath = process.cwd()) => {
+  if (input === null || input === void 0 || input === "") return null;
+  const inputStr = String(input);
+  if (inputStr.startsWith("/")) {
+    return resolveByPath(inputStr);
+  }
+  const planId = parseInt(inputStr, 10);
+  if (Number.isNaN(planId)) return null;
+  return resolveByIdInAncestry(planId, startPath);
+};
+
+// src/skill-scripts/validate-plan-blueprint.ts
+var VALID_FIELDS = [
+  "planFile",
+  "planDir",
+  "taskCount",
+  "blueprintExists",
+  "taskManagerRoot",
+  "planId"
+];
+var countTasks = (planDir) => {
+  const tasksDir = path4.join(planDir, "tasks");
+  if (!fs4.existsSync(tasksDir)) return 0;
+  try {
+    const stat = fs4.lstatSync(tasksDir);
+    if (!stat.isDirectory()) return 0;
+    return fs4.readdirSync(tasksDir).filter((f) => f.endsWith(".md")).length;
+  } catch (_err) {
+    return 0;
+  }
+};
+var checkBlueprintExists = (planFile) => {
+  try {
+    const content = fs4.readFileSync(planFile, "utf8");
+    return /^## Execution Blueprint/m.test(content);
+  } catch (_err) {
+    return false;
+  }
+};
+var usage = () => {
+  const lines = [
+    "Plan ID or absolute path is required",
+    "",
+    "Usage: node validate-plan-blueprint.cjs <plan-id-or-path> [field-name]",
+    "",
+    "Examples:",
+    "  node validate-plan-blueprint.cjs 47",
+    "  node validate-plan-blueprint.cjs /path/to/plan.md",
+    "  node validate-plan-blueprint.cjs 47 planFile",
+    "  node validate-plan-blueprint.cjs 47 blueprintExists"
+  ];
+  lines.forEach((l) => process.stderr.write(`[ERROR] ${l}
+`));
+};
+var listAvailablePlans = (startPath) => {
+  const tmRoot = findTaskManagerRoot(startPath);
+  if (!tmRoot) return [];
+  const plans = getAllPlans(tmRoot);
+  return plans.map((p) => p.name).sort((a, b) => {
+    const aMatch = a.match(/^(\d+)--/);
+    const bMatch = b.match(/^(\d+)--/);
+    if (!aMatch || !bMatch || !aMatch[1] || !bMatch[1]) return 0;
+    return parseInt(aMatch[1], 10) - parseInt(bMatch[1], 10);
+  });
+};
+var main = () => {
+  const inputId = process.argv[2];
+  const fieldName = process.argv[3];
+  if (!inputId) {
+    usage();
+    process.exit(1);
+  }
+  const numericInput = parseInt(inputId, 10);
+  const isNumeric = !Number.isNaN(numericInput);
+  const isAbsolutePath = inputId.startsWith("/");
+  if (!isNumeric && !isAbsolutePath) {
+    process.stderr.write(`[ERROR] Invalid plan ID: "${inputId}" is not a valid number
+`);
+    process.exit(1);
+  }
+  const resolved = resolvePlan(inputId);
+  if (!resolved) {
+    process.stderr.write(`[ERROR] Plan ID ${inputId} not found or invalid
+`);
+    process.stderr.write("[ERROR] \n");
+    const available = listAvailablePlans(process.cwd());
+    if (available.length > 0) {
+      process.stderr.write("[ERROR] Available plans:\n");
+      available.forEach((name) => process.stderr.write(`[ERROR]   ${name}
+`));
+    }
+    process.exit(1);
+  }
+  const result = {
+    planFile: resolved.planFile,
+    planDir: resolved.planDir,
+    taskManagerRoot: resolved.taskManagerRoot,
+    planId: resolved.planId,
+    taskCount: countTasks(resolved.planDir),
+    blueprintExists: checkBlueprintExists(resolved.planFile) ? "yes" : "no"
+  };
+  if (fieldName) {
+    if (!VALID_FIELDS.includes(fieldName)) {
+      process.stderr.write(`[ERROR] Invalid field name: ${fieldName}
+`);
+      process.stderr.write(`[ERROR] Valid fields: ${VALID_FIELDS.join(", ")}
+`);
+      process.exit(1);
+    }
+    const value = result[fieldName];
+    process.stdout.write(`${String(value)}
+`);
+  } else {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  }
+  process.exit(0);
+};
+if (require.main === module) {
+  main();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});

package/templates/harness/skills/task-execute-task/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: task-execute-task
+description: Execute a single task from an AI Task Manager plan. Use when the user asks to run, implement, or carry out one specific task ID within a plan — discovers the local .ai/task-manager root, resolves the plan, validates the task file, checks status and dependencies, runs pre-execution hooks, deploys an agent, updates status, documents noteworthy events, and emits a structured Task Execution Result. Do not use for generic development work outside the AI Task Manager.
+---
+
+# task-execute-task
+
+Drive the execution of a single task within an existing AI Task Manager plan.
+The skill is assistant-agnostic and self-contained: every script it invokes
+lives under this skill's `scripts/` directory and is referenced by relative
+path.
+
+## Critical Rules
+
+1. **Never skip dependency validation** — task execution requires all dependencies to be completed.
+2. **Validate task status** — never execute tasks that are already completed, in-progress, or needs-clarification.
+3. **Maintain status integrity** — update task status throughout the execution lifecycle.
+4. **Document execution** — record all outcomes and issues encountered.
+5. **Provide structured output** — always emit the structured result block for orchestrator parsing.
+
+## Inputs
+
+The user supplies the numeric plan ID and task ID conversationally. Treat them
+as the only authoritative source of intent. Do not invent answers to
+clarifying questions — prompt the user instead.
+
+## Failure Modes
+
+- **No task-manager root found.** Stop and instruct the user to initialize the
+  project. Do not execute the task.
+- **Plan ID does not resolve.** Stop and surface the script's stderr to the
+  user. Do not guess a different ID.
+- **Task file not found.** Stop and list available tasks in the plan to help
+  the user identify the correct task ID.
+- **Task status blocks execution.** If the task is `completed`,
+  `in-progress`, or `needs-clarification`, halt and provide guidance on
+  resolving the blocker.
+- **Dependency validation failure.** If `scripts/check-task-dependencies.cjs`
+  exits 1, stop and report unresolved dependencies. Do not proceed until they
+  are satisfied.
+- **Execution or hook failure.** If `PRE_TASK_EXECUTION.md`,
+  `PRE_TASK_ASSIGNMENT.md`, or `POST_ERROR_DETECTION.md` fails, or the
+  implementing agent encounters an unrecoverable error, set the task status
+  to `failed`, document the error in Noteworthy Events, and emit the
+  structured result with `Exit Code: 1`.
+
+## Operating Procedure
+
+### 1. Locate the task-manager root
+
+Run `scripts/find-task-manager-root.cjs` from the user's working directory.
+The script walks up looking for `.ai/task-manager/.init-metadata.json` and
+prints the absolute path of the resolved root on success.
+
+If the script exits non-zero, the working directory is not inside an
+initialized task-manager workspace. Stop and ask the user to run the project
+initializer (e.g. `npx @e0ipso/ai-task-manager init`) before continuing. Do
+not attempt to execute a task outside of a valid root.
+
+For every subsequent step, treat the path printed by this script as `<root>`.
+
+### 2. Resolve the plan
+
+Run `scripts/validate-plan-blueprint.cjs <plan-id> planFile` to obtain the
+absolute path of the plan file. The same script also accepts these field
+names (single-field output mode) and exposes them on demand:
+
+- `planDir` — absolute path of the plan directory
+- `taskCount` — number of existing task files in that plan's `tasks/`
+- `blueprintExists` — `yes` or `no`
+- `taskManagerRoot` — absolute path of `<root>`
+- `planId` — the resolved numeric plan ID
+
+If the script exits non-zero, stop and ask the user to confirm the plan ID.
+Do not guess a different ID.
+
+Treat the plan directory path returned by this script as `<plan-dir>`.
+
+### 3. Validate the task file
+
+Locate the specific task file inside `<plan-dir>/tasks/`. Match using both
+padded and unpadded forms of the task ID:
+
+- First, look for `<plan-dir>/tasks/<task-id>--*.md`
+- If not found, look for `<plan-dir>/tasks/0<task-id>--*.md`
+
+If no file matches, stop and report that the task ID was not found in the
+plan. List the available task files in `<plan-dir>/tasks/` to help the user
+identify the correct ID.
+
+Treat the resolved file path as `<task-file>`.
+
+### 4. Check task status
+
+Read the YAML frontmatter of `<task-file>` and extract the `status` field.
+
+- Block execution if the status is `completed`, `in-progress`, or
+  `needs-clarification`.
+- Allow execution if the status is `pending` or `failed`.
+- If the status is missing or unrecognized, proceed with caution and note
+  the ambiguity.
+
+If execution is blocked, stop and explain why, including guidance on how
+to resolve the blocker (e.g., use execute-blueprint to re-execute a completed
+task, or resolve clarification questions first).
+
+#### Valid Status Transitions
+
+Reference for orchestrators and execution flow:
+
+- `pending` → `in-progress` (execution starts)
+- `in-progress` → `completed` (successful execution)
+- `in-progress` → `failed` (execution error)
+- `failed` → `in-progress` (retry attempt)
+- `pending` → `needs-clarification` (set externally by orchestrator or reviewer)
+- `needs-clarification` → `pending` (clarification resolved, set externally)
+
+### 5. Validate dependencies
+
+Run `scripts/check-task-dependencies.cjs <plan-id> <task-id>`. The script
+validates that every dependency declared in the task frontmatter has status
+`completed`.
+
+If the script exits 1, stop and report that the task is blocked by unresolved
+dependencies. Do not proceed until dependencies are satisfied.
+
+### 6. Agent selection
+
+Read `<root>/config/hooks/PRE_TASK_ASSIGNMENT.md` and follow its instructions
+for selecting the appropriate agent or skill set for this task.
+
+### 7. Update status to in-progress
+
+Rewrite the YAML frontmatter of `<task-file>`, setting `status: "in-progress"`.
+Preserve all other frontmatter fields exactly.
+
+### 8. Execute the task
+
+Deploy an agent using your internal Task tool. The agent MUST perform these
+steps in order:
+
+1. **Pre-flight validation**: Read and execute
+   `<root>/config/hooks/PRE_TASK_EXECUTION.md` before starting any
+   implementation work.
+2. **Execute the task**: Read the complete `<task-file>` and implement
+   according to its requirements, including:
+   - Objective and acceptance criteria
+   - Technical requirements and implementation notes
+   - Input dependencies and expected output artifacts
+3. **Monitor progress**: Capture outputs, artifacts, and any issues
+   encountered during implementation.
+
+### 9. Update status to completed or failed
+
+After the agent finishes, rewrite the YAML frontmatter of `<task-file>` based
+on the outcome:
+
+- Set `status: "completed"` if the task was implemented successfully and
+  all acceptance criteria are met.
+- Set `status: "failed"` if the task could not be completed, acceptance
+  criteria were not met, or an unrecoverable error occurred.
+
+Preserve all other frontmatter fields exactly.
+
+### 10. Document noteworthy events
+
+If anything significant occurred during execution — decisions made, issues
+encountered, deviations from the plan, or follow-up actions required —
+append a "Noteworthy Events" section to the end of `<task-file>`:
+
+```markdown
+## Noteworthy Events
+- [YYYY-MM-DD] [Event description with sufficient context for the orchestrator]
+```
+
+If no noteworthy events occurred, do not add the section.
+
+### 11. Error handling
+
+If any error occurred during execution, read
+`<root>/config/hooks/POST_ERROR_DETECTION.md` and execute its instructions.
+Document the error in Noteworthy Events and ensure the task status is set to
+`failed` if it is not already.
+
+### 12. Emit structured output
+
+End the session with exactly this block as the final output:
+
+```
+---
+Task Execution Result:
+- Plan ID: [numeric-id]
+- Task ID: [numeric-id]
+- Exit Code: [0 for success, 1 for failure]
+```