@gethmy/mcp 2.3.2 → 2.3.4

package/dist/lib/prompt-builder.js

@@ -1,481 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/prompt-builder.ts
-var exports_prompt_builder = {};
-__export(exports_prompt_builder, {
-  inferCategoryFromLabels: () => inferCategoryFromLabels,
-  getRoleFraming: () => getRoleFraming,
-  getAvailableVariants: () => getAvailableVariants,
-  getAvailableCategories: () => getAvailableCategories,
-  generatePrompt: () => generatePrompt
-});
-function inferCategoryFromLabels(labels) {
-  for (const label of labels) {
-    const normalizedName = label.name.toLowerCase().trim();
-    if (LABEL_CATEGORY_MAP[normalizedName]) {
-      return LABEL_CATEGORY_MAP[normalizedName];
-    }
-    for (const [key, category] of Object.entries(LABEL_CATEGORY_MAP)) {
-      if (normalizedName.includes(key) || key.includes(normalizedName)) {
-        return category;
-      }
-    }
-  }
-  return "custom";
-}
-function getRoleFraming(category) {
-  return DEFAULT_ROLE_FRAMINGS[category];
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function formatSubtasks(subtasks) {
-  if (subtasks.length === 0)
-    return "";
-  const completed = subtasks.filter((s) => s.completed).length;
-  const lines = subtasks.map((s) => `  ${s.completed ? "[x]" : "[ ]"} ${s.title}`);
-  return `
-## Subtasks (${completed}/${subtasks.length} completed)
-${lines.join(`
-`)}`;
-}
-function formatLabels(labels) {
-  if (labels.length === 0)
-    return "";
-  return `
-**Labels:** ${labels.map((l) => l.name).join(", ")}`;
-}
-function formatLinkedCards(links) {
-  if (!links || links.length === 0)
-    return "";
-  const lines = links.map((link) => {
-    const prefix = link.direction === "outgoing" ? "->" : "<-";
-    return `  ${prefix} #${link.target_card.short_id}: ${link.target_card.title} (${link.display_type})`;
-  });
-  return `
-## Related Cards
-${lines.join(`
-`)}`;
-}
-function generatePrompt(options) {
-  const {
-    card,
-    column,
-    variant,
-    customConstraints,
-    memories,
-    assembledContext,
-    assemblyId
-  } = options;
-  const contextOpts = {
-    includeTitle: true,
-    includeDescription: true,
-    includeLabels: true,
-    includeSubtasks: true,
-    includeActivity: false,
-    includeAssignee: true,
-    includeDueDate: true,
-    includePriority: true,
-    includeLinks: true,
-    includeColumn: true,
-    ...options.contextOptions
-  };
-  const labels = card.labels || [];
-  const subtasks = card.subtasks || [];
-  const links = card.links || [];
-  const category = inferCategoryFromLabels(labels);
-  const roleFraming = getRoleFraming(category);
-  const sections = [];
-  sections.push(`# Role: ${roleFraming.role}
-`);
-  sections.push(roleFraming.perspective);
-  sections.push("");
-  sections.push(VARIANT_INSTRUCTIONS[variant]);
-  sections.push("");
-  sections.push(`# Task: ${card.title}`);
-  if (contextOpts.includeColumn && column) {
-    sections.push(`**Status:** ${column.name}`);
-  }
-  if (contextOpts.includePriority) {
-    sections.push(`**Priority:** ${card.priority}`);
-  }
-  if (contextOpts.includeDueDate && card.due_date) {
-    sections.push(`**Due:** ${card.due_date}`);
-  }
-  if (contextOpts.includeAssignee && card.assignee) {
-    sections.push(`**Assignee:** ${card.assignee.full_name || card.assignee.email}`);
-  }
-  if (contextOpts.includeLabels && labels.length > 0) {
-    sections.push(formatLabels(labels));
-  }
-  if (contextOpts.includeDescription && card.description) {
-    sections.push(`
-## Description
-${card.description}`);
-  }
-  if (contextOpts.includeSubtasks && subtasks.length > 0) {
-    sections.push(formatSubtasks(subtasks));
-  }
-  if (contextOpts.includeLinks && links.length > 0) {
-    sections.push(formatLinkedCards(links));
-  }
-  sections.push(`
-## Focus Areas`);
-  roleFraming.focus.forEach((f) => {
-    sections.push(`- ${f}`);
-  });
-  sections.push(`- **Memory:** Store reusable knowledge via \`harmony_remember\`. Only store what a future agent couldn't easily discover from the code itself, applies beyond this specific card, and includes a "because" (not just what, but why).`);
-  sections.push(`  - GOOD: "BoardContext card state must use moveCard action, never direct setState — optimistic updates depend on action ordering"`);
-  sections.push(`  - GOOD: "Mobile bottom bar is 64px, overlaps fixed-position drawers — always add pb-16 to drawer content"`);
-  sections.push(`  - BAD: "Fixed the login button" (no reusable knowledge — the fix is in the code)`);
-  sections.push(`  - BAD: "Completed card #42" (ephemeral, auto-tracked by session)`);
-  sections.push(`
-## Suggested Outputs`);
-  roleFraming.outputSuggestions.forEach((s) => {
-    sections.push(`- ${s}`);
-  });
-  if (assembledContext) {
-    sections.push(`
-${assembledContext}`);
-  } else if (memories && memories.length > 0) {
-    sections.push(`
-## Relevant Memories`);
-    sections.push(`*${memories.length} memories recalled from knowledge graph:*`);
-    for (const memory of memories) {
-      const tags = memory.tags.length > 0 ? ` [${memory.tags.join(", ")}]` : "";
-      sections.push(`
-### ${memory.title} (${memory.type}, confidence: ${memory.confidence})${tags}`);
-      sections.push(memory.content);
-    }
-  }
-  const oneThingLine = synthesizeOneThing(card, subtasks, links, assembledContext);
-  if (oneThingLine) {
-    sections.push(`
-## Recommended Next Step
-${oneThingLine}`);
-  }
-  if (variant === "execute") {
-    sections.push(`
-## Progress Tracking
-Update your progress by calling \`harmony_update_agent_progress\` with \`currentTask\` describing what you're doing now:
-- After exploring the codebase and understanding requirements (~20%)
-- When you start implementing changes (~50%)
-- When you move to testing or verification (~80%)
-- When done, before ending the session (100%)
-
-Keep \`currentTask\` specific (e.g., "Refactoring auth middleware" not "Working on card").`);
-  }
-  if (customConstraints) {
-    sections.push(`
-## Additional Instructions
-${customConstraints}`);
-  }
-  sections.push(`
----
-*Card #${card.short_id} | Generated for ${variant} mode*`);
-  const prompt = sections.join(`
-`);
-  const memoryCount = assembledContext ? (assembledContext.match(/^### /gm) || []).length : memories?.length || 0;
-  return {
-    prompt,
-    variant,
-    category,
-    role: roleFraming.role,
-    contextSummary: {
-      hasDescription: !!card.description,
-      labelCount: labels.length,
-      subtaskCount: subtasks.length,
-      completedSubtasks: subtasks.filter((s) => s.completed).length,
-      linkedCardCount: links.length,
-      memoryCount
-    },
-    tokenEstimate: estimateTokens(prompt),
-    ...assemblyId && { assemblyId }
-  };
-}
-function extractSessionInsights(assembledContext) {
-  const result = {
-    lastSessionStatus: null,
-    lastSessionTask: null,
-    lastSessionProgress: null,
-    blockers: [],
-    procedureNextStep: null
-  };
-  const sessionMatches = assembledContext.match(/### Session:.*?\n([\s\S]*?)(?=\n###|\n## |\n---|\n\*Assembly|$)/g);
-  if (sessionMatches && sessionMatches.length > 0) {
-    const latest = sessionMatches[0];
-    if (/Completed work on/i.test(latest)) {
-      result.lastSessionStatus = "completed";
-    } else if (/Paused work on|status:\s*paused/i.test(latest)) {
-      result.lastSessionStatus = "paused";
-    }
-    const taskMatch = latest.match(/Final task:\s*(.+)/);
-    if (taskMatch)
-      result.lastSessionTask = taskMatch[1].trim();
-    const progressMatch = latest.match(/Progress:\s*(\d+)%/);
-    if (progressMatch)
-      result.lastSessionProgress = parseInt(progressMatch[1], 10);
-  }
-  const blockerMatches = assembledContext.match(/(?:blocker|blocked by|blocking):\s*(.+)/gi);
-  if (blockerMatches) {
-    result.blockers = blockerMatches.map((m) => m.replace(/(?:blocker|blocked by|blocking):\s*/i, "").trim());
-  }
-  const stepMatches = assembledContext.match(/^\d+\.\s+(?!.*\*\*\[key step\]\*\*.*✓)(.+?)(?:\s*\*\*\[key step\]\*\*)?$/gm);
-  if (stepMatches && stepMatches.length > 0) {
-    result.procedureNextStep = stepMatches[0].replace(/^\d+\.\s+/, "").replace(/\s*\*\*\[key step\]\*\*.*$/, "").trim();
-  }
-  return result;
-}
-function synthesizeOneThing(card, subtasks, links, assembledContext) {
-  if (card.done)
-    return null;
-  const blockers = links.filter((l) => l.display_type === "is_blocked_by" && l.direction === "incoming");
-  if (blockers.length > 0) {
-    const blocker = blockers[0];
-    return `Unblock first: resolve #${blocker.target_card.short_id} "${blocker.target_card.title}" which is blocking this card.`;
-  }
-  const session = assembledContext ? extractSessionInsights(assembledContext) : null;
-  if (session?.blockers && session.blockers.length > 0) {
-    return `Resolve blocker: ${session.blockers[0]}`;
-  }
-  if (session?.lastSessionStatus === "paused" && session.lastSessionTask) {
-    const progress = session.lastSessionProgress ? ` (was ${session.lastSessionProgress}% complete)` : "";
-    return `Resume previous session${progress}: "${session.lastSessionTask}".`;
-  }
-  if (subtasks.length > 0) {
-    const completed = subtasks.filter((s) => s.completed).length;
-    if (completed === subtasks.length) {
-      return "All subtasks completed. Review the work and mark the card as done.";
-    }
-    const nextSubtask = subtasks.find((s) => !s.completed);
-    if (nextSubtask) {
-      return `Work on next subtask: "${nextSubtask.title}" (${completed}/${subtasks.length} done).`;
-    }
-  }
-  if (session?.procedureNextStep) {
-    return `Follow procedure: ${session.procedureNextStep}`;
-  }
-  if (session?.lastSessionStatus === "completed" && session.lastSessionTask) {
-    return `Previous session completed ("${session.lastSessionTask}"). Review results and continue with remaining work.`;
-  }
-  if (card.due_date && (card.priority === "urgent" || card.priority === "high")) {
-    return `High-priority task with deadline ${card.due_date}. Start implementation immediately.`;
-  }
-  if (card.description) {
-    return "Analyze the description, identify the approach, and begin implementation.";
-  }
-  return null;
-}
-function getAvailableCategories() {
-  return ["bug", "feature", "design", "review", "onboarding", "epic", "custom"];
-}
-function getAvailableVariants() {
-  return ["analysis", "draft", "execute"];
-}
-var LABEL_CATEGORY_MAP, DEFAULT_ROLE_FRAMINGS, VARIANT_INSTRUCTIONS;
-var init_prompt_builder = __esm(() => {
-  LABEL_CATEGORY_MAP = {
-    bug: "bug",
-    fix: "bug",
-    hotfix: "bug",
-    defect: "bug",
-    issue: "bug",
-    error: "bug",
-    feature: "feature",
-    enhancement: "feature",
-    improvement: "feature",
-    new: "feature",
-    design: "design",
-    ui: "design",
-    ux: "design",
-    frontend: "design",
-    styling: "design",
-    review: "review",
-    "code review": "review",
-    pr: "review",
-    feedback: "review",
-    onboarding: "onboarding",
-    documentation: "onboarding",
-    docs: "onboarding",
-    guide: "onboarding",
-    tutorial: "onboarding",
-    epic: "epic",
-    initiative: "epic",
-    project: "epic",
-    milestone: "epic"
-  };
-  DEFAULT_ROLE_FRAMINGS = {
-    bug: {
-      category: "bug",
-      role: "Senior QA Engineer and Software Developer",
-      perspective: "You are investigating and fixing a bug report.",
-      focus: [
-        "Root cause analysis",
-        "Steps to reproduce",
-        "Impact assessment",
-        "Fix implementation",
-        "Regression prevention",
-        "Test cases to prevent recurrence"
-      ],
-      outputSuggestions: [
-        "Bug triage summary",
-        "Root cause explanation",
-        "Fix implementation plan",
-        "Test cases"
-      ]
-    },
-    feature: {
-      category: "feature",
-      role: "Product Engineer",
-      perspective: "You are implementing a new feature or enhancement.",
-      focus: [
-        "User requirements",
-        "Technical specification",
-        "Implementation approach",
-        "Edge cases",
-        "Acceptance criteria",
-        "Integration points"
-      ],
-      outputSuggestions: [
-        "Technical specification",
-        "Implementation tasks",
-        "Acceptance criteria checklist",
-        "API design"
-      ]
-    },
-    design: {
-      category: "design",
-      role: "UX Designer and Frontend Developer",
-      perspective: "You are designing and implementing a user interface.",
-      focus: [
-        "User experience flow",
-        "Visual design consistency",
-        "Accessibility (WCAG)",
-        "Responsive behavior",
-        "Component architecture",
-        "Interaction patterns"
-      ],
-      outputSuggestions: [
-        "User flow diagram",
-        "Component specifications",
-        "Accessibility checklist",
-        "Responsive breakpoints"
-      ]
-    },
-    review: {
-      category: "review",
-      role: "Code Reviewer and Technical Lead",
-      perspective: "You are reviewing code for quality, correctness, and maintainability.",
-      focus: [
-        "Code correctness",
-        "Performance implications",
-        "Security considerations",
-        "Testing coverage",
-        "Documentation",
-        "Best practices adherence"
-      ],
-      outputSuggestions: [
-        "Review checklist",
-        "Suggested improvements",
-        "Test scenarios",
-        "Security audit"
-      ]
-    },
-    onboarding: {
-      category: "onboarding",
-      role: "Technical Writer and Developer Advocate",
-      perspective: "You are creating documentation or onboarding materials.",
-      focus: [
-        "Clear step-by-step instructions",
-        "Prerequisites and setup",
-        "Common pitfalls",
-        "Examples and use cases",
-        "Troubleshooting guide",
-        "Related resources"
-      ],
-      outputSuggestions: [
-        "Getting started guide",
-        "Step-by-step tutorial",
-        "FAQ section",
-        "Troubleshooting guide"
-      ]
-    },
-    epic: {
-      category: "epic",
-      role: "Technical Project Manager and Architect",
-      perspective: "You are planning and coordinating a large initiative.",
-      focus: [
-        "Scope definition",
-        "Task breakdown",
-        "Dependencies",
-        "Risk assessment",
-        "Timeline considerations",
-        "Success metrics"
-      ],
-      outputSuggestions: [
-        "Epic breakdown into stories",
-        "Dependency graph",
-        "Risk mitigation plan",
-        "Success criteria"
-      ]
-    },
-    custom: {
-      category: "custom",
-      role: "Software Engineer",
-      perspective: "You are working on a software task.",
-      focus: [
-        "Understanding requirements",
-        "Implementation approach",
-        "Quality considerations",
-        "Testing strategy"
-      ],
-      outputSuggestions: [
-        "Implementation plan",
-        "Technical notes",
-        "Task checklist"
-      ]
-    }
-  };
-  VARIANT_INSTRUCTIONS = {
-    analysis: `ANALYSIS MODE: Analyze this task thoroughly. Identify requirements, constraints, edge cases, and potential challenges. Do NOT implement anything yet - focus on understanding and planning.`,
-    draft: `DRAFT MODE: Create a detailed implementation plan with code structure, key decisions, and approach. Include pseudocode or skeleton code where helpful. This is for review before full implementation.`,
-    execute: `EXECUTE MODE: Implement this task completely. Write production-ready code following best practices. Include necessary tests and documentation.`
-  };
-});
-init_prompt_builder();
-
-export {
-  inferCategoryFromLabels,
-  getRoleFraming,
-  getAvailableVariants,
-  getAvailableCategories,
-  generatePrompt
-};