jettypod 4.3.0 → 4.4.1

package/skills-templates/chore-mode/verification.js

@@ -0,0 +1,255 @@
+/**
+ * Type-specific verification runner for chore-mode skill
+ * Runs verification checklist from chore taxonomy based on chore type
+ */
+
+const { getGuidance, CHORE_TYPES } = require('../../../lib/chore-taxonomy');
+
+/**
+ * Create a verification check result
+ *
+ * @param {string} description - What is being verified
+ * @param {boolean} passed - Whether the check passed
+ * @param {string} [details] - Additional details or failure reason
+ * @returns {{description: string, passed: boolean, details?: string}}
+ */
+function createCheck(description, passed, details = null) {
+  const check = { description, passed };
+  if (details) check.details = details;
+  return check;
+}
+
+/**
+ * Run all verification checks for a chore type
+ *
+ * @param {string} type - Chore type (refactor, dependency, cleanup, tooling)
+ * @param {object} context - Context about the chore execution
+ * @param {object} context.testResult - Test execution result
+ * @param {boolean} context.testResult.passed - Whether tests passed
+ * @param {number} context.testResult.total - Total tests run
+ * @param {boolean} [context.testsModified] - Whether test assertions were changed
+ * @param {boolean} [context.newFunctionalityAdded] - Whether new features were added
+ * @param {string[]} [context.deprecationWarnings] - Any deprecation warnings found
+ * @param {boolean} [context.unusedCodeVerified] - Whether code was verified unused
+ * @param {boolean} [context.ciPassed] - Whether CI pipeline passed
+ * @returns {{passed: boolean, checks: Array<{description: string, passed: boolean, details?: string}>}}
+ */
+function runVerificationChecklist(type, context = {}) {
+  const guidance = getGuidance(type);
+  const checks = [];
+  let allPassed = true;
+
+  // Run type-specific verification based on taxonomy criteria
+  switch (type) {
+    case CHORE_TYPES.REFACTOR:
+      checks.push(...runRefactorChecks(guidance, context));
+      break;
+
+    case CHORE_TYPES.DEPENDENCY:
+      checks.push(...runDependencyChecks(guidance, context));
+      break;
+
+    case CHORE_TYPES.CLEANUP:
+      checks.push(...runCleanupChecks(guidance, context));
+      break;
+
+    case CHORE_TYPES.TOOLING:
+      checks.push(...runToolingChecks(guidance, context));
+      break;
+
+    default:
+      checks.push(createCheck(
+        'Valid chore type',
+        false,
+        `Unknown type: ${type}`
+      ));
+  }
+
+  // Calculate overall pass/fail
+  allPassed = checks.every(check => check.passed);
+
+  return {
+    passed: allPassed,
+    checks
+  };
+}
+
+/**
+ * Run refactor-specific verification checks
+ */
+function runRefactorChecks(guidance, context) {
+  const checks = [];
+
+  // "All existing tests pass without modification"
+  checks.push(createCheck(
+    'All existing tests pass without modification',
+    context.testResult?.passed === true,
+    context.testResult?.passed ? null : 'Tests failed - refactor may have broken behavior'
+  ));
+
+  // Check if tests were modified (should NOT be)
+  checks.push(createCheck(
+    'No test assertions modified',
+    context.testsModified !== true,
+    context.testsModified ? 'Test assertions were changed - this violates refactor rules' : null
+  ));
+
+  // "No new functionality added"
+  checks.push(createCheck(
+    'No new functionality added',
+    context.newFunctionalityAdded !== true,
+    context.newFunctionalityAdded ? 'New functionality detected - this should be a feature, not a refactor' : null
+  ));
+
+  // "Performance is not degraded" - assumed pass unless context indicates otherwise
+  checks.push(createCheck(
+    'Performance not degraded',
+    context.performanceDegraded !== true,
+    context.performanceDegraded ? 'Performance regression detected' : null
+  ));
+
+  return checks;
+}
+
+/**
+ * Run dependency-specific verification checks
+ */
+function runDependencyChecks(guidance, context) {
+  const checks = [];
+
+  // "All tests pass after update"
+  checks.push(createCheck(
+    'All tests pass after update',
+    context.testResult?.passed === true,
+    context.testResult?.passed ? null : 'Tests failed after dependency update'
+  ));
+
+  // "Application builds successfully" - assumed from test pass
+  checks.push(createCheck(
+    'Application builds successfully',
+    context.buildPassed !== false,
+    context.buildPassed === false ? 'Build failed' : null
+  ));
+
+  // "No new deprecation warnings"
+  const hasDeprecations = context.deprecationWarnings && context.deprecationWarnings.length > 0;
+  checks.push(createCheck(
+    'No new deprecation warnings (or documented)',
+    !hasDeprecations || context.deprecationsDocumented === true,
+    hasDeprecations && !context.deprecationsDocumented
+      ? `Found ${context.deprecationWarnings.length} deprecation warnings`
+      : null
+  ));
+
+  return checks;
+}
+
+/**
+ * Run cleanup-specific verification checks
+ */
+function runCleanupChecks(guidance, context) {
+  const checks = [];
+
+  // "All tests still pass"
+  checks.push(createCheck(
+    'All tests still pass',
+    context.testResult?.passed === true,
+    context.testResult?.passed ? null : 'Tests failed after cleanup'
+  ));
+
+  // "No broken imports or references"
+  checks.push(createCheck(
+    'No broken imports or references',
+    context.brokenReferences !== true,
+    context.brokenReferences ? 'Broken references found' : null
+  ));
+
+  // "Removed code was actually unused"
+  checks.push(createCheck(
+    'Removed code was verified unused',
+    context.unusedCodeVerified === true,
+    context.unusedCodeVerified ? null : 'Code usage was not verified before removal'
+  ));
+
+  return checks;
+}
+
+/**
+ * Run tooling-specific verification checks
+ */
+function runToolingChecks(guidance, context) {
+  const checks = [];
+
+  // "CI pipeline passes"
+  checks.push(createCheck(
+    'CI pipeline passes',
+    context.ciPassed === true,
+    context.ciPassed ? null : 'CI not verified or failed'
+  ));
+
+  // "Build completes successfully"
+  checks.push(createCheck(
+    'Build completes successfully',
+    context.buildPassed !== false,
+    context.buildPassed === false ? 'Build failed' : null
+  ));
+
+  // "No regression in build times or developer experience"
+  checks.push(createCheck(
+    'No regression in build times/DX',
+    context.dxRegression !== true,
+    context.dxRegression ? 'Developer experience regression detected' : null
+  ));
+
+  return checks;
+}
+
+/**
+ * Format verification results for display
+ *
+ * @param {{passed: boolean, checks: Array}} result - Verification result
+ * @returns {string} Formatted string for display
+ */
+function formatVerificationResult(result) {
+  const lines = [];
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  lines.push('🔍 Verification Checklist');
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  lines.push('');
+
+  for (const check of result.checks) {
+    const icon = check.passed ? '✅' : '❌';
+    lines.push(`${icon} ${check.description}`);
+    if (check.details) {
+      lines.push(`   └─ ${check.details}`);
+    }
+  }
+
+  lines.push('');
+  if (result.passed) {
+    lines.push('✅ All verification checks passed');
+  } else {
+    const failedCount = result.checks.filter(c => !c.passed).length;
+    lines.push(`❌ ${failedCount} verification check(s) failed`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Get verification criteria from taxonomy for display
+ *
+ * @param {string} type - Chore type
+ * @returns {string[]} Array of verification criteria strings
+ */
+function getVerificationCriteria(type) {
+  const guidance = getGuidance(type);
+  return guidance.verification || [];
+}
+
+module.exports = {
+  runVerificationChecklist,
+  formatVerificationResult,
+  getVerificationCriteria,
+  createCheck
+};

package/skills-templates/chore-planning/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: chore-planning
+description: Guide standalone chore planning with automatic type classification, taxonomy guidance loading, and routing to chore-mode for execution. Use when user starts a standalone chore (chore with no parent feature), mentions planning a chore, or says "help me with this chore".
+---
+
+# Chore Planning Skill
+
+Guides Claude through standalone chore planning including automatic type classification, loading type-specific guidance from the taxonomy, building enriched context, and routing to chore-mode for execution.
+
+## Instructions
+
+When this skill is activated, you are helping plan a standalone chore (one without a parent feature). Follow this structured approach:
+
+### Step 1: Understand the Chore Context
+
+You'll receive context about:
+- Chore title and description
+- Project context
+- No parent feature (standalone chores don't have features)
+
+Display:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔧 Planning Standalone Chore
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Chore:** [Title]
+**Description:** [Description if provided]
+
+Analyzing chore type...
+```
+
+### Step 2: Classify Chore Type
+
+**CRITICAL:** Use the chore-classifier to determine the chore type automatically.
+
+**Execute this code:**
+
+```javascript
+const { classifyChoreType, classifyWithConfidence } = require('./lib/chore-classifier');
+
+const choreTitle = '[chore title]';
+const choreDescription = '[chore description or empty string]';
+
+const classification = classifyWithConfidence(choreTitle, choreDescription);
+console.log('Classification:', JSON.stringify(classification, null, 2));
+```
+
+Display the classification result:
+
+```
+**Type Classification:** [type] (confidence: [high/medium/low])
+```
+
+**If confidence is low:**
+```
+⚠️ Low confidence classification. The chore might be:
+- [type] - because [reason based on keywords found]
+- [alternative type] - if [alternative interpretation]
+
+Proceeding with [type]. Let me know if this should be different.
+```
+
+### Step 3: Load Taxonomy Guidance
+
+**Execute this code to load type-specific guidance:**
+
+```javascript
+const { getGuidance } = require('./lib/chore-taxonomy');
+
+const guidance = getGuidance('[classified-type]');
+console.log('Guidance:', JSON.stringify(guidance, null, 2));
+```
+
+Display the guidance:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📋 [Type] Chore Guidance
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Scope Considerations:**
+[List each scope item from guidance]
+
+**Verification Criteria:**
+[List each verification item from guidance]
+
+**Test Handling:**
+- Tests required: [yes/no]
+- Approach: [testHandling.approach]
+```
+
+### Step 4: Build Enriched Context
+
+Combine all information into a structured context object:
+
+```javascript
+const choreContext = {
+  chore: {
+    id: [chore-id],
+    title: '[title]',
+    description: '[description]',
+    type: 'chore',
+    parent_id: null  // standalone
+  },
+  classification: {
+    type: '[classified-type]',
+    confidence: '[high/medium/low]'
+  },
+  guidance: {
+    scope: [...],
+    verification: [...],
+    testHandling: {
+      required: true/false,
+      approach: '...'
+    }
+  }
+};
+```
+
+### Step 5: Analyze Codebase Impact
+
+Based on the chore type and guidance, analyze what needs to be done:
+
+**For REFACTOR chores:**
+- Identify the code being restructured
+- Find all callers/dependents
+- List affected test files
+
+**For DEPENDENCY chores:**
+- Check current version
+- Review changelog for breaking changes
+- Identify affected code
+
+**For CLEANUP chores:**
+- Find all references to code being removed
+- Verify nothing depends on it
+- List files to modify
+
+**For TOOLING chores:**
+- Check current tool configuration
+- Identify affected workflows
+- Review CI/CD impacts
+
+Display analysis:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 Impact Analysis
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Files to modify:**
+[List of files]
+
+**Tests to run:**
+[List of test files/patterns]
+
+**Verification steps:**
+[Specific steps based on guidance]
+```
+
+### Step 6: Create Implementation Plan
+
+Based on the analysis, create a focused plan:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📝 Implementation Plan
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Step 1:** [First action]
+**Step 2:** [Second action]
+...
+
+**Verification:**
+1. [First check from guidance]
+2. [Second check from guidance]
+...
+
+Ready to proceed?
+```
+
+### Step 7: Route to Chore Mode
+
+**WAIT for user confirmation.**
+
+When user confirms (responds with "yes", "proceed", "let's go", etc.):
+
+**Invoke the chore-mode skill using the Skill tool:**
+
+```
+Use the Skill tool with skill: "chore-mode"
+```
+
+The chore-mode skill will:
+1. Create a worktree for the chore
+2. Execute the implementation plan
+3. Run verification steps
+4. Merge when complete
+
+**End chore-planning skill after invoking chore-mode.**
+
+## Key Principles
+
+1. **Automatic classification** - AI determines chore type from title/description
+2. **Taxonomy-driven guidance** - Load specific guidance for each chore type
+3. **Context enrichment** - Build complete context before execution
+4. **Impact analysis** - Understand what the chore affects
+5. **Verification-focused** - Use type-specific verification criteria
+6. **Seamless handoff** - Route to chore-mode with full context
+
+## Chore Type Quick Reference
+
+| Type | Keywords | Test Handling |
+|------|----------|---------------|
+| refactor | refactor, restructure, extract, rename | Run all tests, don't modify assertions |
+| dependency | update, upgrade, bump, migrate | Run full suite, check for deprecations |
+| cleanup | remove, delete, unused, legacy | Verify no references, run affected tests |
+| tooling | ci, build, lint, config | Run affected pipelines |
+
+## Validation
+
+Before routing to chore-mode, ensure:
+- [ ] Chore type classified
+- [ ] Taxonomy guidance loaded
+- [ ] Impact analysis complete
+- [ ] Implementation plan created
+- [ ] User confirmed ready to proceed

package/skills-templates/epic-planning/SKILL.md

@@ -159,13 +159,21 @@ Once features are defined and architectural decision is made (if needed):
 
 #### Step 6A: Create Features
 
-Use the Bash tool to create each feature:
+**CRITICAL:** You MUST pass the `--parent=<epic-id>` flag with the actual numeric epic ID. Without this, features won't appear under the epic in the backlog tree.
+
+Use the Bash tool to create each feature. Replace `<EPIC_ID>` with the actual epic ID number:
 
 ```javascript
-// For each feature, use Bash tool to execute:
-node jettypod.js work create feature "[Feature 1]" "[Description]" --parent=[epic-id]
-node jettypod.js work create feature "[Feature 2]" "[Description]" --parent=[epic-id]
-// etc.
+// CORRECT - uses actual numeric epic ID:
+node jettypod.js work create feature "Live cursor tracking" "Track cursor positions in real-time" --parent=5
+
+// WRONG - missing parent flag (feature won't be under epic):
+node jettypod.js work create feature "Live cursor tracking" "Track cursor positions in real-time"
+```
+
+For each feature, execute:
+```bash
+node jettypod.js work create feature "<Title>" "<Description>" --parent=<EPIC_ID>
 ```
 
 Display to user as you create each one: