@e0ipso/ai-task-manager 1.36.1 → 1.38.0

package/templates/harness/skills/task-generate-tasks/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-refine-plan/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: task-refine-plan
+description: Refine an existing AI Task Manager plan in this repository. Use when the user asks to review, improve, interrogate, or update a specific plan ID — discovers the local .ai/task-manager root, resolves the plan, runs the project's plan hooks, pressure-tests the document for gaps and contradictions, gathers clarifications interactively or autonomously, and updates the plan in-place while preserving its identity and structure. Do not use for creating new plans or for generic brainstorming outside the AI Task Manager.
+---
+
+# task-refine-plan
+
+Drive the end-to-end refinement of 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.
+
+## Inputs
+
+The user supplies the numeric plan ID conversationally, along with any optional
+refinement notes or constraints. Treat the plan ID as the only authoritative
+source of intent. Do not invent answers to clarifying questions — prompt the
+user instead.
+
+## 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 refine a plan 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.
+
+### 3. Load project context
+
+Read these files, in order:
+
+- `<root>/config/TASK_MANAGER.md` — directory conventions and project context.
+- `<root>/config/hooks/PRE_PLAN.md` — execute the instructions it contains
+  before proceeding.
+- `<root>/config/templates/PLAN_TEMPLATE.md` — the structural baseline the
+  refined plan must continue to conform to.
+
+### 4. Baseline Review
+
+Read the entire plan end-to-end. Without modifying the file:
+
+1. Capture key metadata (plan title, summary, creation date, related initiatives).
+2. Surface the strongest sections, contradictions, and potential risks.
+3. Identify gaps using these lenses:
+   - **Context gaps**: missing background, assumptions, competing priorities.
+   - **Technical gaps**: underspecified architecture, unclear interfaces, missing diagrams.
+   - **Risk gaps**: untracked risks, missing mitigations, hand-wavy success metrics.
+   - **Scope issues**: gold-plating, ambiguous boundaries, requirements that
+     contradict YAGNI.
+
+Document each gap with `{section, issue, severity, proposed fix}` so you can
+reference it when refining the plan.
+
+### 5. Clarification Loop
+
+**Default to Interactive Clarification.** Only switch to **Autonomous
+Clarification** when the trigger is unambiguous and beyond reasonable doubt.
+Treat ambiguity as a vote for Interactive: asking a question the user
+cannot answer is recoverable; making silent assumptions when the user
+expected to be consulted is not.
+
+Switch to Autonomous Clarification only if at least one of the following
+holds without interpretation:
+
+- The user's request contains an explicit, unambiguous mode keyword such
+  as "auto", "autonomous", "non-interactive", "without asking me", "don't
+  ask", or equivalent phrasing that names the mode by intent.
+- An upstream orchestrator (for example the `task-full-workflow` skill)
+  has declared autonomous operation for this invocation in the prompt
+  passed to this skill.
+- The skill is invoked in auto mode (for example by the `task-full-workflow`
+  orchestrator or by a caller that explicitly requests autonomous operation).
+
+If none of the above holds, use Interactive Clarification even when the
+user's presence is uncertain. Do not infer autonomous mode from indirect
+signals such as terse prompts, scripted-looking input, or absence of
+recent user messages.
+
+After the clarification loop completes, append all new findings to the
+"Plan Clarifications" section in the plan document using the existing format
+(table with question/answer pairs). Mark the source of each entry
+appropriately.
+
+#### Interactive Clarification
+
+Think harder before interrupting the user — only trigger this loop when you
+can cite concrete uncertainties.
+
+1. Review the gaps documented in the Baseline Review.
+2. If no gaps remain, stop here and proceed to Stage 6.
+3. Build a clarification packet grouped by theme.
+4. Prefill each question with the most plausible answer so the user can
+   confirm or deny quickly.
+5. Always include an "Other / open-ended" option to capture nuances you did
+   not anticipate.
+6. **STOP AND ASK**: Present the clarification packet to the user. You must
+   halt execution here and await user input. Do not simulate the user's
+   response. Do not proceed to Stage 6 until you have received explicit answers.
+7. After receiving answers, record them in the Plan Clarifications table.
+   If the user cannot answer a question, record it as unresolved with
+   mitigation notes so downstream assistants know the risk.
+8. Re-evaluate whether new gaps emerged from the answers. If so, repeat
+   this loop.
+
+#### Autonomous Clarification
+
+Think harder before flagging gaps — only document concrete uncertainties
+you can cite.
+
+1. Review the gaps documented in the Baseline Review.
+2. For each gap, attempt to resolve it by:
+   - Inspecting the codebase, configuration files, and documentation.
+   - Analyzing existing patterns and conventions in the project.
+   - Reviewing assistant documents and README files.
+   - Making reasonable assumptions based on common practices and project
+     context.
+3. Record all resolutions in the Plan Clarifications table. Mark each
+   entry's source as either "auto-resolved" (confirmed via codebase) or
+   "assumption" (best-effort guess with rationale).
+4. For truly unresolvable questions, record them as unresolved with
+   mitigation notes so downstream assistants know the risk.
+5. If no gaps remain (or all have been resolved or documented), proceed to
+   Stage 6.
+
+### 6. Refinement Implementation
+
+Once you have sufficient context (or have documented all missing context),
+refine the plan directly in-place. The plan file path is the one returned by
+step 2.
+
+1. **Maintain Identity**: Keep the existing `id` and directory. Do not create
+   a new plan ID. Do not move the plan to a new location.
+2. **Structure Compliance**: Ensure the plan still follows
+   `<root>/config/templates/PLAN_TEMPLATE.md`. Add missing sections if
+   necessary.
+3. **Content Updates**:
+   - Refresh the executive summary to reflect clarifications and new insights.
+   - Update architectural sections, diagrams, and risk mitigations to resolve
+     the identified gaps.
+   - Trim any scope creep that is not explicitly required.
+   - Clearly reference clarifications in the relevant plan sections (e.g.,
+     italicized notes that point back to the Q&A table).
+4. **Net-New Sections**: If the plan needs a new subsection (e.g., Decision
+   Log, Data Contracts), add it under `Notes` with a clearly labeled section
+   so it remains discoverable.
+5. **Change Log**: Append a bullet list in the `Notes` section that briefly
+   states what changed in this refinement session (e.g.,
+   `- 2025-03-16: Clarified auth flow tokens and updated architecture diagram`).
+6. **Validation Hooks**: Execute `<root>/config/hooks/POST_PLAN.md` to ensure
+   the refined plan still meets quality bars.
+
+### 7. Run the post-plan hook
+
+Execute `<root>/config/hooks/POST_PLAN.md` after the plan file is updated.
+
+### 8. Emit the structured summary
+
+Conclude with exactly this block as the final output:
+
+```
+---
+
+Plan Refinement Summary:
+- Plan ID: [numeric-id]
+- Plan File: [absolute-path-to-plan-file]
+```
+
+The summary is consumed by downstream automation; keep the format exact.
+
+## Failure Modes
+
+- **No task-manager root found.** Stop and instruct the user to initialize the
+  project. Do not read or write any plan files.
+- **Plan ID does not resolve.** Stop and surface the script's stderr to the
+  user. Do not guess a different ID and do not read or write any files.
+- **User refuses to answer a clarifying question that blocks refinement.**
+  Record the unresolved question in the Plan Clarifications table with
+  mitigation notes, proceed with available context, and flag the remaining
+  risk in the Refinement Report.
+- **A helper script fails unexpectedly.** Surface stderr to the user and
+  stop — do not fall back to manual path discovery.
+- **Plan file is missing after resolution.** This indicates a consistency
+  issue in the task-manager workspace. Stop and report the error without
+  attempting to recreate the plan.

package/templates/harness/skills/task-refine-plan/scripts/find-task-manager-root.cjs

@@ -0,0 +1,116 @@
+"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/find-task-manager-root.ts
+var find_task_manager_root_exports = {};
+__export(find_task_manager_root_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(find_task_manager_root_exports);
+
+// 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/find-task-manager-root.ts
+var main = () => {
+  const startPath = process.argv[2] || process.cwd();
+  const root = findTaskManagerRoot(startPath);
+  if (!root) {
+    process.stderr.write(
+      `Could not find .ai/task-manager root from ${startPath} or any parent directory.
+`
+    );
+    process.exit(1);
+  }
+  process.stdout.write(`${root}
+`);
+  process.exit(0);
+};
+if (require.main === module) {
+  main();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});