jumpstart-mode 1.1.11 → 1.1.13

package/bin/lib/tool-schemas.js

@@ -247,6 +247,7 @@ const ALL_TOOLS = [
               'approval', 'rejection',
               'subagent_invoked', 'subagent_completed',
               'llm_turn_start', 'llm_turn_end',
+              'prompt_logged',
               'research_query', 'checkpoint_created', 'rewind',
               'handoff', 'usage_logged', 'custom'
             ],
@@ -280,6 +281,283 @@ const ALL_TOOLS = [
         required: ['event_type', 'action']
       }
     }
+  },
+  // ─── Usage Logging ──────────────────────────────────────────────────────────
+  {
+    type: 'function',
+    function: {
+      name: 'log_usage',
+      description: 'Log token usage and estimated cost for the current agent session to the usage log (.jumpstart/usage-log.json). Call this at the end of each phase or significant agent interaction to maintain an audit trail of LLM consumption.',
+      parameters: {
+        type: 'object',
+        properties: {
+          phase: {
+            type: 'string',
+            description: 'Phase identifier (e.g., "phase-0", "scout", "phase-3").'
+          },
+          agent: {
+            type: 'string',
+            description: 'Agent name (e.g., "Challenger", "Architect", "Developer").'
+          },
+          action: {
+            type: 'string',
+            description: 'Action description (e.g., "generation", "review", "consultation").'
+          },
+          estimated_tokens: {
+            type: 'number',
+            description: 'Estimated total token count for this interaction.'
+          },
+          estimated_cost_usd: {
+            type: 'number',
+            description: 'Estimated cost in USD (optional — computed from tokens if omitted).'
+          },
+          model: {
+            type: 'string',
+            description: 'Model name/ID used for this interaction.'
+          },
+          metadata: {
+            type: 'object',
+            description: 'Additional metadata (e.g., { "turns": 12, "artifact": "specs/prd.md" }).'
+          }
+        },
+        required: ['phase', 'agent', 'action', 'estimated_tokens']
+      }
+    }
+  },
+  // ─── Item-Tagged Feature Tools ─────────────────────────────────────────
+  {
+    type: 'function',
+    function: {
+      name: 'run_revert',
+      description: 'Archive a rejected artifact draft and restore the last approved version from git. (Item 40)',
+      parameters: {
+        type: 'object',
+        properties: {
+          artifact: { type: 'string', description: 'Path to the artifact file to revert.' },
+          reason: { type: 'string', description: 'Reason for reverting.' },
+          archive_dir: { type: 'string', description: 'Archive directory (default: .jumpstart/archive).' }
+        },
+        required: ['artifact']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_adr_index',
+      description: 'Build or search an index of Architecture Decision Records. (Item 51)',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['build', 'search'], description: 'Action to perform.' },
+          root: { type: 'string', description: 'Project root directory.' },
+          query: { type: 'string', description: 'Search query (for search action).' },
+          tag: { type: 'string', description: 'Filter by tag (for search action).' }
+        },
+        required: ['action']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_complexity',
+      description: 'Calculate adaptive planning depth (quick/standard/deep) from project signals. (Item 33)',
+      parameters: {
+        type: 'object',
+        properties: {
+          description: { type: 'string', description: 'Free-text problem statement.' },
+          root: { type: 'string', description: 'Project root directory.' }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_crossref',
+      description: 'Validate cross-reference links in spec artifacts and detect broken links and orphan sections. (Item 47)',
+      parameters: {
+        type: 'object',
+        properties: {
+          specs_dir: { type: 'string', description: 'Path to specs directory (default: specs).' },
+          root: { type: 'string', description: 'Project root directory.' }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_init',
+      description: 'Generate initialization configuration based on skill level and project type. (Item 76)',
+      parameters: {
+        type: 'object',
+        properties: {
+          skill_level: { type: 'string', enum: ['beginner', 'intermediate', 'expert'], description: 'User skill level.' },
+          project_type: { type: 'string', enum: ['greenfield', 'brownfield'], description: 'Project type.' }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_lock',
+      description: 'Manage artifact file locks for concurrent agent access. (Item 45)',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['acquire', 'release', 'status', 'list'], description: 'Lock action.' },
+          file: { type: 'string', description: 'File path to lock/unlock (required for acquire/release/status).' },
+          agent: { type: 'string', description: 'Agent name acquiring/releasing the lock.' }
+        },
+        required: ['action']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_timestamp',
+      description: 'Generate, validate, or audit UTC timestamps in ISO 8601 format. (Item 60)',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['now', 'validate', 'audit'], description: 'Timestamp action.' },
+          value: { type: 'string', description: 'Timestamp string to validate (for validate action).' },
+          file: { type: 'string', description: 'File path to audit timestamps in (for audit action).' }
+        },
+        required: ['action']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_scan',
+      description: 'Scan project directory to detect tech stack, dependencies, patterns, and risks. (Item 49)',
+      parameters: {
+        type: 'object',
+        properties: {
+          root: { type: 'string', description: 'Project root directory.' },
+          ignore: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Directories to ignore.'
+          }
+        }
+      }
+    }
+  },
+  // ─── Quality Gate Tools ────────────────────────────────────────────────────
+  {
+    type: 'function',
+    function: {
+      name: 'run_secret_scan',
+      description: 'Scan files for accidentally committed secrets (API keys, tokens, passwords, private keys). Returns structured findings with severity levels.',
+      parameters: {
+        type: 'object',
+        properties: {
+          files: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Array of file paths to scan.'
+          },
+          root: { type: 'string', description: 'Project root directory.' },
+          config: {
+            type: 'object',
+            description: 'Optional configuration.',
+            properties: {
+              custom_patterns: {
+                type: 'array',
+                description: 'Additional secret patterns to check.',
+                items: {
+                  type: 'object',
+                  properties: {
+                    name: { type: 'string' },
+                    pattern: { type: 'string' },
+                    severity: { type: 'string', enum: ['critical', 'high'] }
+                  },
+                  required: ['name', 'pattern']
+                }
+              },
+              allowlist: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'File paths to skip during scanning.'
+              }
+            }
+          }
+        },
+        required: ['files']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_type_check',
+      description: 'Run automated type checking (TypeScript tsc, Python mypy/pyright). Auto-detects the type checker from project configuration.',
+      parameters: {
+        type: 'object',
+        properties: {
+          files: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Specific files to filter results for (optional — type checker runs project-wide).'
+          },
+          root: { type: 'string', description: 'Project root directory.' },
+          config: {
+            type: 'object',
+            description: 'Optional configuration.',
+            properties: {
+              type_command: { type: 'string', description: 'Override the auto-detected type check command.' },
+              strict: { type: 'boolean', description: 'Enable strict mode (TypeScript).' }
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_smoke_test',
+      description: 'Perform a smoke test: build the project and optionally check if the application starts and responds to HTTP requests.',
+      parameters: {
+        type: 'object',
+        properties: {
+          root: { type: 'string', description: 'Project root directory.' },
+          config: {
+            type: 'object',
+            description: 'Optional configuration.',
+            properties: {
+              build_command: { type: 'string', description: 'Override the auto-detected build command.' },
+              start_command: { type: 'string', description: 'Override the auto-detected start command.' },
+              health_url: { type: 'string', description: 'URL to check for health (default: http://localhost:3000/health).' },
+              health_timeout: { type: 'number', description: 'Timeout in ms for health check (default: 10000).' },
+              skip_health_check: { type: 'boolean', description: 'Skip the health check and only verify the build.' }
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_uat_coverage',
+      description: 'Check UAT alignment: verify that PRD acceptance criteria (Gherkin or bullet-point) are covered by actual test files. Returns coverage percentages and detailed mapping.',
+      parameters: {
+        type: 'object',
+        properties: {
+          prd_path: { type: 'string', description: 'Path to the PRD markdown file.' },
+          test_dir: { type: 'string', description: 'Path to the test directory.' }
+        },
+        required: ['prd_path', 'test_dir']
+      }
+    }
   }
 ];
 
@@ -289,7 +567,7 @@ const ALL_TOOLS = [
 const BASE_TOOLS = [
   'read_file', 'create_file', 'replace_string_in_file', 'list_dir',
   'file_search', 'grep_search', 'semantic_search',
-  'ask_questions', 'manage_todo_list', 'record_timeline_event'
+  'ask_questions', 'manage_todo_list', 'record_timeline_event', 'log_usage'
 ];
 
 /** Additional tools unlocked per phase */
@@ -298,8 +576,8 @@ const PHASE_TOOL_ADDITIONS = {
   challenger: [],
   analyst:    [],
   pm:         [],
-  architect:  ['marketplace_install'],
-  developer:  ['run_in_terminal', 'marketplace_install']
+  architect:  ['marketplace_install', 'run_adr_index', 'run_complexity', 'run_crossref', 'run_lock', 'run_scan', 'run_init'],
+  developer:  ['run_in_terminal', 'marketplace_install', 'run_secret_scan', 'run_type_check', 'run_smoke_test', 'run_uat_coverage', 'run_revert', 'run_adr_index', 'run_complexity', 'run_crossref', 'run_lock', 'run_timestamp', 'run_scan', 'run_init']
 };
 
 /**

package/bin/lib/transcript-ingestion.js

@@ -0,0 +1,150 @@
+/**
+ * transcript-ingestion.js — Meeting Transcript Ingestion (Item 74)
+ *
+ * Convert notes and transcripts into artifact updates,
+ * decision proposals, and action items.
+ *
+ * Usage:
+ *   node bin/lib/transcript-ingestion.js ingest|extract|list [options]
+ *
+ * State file: .jumpstart/state/transcripts.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'transcripts.json');
+
+const ACTION_PATTERNS = [
+  /\baction(?:\s+item)?:\s*(.+)/gi,
+  /\bTODO:\s*(.+)/gi,
+  /\b(?:will|should|needs? to)\s+(.+?)(?:\.|$)/gi
+];
+
+const DECISION_PATTERNS = [
+  /\bdecided?\s+(?:to\s+)?(.+?)(?:\.|$)/gi,
+  /\bdecision:\s*(.+)/gi,
+  /\bagreed\s+(?:to\s+)?(.+?)(?:\.|$)/gi
+];
+
+function defaultState() {
+  return { version: '1.0.0', transcripts: [], last_updated: null };
+}
+
+function loadState(stateFile) {
+  const fp = stateFile || DEFAULT_STATE_FILE;
+  if (!fs.existsSync(fp)) return defaultState();
+  try { return JSON.parse(fs.readFileSync(fp, 'utf8')); }
+  catch { return defaultState(); }
+}
+
+function saveState(state, stateFile) {
+  const fp = stateFile || DEFAULT_STATE_FILE;
+  const dir = path.dirname(fp);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  state.last_updated = new Date().toISOString();
+  fs.writeFileSync(fp, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Ingest a transcript text.
+ */
+function ingestTranscript(text, options = {}) {
+  if (!text) return { success: false, error: 'Transcript text is required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const transcript = {
+    id: `TR-${Date.now()}`,
+    title: options.title || 'Untitled Meeting',
+    source: options.source || 'manual',
+    text_length: text.length,
+    ingested_at: new Date().toISOString(),
+    actions: [],
+    decisions: [],
+    key_topics: []
+  };
+
+  // Extract action items
+  for (const pattern of ACTION_PATTERNS) {
+    let match;
+    pattern.lastIndex = 0;
+    while ((match = pattern.exec(text)) !== null) {
+      transcript.actions.push({ text: match[1].trim(), source_pattern: pattern.source.substring(0, 30) });
+    }
+  }
+
+  // Extract decisions
+  for (const pattern of DECISION_PATTERNS) {
+    let match;
+    pattern.lastIndex = 0;
+    while ((match = pattern.exec(text)) !== null) {
+      transcript.decisions.push({ text: match[1].trim() });
+    }
+  }
+
+  // Extract key topics (headings or emphasized text)
+  const headings = text.match(/^#+\s+(.+)$/gm);
+  if (headings) {
+    transcript.key_topics = headings.map(h => h.replace(/^#+\s+/, '').trim());
+  }
+
+  state.transcripts.push(transcript);
+  saveState(state, stateFile);
+
+  return { success: true, transcript };
+}
+
+/**
+ * Extract structured data from a transcript.
+ */
+function extractFromTranscript(transcriptId, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const transcript = state.transcripts.find(t => t.id === transcriptId);
+  if (!transcript) return { success: false, error: `Transcript ${transcriptId} not found` };
+
+  return {
+    success: true,
+    id: transcript.id,
+    title: transcript.title,
+    actions: transcript.actions,
+    decisions: transcript.decisions,
+    key_topics: transcript.key_topics,
+    summary: {
+      action_count: transcript.actions.length,
+      decision_count: transcript.decisions.length,
+      topic_count: transcript.key_topics.length
+    }
+  };
+}
+
+/**
+ * List ingested transcripts.
+ */
+function listTranscripts(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    total: state.transcripts.length,
+    transcripts: state.transcripts.map(t => ({
+      id: t.id,
+      title: t.title,
+      actions: t.actions.length,
+      decisions: t.decisions.length,
+      ingested_at: t.ingested_at
+    }))
+  };
+}
+
+module.exports = {
+  ingestTranscript, extractFromTranscript, listTranscripts,
+  loadState, saveState, defaultState,
+  ACTION_PATTERNS, DECISION_PATTERNS
+};