jettypod 4.4.116 → 4.4.120

package/templates/bdd-scaffolding/world.js

@@ -0,0 +1,19 @@
+/**
+ * Cucumber World configuration.
+ * Provides per-scenario state via `this` in step definitions.
+ * Use this instead of module-level let/var for test state.
+ *
+ * Place at: features/support/world.js
+ */
+const { setWorldConstructor } = require('@cucumber/cucumber');
+
+class TestWorld {
+  constructor() {
+    // Per-scenario state — automatically reset between scenarios.
+    // Add properties here or in step definitions via this.propName = value
+  }
+}
+
+setWorldConstructor(TestWorld);
+
+module.exports = { TestWorld };

package/apps/dashboard/app/access-code/page.tsx

@@ -1,110 +0,0 @@
-'use client';
-
-import { useState } from 'react';
-import Image from 'next/image';
-
-export default function AccessCodePage() {
-  const [code, setCode] = useState('');
-  const [error, setError] = useState<string | null>(null);
-  const [isSubmitting, setIsSubmitting] = useState(false);
-
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault();
-    setError(null);
-
-    if (!code.trim()) {
-      setError('Please enter an access code.');
-      return;
-    }
-
-    if (!window.electronAPI?.isElectron) {
-      setError('Access code validation is only available in the desktop app.');
-      return;
-    }
-
-    setIsSubmitting(true);
-
-    try {
-      const result = await window.electronAPI.access.validate(code.trim());
-
-      if (!result.success) {
-        setError(result.error || 'Invalid access code.');
-        setIsSubmitting(false);
-        return;
-      }
-
-      // Access granted - navigate to main app
-      window.location.href = '/';
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to validate access code.');
-      setIsSubmitting(false);
-    }
-  };
-
-  return (
-    <div className="flex flex-col items-center justify-center min-h-screen bg-white dark:bg-zinc-900 p-8">
-      <div className="max-w-md w-full space-y-8">
-        {/* Logo */}
-        <div className="flex flex-col items-center space-y-4">
-          <Image
-            src="/jettypod_wordmark.png"
-            alt="JettyPod"
-            width={160}
-            height={40}
-            priority
-          />
-          <h1 className="text-2xl font-semibold text-zinc-900 dark:text-zinc-100 text-center">
-            Enter Access Code
-          </h1>
-          <p className="text-zinc-500 dark:text-zinc-400 text-center">
-            Enter your access code to get started with JettyPod.
-          </p>
-        </div>
-
-        {/* Error */}
-        {error && (
-          <div className="bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 text-red-700 dark:text-red-400 px-4 py-3 rounded-lg text-sm">
-            {error}
-          </div>
-        )}
-
-        {/* Form */}
-        <form onSubmit={handleSubmit} className="pt-4 space-y-4">
-          <input
-            type="text"
-            value={code}
-            onChange={(e) => setCode(e.target.value)}
-            placeholder="Access code"
-            autoFocus
-            disabled={isSubmitting}
-            className="w-full px-4 py-3 rounded-xl border border-zinc-300 dark:border-zinc-600 bg-white dark:bg-zinc-800 text-zinc-900 dark:text-zinc-100 placeholder-zinc-400 dark:placeholder-zinc-500 focus:outline-none focus:ring-2 focus:ring-zinc-400 dark:focus:ring-zinc-500 disabled:opacity-50"
-            data-testid="access-code-input"
-          />
-          <button
-            type="submit"
-            disabled={isSubmitting}
-            className="w-full py-3 px-6 rounded-xl font-medium transition-all duration-200 hover:-translate-y-1 hover:scale-[1.01] active:translate-y-0 active:scale-100 disabled:opacity-50 disabled:pointer-events-none"
-            style={{
-              cursor: isSubmitting ? 'default' : 'pointer',
-              background: 'linear-gradient(145deg, #ffffff 0%, #faf9f7 10%, #f0f4f4 35%, #c8d9da 55%, #819D9F 90%)',
-              color: '#3d4d4e',
-              boxShadow: `
-                0 1px 1px rgba(0, 0, 0, 0.02),
-                0 2px 4px rgba(0, 0, 0, 0.03),
-                0 6px 12px rgba(0, 0, 0, 0.05),
-                0 12px 24px rgba(0, 0, 0, 0.06),
-                0 20px 40px rgba(129, 157, 159, 0.2),
-                0 32px 64px rgba(129, 157, 159, 0.18),
-                inset 0 2px 4px rgba(255, 255, 255, 1),
-                inset 0 -2px 4px rgba(129, 157, 159, 0.05)
-              `,
-            }}
-            data-testid="access-code-submit"
-          >
-            {isSubmitting ? 'Validating...' : 'Continue'}
-          </button>
-        </form>
-      </div>
-    </div>
-  );
-}

package/lib/discovery-checkpoint.js

@@ -1,123 +0,0 @@
-const config = require('./config');
-
-/**
- * Update discovery checkpoint with current progress
- * @param {number} step - Current discovery step (1-7)
- * @param {Object} data - Checkpoint data (user_journey, ux_approach, epics_created)
- */
-function updateCheckpoint(step, data = {}) {
-  const currentConfig = config.read();
-
-  // Ensure project_discovery exists
-  if (!currentConfig.project_discovery) {
-    currentConfig.project_discovery = config.getDefaultProjectDiscovery();
-  }
-
-  // Update checkpoint
-  currentConfig.project_discovery.checkpoint = {
-    step,
-    user_journey: data.user_journey || currentConfig.project_discovery.checkpoint?.user_journey || null,
-    ux_approach: data.ux_approach || currentConfig.project_discovery.checkpoint?.ux_approach || null,
-    epics_created: data.epics_created !== undefined ? data.epics_created : (currentConfig.project_discovery.checkpoint?.epics_created || false)
-  };
-
-  // Update status to in_progress if not already completed
-  if (currentConfig.project_discovery.status === 'not_started') {
-    currentConfig.project_discovery.status = 'in_progress';
-    currentConfig.project_discovery.started_date = new Date().toISOString();
-  }
-
-  config.write(currentConfig);
-}
-
-/**
- * Get current discovery checkpoint
- * @returns {Object|null} Checkpoint data or null if not started
- */
-function getCheckpoint() {
-  const currentConfig = config.read();
-
-  if (!currentConfig.project_discovery || currentConfig.project_discovery.status === 'not_started') {
-    return null;
-  }
-
-  return currentConfig.project_discovery.checkpoint || null;
-}
-
-/**
- * Clear discovery checkpoint (when discovery is completed)
- */
-function clearCheckpoint() {
-  const currentConfig = config.read();
-
-  if (currentConfig.project_discovery) {
-    currentConfig.project_discovery.checkpoint = config.getDefaultProjectDiscovery().checkpoint;
-    config.write(currentConfig);
-  }
-}
-
-/**
- * Get human-readable description of current checkpoint step
- * @param {number} step - Step number
- * @returns {string} Step description
- */
-function getStepDescription(step) {
-  const steps = {
-    1: 'Starting discovery - define user journey',
-    2: 'User journey defined - present UX approaches',
-    3: 'UX approach selected - build prototypes',
-    4: 'Prototypes tested - break into epics',
-    5: 'Epics created - choose tech stack',
-    6: 'Tech stack chosen - record decision',
-    7: 'Discovery complete'
-  };
-
-  return steps[step] || 'Unknown step';
-}
-
-/**
- * Generate a formatted resume message for displaying when resuming discovery
- * @param {Object} checkpoint - Checkpoint object with step, user_journey, ux_approach, epics_created
- * @returns {string|null} Formatted resume message or null if no checkpoint
- */
-function generateResumeMessage(checkpoint) {
-  if (!checkpoint) {
-    return null;
-  }
-
-  const stepDesc = getStepDescription(checkpoint.step);
-
-  let lines = [
-    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
-    '🔄 RESUMING PROJECT DISCOVERY',
-    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
-    '',
-    `📍 Resuming from Step ${checkpoint.step}: ${stepDesc}`,
-    ''
-  ];
-
-  if (checkpoint.user_journey) {
-    lines.push(`📝 User Journey: "${checkpoint.user_journey}"`);
-  }
-  if (checkpoint.ux_approach) {
-    lines.push(`🎨 UX Approach: "${checkpoint.ux_approach}"`);
-  }
-  if (checkpoint.epics_created) {
-    lines.push(`✅ Epics: Already created`);
-  }
-
-  lines.push('');
-  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-  lines.push('');
-  lines.push('Continuing where you left off...');
-
-  return lines.join('\n');
-}
-
-module.exports = {
-  updateCheckpoint,
-  getCheckpoint,
-  clearCheckpoint,
-  getStepDescription,
-  generateResumeMessage
-};

package/skills-templates/project-discovery/SKILL.md

@@ -1,372 +0,0 @@
----
-name: project-discovery
-description: "Guide new project planning from blank slate to epics. Auto-activates when project has no implementation code. Walks user through journey exploration, UX approach selection, optional prototyping, epic breakdown, and tech stack selection."
----
-
-# Project Discovery Skill
-
-Guides users through planning a new project from blank slate to epics. Auto-activates when a blank project (no implementation code) is detected.
-
-## Instructions
-
-When this skill is activated, you are guiding a user through planning a brand new project. Follow this structured approach:
-
-### Step 1: Check for Resume (Checkpoint)
-
-**First, check if there's an existing checkpoint** from a previous session:
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  const data = checkpoint.getCheckpoint();
-  if (data && data.step > 1) {
-    // Resume from checkpoint - display resume message
-    const resumeMessage = checkpoint.generateResumeMessage(data);
-    console.log(resumeMessage);
-    // Then skip to appropriate step based on data.step
-  }
-} catch (e) {
-  // No checkpoint - start fresh
-}
-```
-
-**If resuming from checkpoint:**
-
-Use `generateResumeMessage(checkpoint)` from `lib/discovery-checkpoint.js` to display:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🔄 RESUMING PROJECT DISCOVERY
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📍 Resuming from Step [step]: [step description]
-
-📝 User Journey: "[user_journey]"      (if exists)
-🎨 UX Approach: "[ux_approach]"        (if exists)
-✅ Epics: Already created              (if epics_created)
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Continuing where you left off...
-```
-
-Then skip to the appropriate step based on `checkpoint.step`.
-
-**If starting fresh:** Continue to Step 2.
-
----
-
-### Step 2: Greet and Explore User Goal
-
-**Your FIRST words to the user must be:**
-
-> 👋 Hey there. It looks like you're kicking off a new project. I'm going to use JettyPod to guide you through building and shipping high quality code.
->
-> And FYI, JettyPod is fully set up in your project for all future Claude Code sessions.
->
-> **Ready to do this?**
-
-**WAIT FOR USER RESPONSE.**
-
-After they respond affirmatively, continue with:
-
-> Awesome!
->
-> Here is how we are going to kick things off:
->
-> 1. I'll help you explore some prototypes to define what users actually do in your product
-> 2. We'll choose a tech stack that fits
-> 3. I'll break the project into phases so you have a clear plan
->
-> Let's start simple: What do users DO in this product? Walk me through it.
->
-> If that's not clear yet, what are you trying to help them accomplish?
-
-**WAIT FOR USER RESPONSE.**
-
----
-
-### Step 3: Explore User Journey
-
-After user responds with their goal, ask about the user journey:
-
-> Do you have a clear picture of how users will accomplish this? Like, what's the flow from opening your product to getting value from it?
->
-> If yes, walk me through it. If not, I can suggest some user journey ideas based on what you've described.
-
-**If user wants journey suggestions, present exactly 3 journey options:**
-
-```
-Here are 3 different ways users could accomplish [their goal]:
-
-**Journey Option 1: [Simple/Direct approach name]**
-- **Flow**: [Step-by-step user actions]
-- **Pros**: ✅ [2-3 advantages - fast, familiar, low friction]
-- **Cons**: ❌ [2-3 trade-offs - limitations, constraints]
-
-**Journey Option 2: [Balanced approach name]**
-- **Flow**: [Step-by-step user actions]
-- **Pros**: ✅ [2-3 advantages - good balance]
-- **Cons**: ❌ [2-3 trade-offs]
-
-**Journey Option 3: [Advanced/Guided approach name]**
-- **Flow**: [Step-by-step user actions]
-- **Pros**: ✅ [2-3 advantages - powerful, guided]
-- **Cons**: ❌ [2-3 trade-offs - complexity, learning curve]
-
-**Additional journey patterns considered:**
-- *Alternative 1*: [Brief] - Not recommended because [reason]
-- *Alternative 2*: [Brief] - Not recommended because [reason]
-
-Which journey resonates with you? Or do you want to describe your own?
-```
-
-**WAIT FOR USER RESPONSE.**
-
-**After user picks/describes journey, save checkpoint:**
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  checkpoint.updateCheckpoint(2, { user_journey: "[their chosen/described journey]" });
-} catch (e) {
-  // Checkpoint module optional - skip if not available
-}
-```
-
----
-
-### Step 4: Explore UX Approach
-
-**Present exactly 3 UX approaches** (NOT tech stacks - focus on what it FEELS LIKE to use):
-
-Adapt to their workflow. Example patterns:
-- Command-Line Workflow vs Visual Dashboard vs Conversational AI
-- Template Selection vs Drag-and-Drop Editor vs Code-First
-- Linear Document vs Networked Notes vs Canvas-Based
-
-```
-**Option 1: [Simple approach]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **Experience**: [What it feels like to use]
-
-**Option 2: [Balanced approach]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **Experience**: [What it feels like to use]
-
-**Option 3: [Advanced approach]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **Experience**: [What it feels like to use]
-
-**Additional approaches considered but not recommended:**
-- *Alternative 1*: [Brief] - Not selected because [reason]
-- *Alternative 2*: [Brief] - Not selected because [reason]
-- *Alternative 3*: [Brief] - Not selected because [reason]
-
-**Would you like me to create working prototypes of these experiences?**
-```
-
-**WAIT FOR USER RESPONSE.**
-
----
-
-### Step 4B: Optional Prototyping
-
-**If user wants prototypes:**
-
-For each prototype approach, run:
-```bash
-jettypod project prototype start <approach-name>
-```
-
-This creates a worktree at `.jettypod-work/project-prototype-<approach>/`. Build the prototype using **absolute paths**:
-- `<worktree_path>/prototypes/<approach>/` for prototype files
-- Focus on demonstrating the FEEL, not production code
-- Use whatever tech is FASTEST to show the experience
-
-After building, commit and merge:
-```bash
-cd <worktree_path>
-git add .
-git commit -m "Add project prototype: <approach>"
-jettypod project prototype merge
-```
-
-Repeat for each approach. Each merge lands the prototype on main in `/prototypes/`.
-
-**After building prototypes, offer to open them:**
-
-> Want me to open these in your browser so you can try them out?
-
-If yes, use: `open prototypes/<approach>/index.html`
-
-**After ANY prototype modifications or tweaks, always ask:**
-
-> Got it - I've updated the prototype.
->
-> Do you feel like you have enough clarity on the basic user journey now? Like, do you know what users will DO to get value from this?
->
-> If yes, let's break this down into phases and start building the real thing.
-> If no, what else do you want to explore with the prototype?
-
-**Important:** Prototypes are for learning and answering questions, not for building production features. Don't let users iterate endlessly - help them move forward once they have clarity on the user journey.
-
----
-
-### Step 5: Epic Breakdown
-
-**After user picks UX approach winner, save checkpoint:**
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  checkpoint.updateCheckpoint(4, { ux_approach: "[chosen option]" });
-} catch (e) {
-  // Checkpoint module optional - skip if not available
-}
-```
-
-**Propose epic breakdown:**
-
-> Based on what you described, here's how I'd break this into epics.
->
-> **Quick context:** Epics are phase-level chunks of work that each contain several features. For example, an epic might be "User Authentication" which includes features like "Email/password login", "Password reset", and "Social login".
->
-> Here's what I'm thinking:
->
-> **Epic 1: [Name]** - [What it covers - specific capabilities]
-> **Epic 2: [Name]** - [What it covers]
-> **Epic 3: [Name]** - [What it covers]
->
-> Sound right?
-
-**WAIT FOR USER RESPONSE.**
-
-After user confirms (with any adjustments), create the epics:
-
-```bash
-jettypod work create epic "[Epic Name]" "[Description]"
-```
-
-After creating all epics, display:
-
-> ✅ Epics created and added to your backlog.
-
-**Save checkpoint:**
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  checkpoint.updateCheckpoint(5, { epics_created: true });
-} catch (e) {
-  // Checkpoint module optional - skip if not available
-}
-```
-
----
-
-### Step 6: Tech Stack Selection
-
-**Present exactly 3 tech stack options** appropriate for the UX approach they chose:
-
-```
-Now let's pick the tech stack. Based on [their chosen UX approach], here are 3 options:
-
-**Option 1: [Tech stack name]**
-- **Pros**: ✅ [2-3 advantages - why this is good for their use case]
-- **Cons**: ❌ [2-3 trade-offs - limitations or costs]
-- **What you'll get**: [What development will feel like, deployment complexity, learning curve]
-
-**Option 2: [Tech stack name]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **What you'll get**: [Development experience, deployment, learning curve]
-
-**Option 3: [Tech stack name]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **What you'll get**: [Development experience, deployment, learning curve]
-
-**Other options considered:**
-- *Alternative 1*: [Brief] - Not recommended because [reason]
-- *Alternative 2*: [Brief] - Not recommended because [reason]
-
-Which tech stack fits best for you?
-```
-
-**Important:** If they're building a web application, use shadcn/ui as the default component library (don't ask - just use it when building UI).
-
-**WAIT FOR USER RESPONSE.**
-
-**Save checkpoint:**
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  checkpoint.updateCheckpoint(6, {});
-} catch (e) {
-  // Checkpoint module optional - skip if not available
-}
-```
-
----
-
-### Step 7: Confirm Rationale and Complete Discovery
-
-**Propose the rationale to the user first:**
-
-> I'm going to record this decision:
->
-> Winner: prototypes/[path]
-> Rationale: [experience] with [tech] because [reason]
->
-> Does this capture why you chose this approach? (You can edit the rationale if needed)
-
-**WAIT FOR USER RESPONSE.**
-
-**After user confirms, record the decision:**
-
-```bash
-jettypod project discover complete --winner="prototypes/[path]" --rationale="[user's confirmed/edited rationale]"
-```
-
----
-
-### Step 8: Educational Transition
-
-**After recording decision, provide this educational transition:**
-
-> 🎉 Project discovery complete! You've got your epics defined and we know what we're building.
->
-> **Here's how we'll build this, one piece at a time:**
->
-> We're entering a repeatable workflow that you'll use for the rest of this project. Think of it like Russian nesting dolls:
->
-> 📦 **Epic** = A big capability (like "User Authentication" or "Real-time Collaboration")
->   └─ ✨ **Feature** = Something users actually do (like "Email/password login" or "Live cursor tracking")
->       └─ 🔧 **Chore** = Technical tasks to build that feature (like "Create login form" or "Hash passwords")
->
-> **Two phases for everything you build:**
->
-> 1️⃣ **Discovery Phase** - Figure out what to build
->    - We'll explore 2-3 different approaches
->    - You pick the winner
->    - We write test scenarios
->    - **You only do this once per feature**
->
-> 2️⃣ **Implementation Phase** - Build it in 3 modes
->    - **Speed Mode**: Prove it works (happy path only, ~2 hours)
->    - **Stable Mode**: Make it dependable (error handling, edge cases - this is where features live)
->    - **Production Mode**: Safe for customers (security, scale, compliance - only needed if customers use it)
->
-> **We won't talk about modes yet** - you'll learn those when you start implementing. Right now, focus on discovery.
->
-> **Next step: Plan your first epic**
->
-> Pick one epic to start with (usually the foundational one). Then tell me:
-> "Let's plan [epic name]"
-
-**Discovery is complete.** Wait for user to choose which epic to plan next.