@ai-sdlc/orchestrator 0.5.0 → 0.9.0

package/dist/workflow-patterns/proposal-generator.js

@@ -0,0 +1,183 @@
+/**
+ * Proposal generator — creates draft automation artifacts from detected patterns.
+ * Each pattern type maps to a specific artifact: command, skill, hook, or workflow.
+ */
+/**
+ * Generate an automation proposal from a detected pattern.
+ */
+export function generateProposal(pattern) {
+    const name = generateName(pattern);
+    switch (pattern.suggestedArtifactType) {
+        case 'command':
+            return {
+                proposalType: pattern.patternType,
+                artifactType: 'command',
+                artifactPath: `.claude/commands/${name}.md`,
+                draftContent: generateCommandTemplate(name, pattern),
+                confidence: computeProposalConfidence(pattern),
+                status: 'pending',
+            };
+        case 'skill':
+            return {
+                proposalType: pattern.patternType,
+                artifactType: 'skill',
+                artifactPath: `.claude/skills/${name}/SKILL.md`,
+                draftContent: generateSkillTemplate(name, pattern),
+                confidence: computeProposalConfidence(pattern),
+                status: 'pending',
+            };
+        case 'workflow':
+            return {
+                proposalType: pattern.patternType,
+                artifactType: 'workflow',
+                artifactPath: `.github/workflows/auto-${name}.yml`,
+                draftContent: generateWorkflowTemplate(name, pattern),
+                confidence: computeProposalConfidence(pattern),
+                status: 'pending',
+            };
+        case 'hook':
+            return {
+                proposalType: pattern.patternType,
+                artifactType: 'hook',
+                artifactPath: `.claude/hooks/${name}.sh`,
+                draftContent: generateHookTemplate(name, pattern),
+                confidence: computeProposalConfidence(pattern),
+                status: 'pending',
+            };
+        default:
+            return {
+                proposalType: pattern.patternType,
+                artifactType: 'command',
+                artifactPath: `.claude/commands/${name}.md`,
+                draftContent: generateCommandTemplate(name, pattern),
+                confidence: computeProposalConfidence(pattern),
+                status: 'pending',
+            };
+    }
+}
+/**
+ * Generate a kebab-case name from the pattern's steps.
+ */
+export function generateName(pattern) {
+    // Take the most distinctive tool+action pairs
+    const parts = [];
+    for (const step of pattern.steps) {
+        const action = step.action
+            .replace(/[^a-zA-Z0-9\s]/g, '')
+            .trim()
+            .split(/\s+/)
+            .slice(0, 2)
+            .join('-')
+            .toLowerCase();
+        if (action && !parts.includes(action)) {
+            parts.push(action);
+        }
+        if (parts.length >= 3)
+            break;
+    }
+    const name = parts.length > 0 ? `auto-${parts.join('-')}` : `auto-pattern-${pattern.hash.slice(0, 8)}`;
+    return name.slice(0, 50);
+}
+function stepsToMarkdown(steps) {
+    return steps
+        .map((s, i) => {
+        const desc = s.action.includes(':') ? `${s.tool}: ${s.action}` : `Run \`${s.action}\``;
+        return `${i + 1}. ${desc}`;
+    })
+        .join('\n');
+}
+function generateCommandTemplate(name, pattern) {
+    return `---
+name: ${name}
+description: Auto-generated from detected workflow pattern (${pattern.patternType})
+argument-hint: [optional-args]
+---
+
+# ${name}
+
+> Auto-generated from pattern detection. Confidence: ${(pattern.confidence * 100).toFixed(0)}%
+> Observed ${pattern.frequency} times across ${pattern.sessionCount} sessions.
+
+## Steps
+
+${stepsToMarkdown(pattern.steps)}
+
+## Notes
+
+This command was auto-generated by the workflow pattern detection engine.
+Review and customize before using in production.
+`;
+}
+function generateSkillTemplate(name, pattern) {
+    return `---
+name: ${name}
+description: Auto-generated skill from detected ${pattern.patternType} pattern
+---
+
+# ${name}
+
+> Auto-generated from pattern detection. Confidence: ${(pattern.confidence * 100).toFixed(0)}%
+> Observed ${pattern.frequency} times across ${pattern.sessionCount} sessions.
+
+## Workflow
+
+${stepsToMarkdown(pattern.steps)}
+
+## Customization
+
+This skill was auto-generated. Modify the steps above to match your
+specific use case.
+`;
+}
+function generateWorkflowTemplate(name, pattern) {
+    const schedule = '0 9 * * 1'; // Default: Monday 9am
+    return `# Auto-generated workflow from pattern detection
+# Pattern: ${pattern.patternType}
+# Confidence: ${(pattern.confidence * 100).toFixed(0)}%
+# Observed ${pattern.frequency} times across ${pattern.sessionCount} sessions
+
+name: Auto ${name}
+
+on:
+  schedule:
+    - cron: '${schedule}'
+  workflow_dispatch:
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+${pattern.steps.map((s) => `      - name: ${s.tool} ${s.action}\n        run: echo "TODO: implement ${s.action}"`).join('\n')}
+`;
+}
+function generateHookTemplate(name, pattern) {
+    return `#!/bin/bash
+# Auto-generated hook from pattern detection
+# Pattern: ${pattern.patternType}
+# Confidence: ${(pattern.confidence * 100).toFixed(0)}%
+
+set -euo pipefail
+
+# TODO: Implement hook logic for pattern:
+${pattern.steps.map((s) => `# - ${s.tool}: ${s.action}`).join('\n')}
+
+exit 0
+`;
+}
+function computeProposalConfidence(pattern) {
+    // Base confidence from pattern detection
+    let confidence = pattern.confidence;
+    // Template fit: commands and skills have better template mapping
+    if (pattern.suggestedArtifactType === 'command' || pattern.suggestedArtifactType === 'skill') {
+        confidence *= 1.0; // Perfect fit
+    }
+    else if (pattern.suggestedArtifactType === 'workflow') {
+        confidence *= 0.8; // Periodic tasks need schedule tuning
+    }
+    else {
+        confidence *= 0.7; // Hooks need manual implementation
+    }
+    return Math.min(1.0, confidence);
+}
+//# sourceMappingURL=proposal-generator.js.map

package/dist/workflow-patterns/telemetry-ingest.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Telemetry ingestion — reads tool sequence JSONL and session-meta
+ * JSON files into ToolSequenceEvent format for pattern detection.
+ */
+import type { ToolSequenceEvent } from '../state/types.js';
+import type { SessionMeta, CanonicalStep } from './types.js';
+/**
+ * Read tool sequence entries from a JSONL file.
+ * Each line is a JSON object with ts, sid, tool, action, project.
+ */
+export declare function readToolSequenceJSONL(filePath: string): ToolSequenceEvent[];
+/**
+ * Read session metadata from the Claude Code usage-data directory.
+ * Returns metadata for all sessions found.
+ */
+export declare function readSessionMetaFiles(usageDataDir: string): SessionMeta[];
+/**
+ * Convert session-meta tool_counts into synthetic ToolSequenceEvents.
+ * Since session-meta only has aggregate counts (no ordering), these
+ * events are useful for frequency analysis but not sequence mining.
+ */
+export declare function sessionMetaToEvents(meta: SessionMeta): ToolSequenceEvent[];
+/**
+ * Categorize a tool action into a workflow category.
+ */
+export declare function categorizeAction(tool: string, action: string): CanonicalStep['category'];
+//# sourceMappingURL=telemetry-ingest.d.ts.map

package/dist/workflow-patterns/telemetry-ingest.js

@@ -0,0 +1,103 @@
+/**
+ * Telemetry ingestion — reads tool sequence JSONL and session-meta
+ * JSON files into ToolSequenceEvent format for pattern detection.
+ */
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Read tool sequence entries from a JSONL file.
+ * Each line is a JSON object with ts, sid, tool, action, project.
+ */
+export function readToolSequenceJSONL(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const content = readFileSync(filePath, 'utf-8');
+    const events = [];
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const raw = JSON.parse(trimmed);
+            events.push({
+                sessionId: raw.sid,
+                toolName: raw.tool,
+                actionCanonical: raw.action,
+                projectPath: raw.project,
+                timestamp: raw.ts,
+            });
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return events;
+}
+/**
+ * Read session metadata from the Claude Code usage-data directory.
+ * Returns metadata for all sessions found.
+ */
+export function readSessionMetaFiles(usageDataDir) {
+    const metaDir = join(usageDataDir, 'session-meta');
+    if (!existsSync(metaDir))
+        return [];
+    const files = readdirSync(metaDir).filter((f) => f.endsWith('.json'));
+    const sessions = [];
+    for (const file of files) {
+        try {
+            const content = readFileSync(join(metaDir, file), 'utf-8');
+            const meta = JSON.parse(content);
+            if (meta.session_id && meta.tool_counts) {
+                sessions.push(meta);
+            }
+        }
+        catch {
+            // Skip malformed files
+        }
+    }
+    return sessions;
+}
+/**
+ * Convert session-meta tool_counts into synthetic ToolSequenceEvents.
+ * Since session-meta only has aggregate counts (no ordering), these
+ * events are useful for frequency analysis but not sequence mining.
+ */
+export function sessionMetaToEvents(meta) {
+    const events = [];
+    const timestamp = meta.start_time;
+    for (const [tool, count] of Object.entries(meta.tool_counts)) {
+        for (let i = 0; i < count; i++) {
+            events.push({
+                sessionId: meta.session_id,
+                toolName: tool,
+                actionCanonical: tool.toLowerCase(),
+                projectPath: meta.project_path,
+                timestamp,
+            });
+        }
+    }
+    return events;
+}
+/**
+ * Categorize a tool action into a workflow category.
+ */
+export function categorizeAction(tool, action) {
+    const lower = action.toLowerCase();
+    if (tool === 'Read' || lower.startsWith('read:'))
+        return 'read';
+    if (tool === 'Edit' ||
+        tool === 'Write' ||
+        lower.startsWith('edit:') ||
+        lower.startsWith('write:'))
+        return 'write';
+    if (lower.includes('test') || lower.includes('vitest') || lower.includes('jest'))
+        return 'test';
+    if (lower.includes('build') || lower.includes('tsc') || lower.includes('compile'))
+        return 'build';
+    if (lower.startsWith('git ') || lower.startsWith('gh '))
+        return 'git';
+    if (tool === 'Grep' || tool === 'Glob' || lower.startsWith('grep:') || lower.startsWith('glob:'))
+        return 'search';
+    return 'other';
+}
+//# sourceMappingURL=telemetry-ingest.js.map

package/dist/workflow-patterns/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Types for the workflow pattern detection system.
+ */
+export interface CanonicalStep {
+    tool: string;
+    action: string;
+    /** Category for grouping: read, write, test, build, git, search, other */
+    category: 'read' | 'write' | 'test' | 'build' | 'git' | 'search' | 'other';
+}
+export interface NGram {
+    steps: CanonicalStep[];
+    hash: string;
+    sessionId: string;
+}
+export interface DetectedPattern {
+    hash: string;
+    steps: CanonicalStep[];
+    frequency: number;
+    sessionCount: number;
+    confidence: number;
+    patternType: 'command-sequence' | 'copy-paste-cycle' | 'periodic-task';
+    suggestedArtifactType: 'command' | 'skill' | 'hook' | 'workflow';
+    firstSeen: string;
+    lastSeen: string;
+    exampleSessionIds: string[];
+}
+export interface DetectionOptions {
+    minSequenceLength: number;
+    maxSequenceLength: number;
+    minFrequency: number;
+    minSessionCount: number;
+    minConfidence: number;
+    projectFilter?: string;
+    since?: string;
+}
+export declare const DEFAULT_DETECTION_OPTIONS: DetectionOptions;
+/** Raw tool sequence entry from the JSONL file. */
+export interface RawToolSequenceEntry {
+    ts: string;
+    sid: string;
+    tool: string;
+    action: string;
+    project: string;
+}
+/** Session metadata from Claude Code usage data. */
+export interface SessionMeta {
+    session_id: string;
+    project_path: string;
+    start_time: string;
+    duration_minutes: number;
+    user_message_count: number;
+    assistant_message_count: number;
+    tool_counts: Record<string, number>;
+    git_commits: number;
+    git_pushes: number;
+    first_prompt: string;
+    tool_errors: number;
+    lines_added: number;
+    files_modified: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/workflow-patterns/types.js

@@ -0,0 +1,11 @@
+/**
+ * Types for the workflow pattern detection system.
+ */
+export const DEFAULT_DETECTION_OPTIONS = {
+    minSequenceLength: 3,
+    maxSequenceLength: 8,
+    minFrequency: 3,
+    minSessionCount: 3,
+    minConfidence: 0.6,
+};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdlc/orchestrator",
-  "version": "0.5.0",
+  "version": "0.9.0",
   "description": "AI-SDLC Orchestrator — long-running runtime that drives issues through the complete SDLC with AI agents",
   "license": "Apache-2.0",
   "repository": {
@@ -45,7 +45,7 @@
     "better-sqlite3": "^11.0.0",
     "commander": "^12.0.0",
     "yaml": "^2.7.0",
-    "@ai-sdlc/reference": "0.5.0"
+    "@ai-sdlc/reference": "0.9.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.0",