atlasia-ghost 1.0.2 → 1.1.1

package/AGENTS.md

@@ -40,9 +40,15 @@
 New commands and SDK for building extensions:
 
 **CLI Commands:**
-- `ghost extension init <name>` - Scaffold new extension with boilerplate
+- `ghost extension init` - Interactive template wizard with gallery
 - `ghost extension validate [path]` - Validate manifest and permissions
 
+**Template Gallery:** `core/templates/` - Production-ready templates:
+- **API Integration** - REST/GraphQL client with auth (Bearer, API Key, OAuth)
+- **File Processor** - Batch operations with progress tracking and transformations
+- **Git Workflow** - Commit hooks with validation (pre-commit, commit-msg, conventional commits)
+- **Testing** - Vitest/Jest setup with mocking, coverage, and E2E support
+
 **SDK Package:** `packages/extension-sdk/` - @ghost/extension-sdk NPM package with:
 - `ExtensionSDK` class - High-level API (requestFileRead, requestNetworkCall, requestGitExec)
 - `IntentBuilder` - Build JSON-RPC intents
@@ -54,3 +60,4 @@ New commands and SDK for building extensions:
 - `extension-examples.md` - Working examples (file processor, API integration, git helper)
 - `DEVELOPER_TOOLKIT.md` - Complete toolkit guide
 - `QUICK_REFERENCE.md` - Quick reference card
+- `TEMPLATE_GALLERY.md` - Template gallery guide

package/README.md

@@ -91,6 +91,7 @@ Ghost includes a complete toolkit for building custom extensions:
 
 - **`ghost extension init <name>`** - Scaffold a new extension project with boilerplate
 - **`ghost extension validate [path]`** - Validate manifest syntax and simulate permissions
+- **`ghost extension migrate [path]`** - Migrate v0.x extensions to v1.0.0 SDK
 - **`ghost extension install <path>`** - Install extension locally
 - **`ghost extension list`** - List installed extensions
 - **`ghost extension info <id>`** - Show extension details
@@ -133,6 +134,7 @@ module.exports = MyExtension;
 ### Documentation
 
 - 🛠️ [Developer Toolkit Guide](./docs/DEVELOPER_TOOLKIT.md) - Complete guide to extension development
+- 🔄 [Extension Migration Guide](./docs/EXTENSION_MIGRATION.md) - Migrate v0.x to v1.0.0
 - 📖 [Extension API Reference](./docs/extension-api.md) - I/O intent schema and examples
 - 💡 [Extension Examples](./docs/extension-examples.md) - Working examples for common patterns
 - 📦 [Extension SDK Package](./packages/extension-sdk/README.md) - SDK documentation
@@ -297,6 +299,37 @@ ghost version bump --from-commits --tag --output json
 
 ### Creating Extensions
 
+#### 🎨 Quick Start with Template Gallery
+
+Ghost CLI includes a comprehensive template gallery with pre-built patterns:
+
+```bash
+# Interactive template selector
+ghost extension init
+
+# Or use specific template
+ghost extension init my-api --template api-integration
+```
+
+**Available Templates:**
+- `api-integration` - REST/GraphQL client with auth, retry, caching
+- `file-processor` - Batch file operations with streaming
+- `git-workflow` - Git hooks and conventional commits
+- `testing` - Test infrastructure with mock RPC client
+- `basic` - Simple minimal structure
+- `typescript` - Type-safe development
+- `advanced` - Production-ready with tests
+
+Each template includes:
+- ✅ Fully-implemented, commented code
+- ✅ Complete test suite
+- ✅ Comprehensive README with examples
+- ✅ Best practices built-in
+
+[📚 View Template Gallery →](./templates/README.md)
+
+#### Manual Extension Creation
+
 1. Create extension directory structure:
 ```
 my-extension/

package/core/analytics/api-server.js

@@ -0,0 +1,253 @@
+const http = require('http');
+const { AnalyticsPlatform } = require('./index');
+
+class AnalyticsAPIServer {
+    constructor(options = {}) {
+        this.options = {
+            port: options.port || 9876,
+            host: options.host || 'localhost',
+            ...options
+        };
+
+        this.analytics = new AnalyticsPlatform(options.analytics || {});
+        this.server = null;
+    }
+
+    async start() {
+        await this.analytics.initialize();
+
+        this.server = http.createServer((req, res) => {
+            this._handleRequest(req, res);
+        });
+
+        return new Promise((resolve, reject) => {
+            this.server.listen(this.options.port, this.options.host, (err) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    console.log(`[AnalyticsAPI] Server listening on http://${this.options.host}:${this.options.port}`);
+                    resolve();
+                }
+            });
+        });
+    }
+
+    async stop() {
+        await this.analytics.shutdown();
+        
+        if (this.server) {
+            return new Promise((resolve) => {
+                this.server.close(() => {
+                    console.log('[AnalyticsAPI] Server stopped');
+                    resolve();
+                });
+            });
+        }
+    }
+
+    async _handleRequest(req, res) {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        res.setHeader('Content-Type', 'application/json');
+
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+
+        try {
+            if (url.pathname === '/api/analytics/dashboard') {
+                await this._handleDashboard(req, res, url);
+            } else if (url.pathname.startsWith('/api/analytics/performance/')) {
+                await this._handlePerformanceHistory(req, res, url);
+            } else if (url.pathname === '/api/analytics/extensions') {
+                await this._handleExtensionsList(req, res);
+            } else if (url.pathname.startsWith('/api/analytics/extension/')) {
+                await this._handleExtensionDetail(req, res, url);
+            } else {
+                res.writeHead(404);
+                res.end(JSON.stringify({ error: 'Not found' }));
+            }
+        } catch (error) {
+            console.error('[AnalyticsAPI] Error handling request:', error);
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: error.message }));
+        }
+    }
+
+    async _handleDashboard(req, res, url) {
+        const timeRange = url.searchParams.get('timeRange') || '6h';
+        
+        const allMetrics = this.analytics.collector.getAllMetrics();
+        const costs = [];
+        const alerts = this.analytics.performance.getAlerts();
+        
+        for (const [extensionId, metrics] of Object.entries(allMetrics)) {
+            const costData = this.analytics.cost.getCostsByExtension(extensionId);
+            if (costData) {
+                costs.push({
+                    extensionId,
+                    totalCost: costData.total || 0,
+                    resources: costData.breakdown || {
+                        cpu: 0,
+                        memory: 0,
+                        io: 0,
+                        network: 0,
+                        storage: 0
+                    },
+                    billingPeriod: costData.period || 'current'
+                });
+            }
+        }
+
+        const crossExtensionCalls = this.analytics.tracing.getCrossExtensionCalls();
+        const extensionInteractions = this.analytics.tracing.getExtensionInteractions();
+        
+        const callGraph = {
+            nodes: [],
+            edges: []
+        };
+
+        if (crossExtensionCalls && crossExtensionCalls.length > 0) {
+            const nodeMap = new Map();
+            
+            crossExtensionCalls.forEach(call => {
+                const fromKey = `${call.from.extensionId}:${call.from.operation}`;
+                const toKey = `${call.to.extensionId}:${call.to.operation}`;
+                
+                if (!nodeMap.has(fromKey)) {
+                    nodeMap.set(fromKey, {
+                        extensionId: call.from.extensionId,
+                        operation: call.from.operation,
+                        callCount: 0,
+                        totalDuration: 0,
+                        avgDuration: 0
+                    });
+                }
+                
+                if (!nodeMap.has(toKey)) {
+                    nodeMap.set(toKey, {
+                        extensionId: call.to.extensionId,
+                        operation: call.to.operation,
+                        callCount: 0,
+                        totalDuration: 0,
+                        avgDuration: 0
+                    });
+                }
+                
+                const fromNode = nodeMap.get(fromKey);
+                const toNode = nodeMap.get(toKey);
+                
+                fromNode.callCount += call.count;
+                toNode.callCount += call.count;
+                fromNode.totalDuration += call.totalDuration || 0;
+                toNode.totalDuration += call.totalDuration || 0;
+                
+                callGraph.edges.push({
+                    from: fromKey,
+                    to: toKey,
+                    callCount: call.count
+                });
+            });
+            
+            nodeMap.forEach((node, key) => {
+                node.avgDuration = node.callCount > 0 ? node.totalDuration / node.callCount : 0;
+                callGraph.nodes.push(node);
+            });
+        }
+
+        const formattedAlerts = alerts.map(alert => ({
+            id: alert.id || `alert-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            extensionId: alert.extensionId,
+            version: alert.version || '1.0.0',
+            severity: alert.severity || 'medium',
+            metric: alert.metric,
+            baselineValue: alert.baselineValue,
+            currentValue: alert.currentValue,
+            percentChange: alert.percentChange,
+            threshold: alert.threshold,
+            timestamp: alert.timestamp || Date.now()
+        }));
+
+        const dashboardData = {
+            metrics: allMetrics,
+            costs,
+            alerts: formattedAlerts,
+            callGraph,
+            timestamp: Date.now()
+        };
+
+        res.writeHead(200);
+        res.end(JSON.stringify(dashboardData));
+    }
+
+    async _handlePerformanceHistory(req, res, url) {
+        const extensionId = url.pathname.split('/').pop();
+        const timeRange = url.searchParams.get('timeRange') || '6h';
+        
+        const history = [];
+        const now = Date.now();
+        const timeRangeMs = this._parseTimeRange(timeRange);
+        
+        const invocations = Array.from(this.analytics.collector.metrics.values())
+            .filter(m => m.extensionId === extensionId && m.timestamp > (now - timeRangeMs))
+            .sort((a, b) => a.timestamp - b.timestamp);
+
+        const bucketSize = Math.max(1, Math.floor(invocations.length / 50));
+        
+        for (let i = 0; i < invocations.length; i += bucketSize) {
+            const bucket = invocations.slice(i, i + bucketSize);
+            const durations = bucket
+                .filter(inv => inv.duration !== undefined)
+                .map(inv => inv.duration)
+                .sort((a, b) => a - b);
+            
+            if (durations.length > 0) {
+                history.push({
+                    timestamp: bucket[0].timestamp,
+                    p50: durations[Math.floor(durations.length * 0.5)] || 0,
+                    p95: durations[Math.floor(durations.length * 0.95)] || 0,
+                    p99: durations[Math.floor(durations.length * 0.99)] || 0
+                });
+            }
+        }
+
+        res.writeHead(200);
+        res.end(JSON.stringify({ history }));
+    }
+
+    async _handleExtensionsList(req, res) {
+        const allMetrics = this.analytics.collector.getAllMetrics();
+        const extensions = Object.keys(allMetrics).map(extensionId => ({
+            id: extensionId,
+            metrics: allMetrics[extensionId]
+        }));
+
+        res.writeHead(200);
+        res.end(JSON.stringify({ extensions }));
+    }
+
+    async _handleExtensionDetail(req, res, url) {
+        const extensionId = url.pathname.split('/').pop();
+        const metrics = this.analytics.getExtensionMetrics(extensionId);
+
+        res.writeHead(200);
+        res.end(JSON.stringify(metrics));
+    }
+
+    _parseTimeRange(timeRange) {
+        const ranges = {
+            '1h': 60 * 60 * 1000,
+            '6h': 6 * 60 * 60 * 1000,
+            '24h': 24 * 60 * 60 * 1000,
+            '7d': 7 * 24 * 60 * 60 * 1000
+        };
+        return ranges[timeRange] || ranges['6h'];
+    }
+}
+
+module.exports = AnalyticsAPIServer;

package/core/analytics/examples/populate-sample-data.js

@@ -0,0 +1,103 @@
+const { AnalyticsPlatform } = require('../index');
+const path = require('path');
+const os = require('os');
+
+async function populateSampleData() {
+    const analytics = new AnalyticsPlatform({
+        persistenceDir: path.join(os.homedir(), '.ghost', 'analytics'),
+        flushInterval: 60000,
+        retentionDays: 30
+    });
+
+    await analytics.initialize();
+
+    console.log('[Sample Data] Generating analytics data...');
+
+    const extensions = [
+        'ghost-git-extension',
+        'ghost-npm-extension',
+        'ghost-docker-extension',
+        'ghost-lint-extension'
+    ];
+
+    const operations = {
+        'ghost-git-extension': ['status', 'commit', 'push', 'pull', 'branch'],
+        'ghost-npm-extension': ['install', 'test', 'build', 'publish'],
+        'ghost-docker-extension': ['build', 'run', 'ps', 'logs'],
+        'ghost-lint-extension': ['check', 'fix', 'format']
+    };
+
+    for (let i = 0; i < 200; i++) {
+        const extensionId = extensions[Math.floor(Math.random() * extensions.length)];
+        const method = operations[extensionId][Math.floor(Math.random() * operations[extensionId].length)];
+        
+        const context = analytics.trackExtensionInvocation(extensionId, method, {
+            param1: 'value1',
+            param2: 'value2'
+        });
+
+        await new Promise(resolve => setTimeout(resolve, Math.random() * 50 + 10));
+
+        const duration = Math.random() * 200 + 10;
+        const success = Math.random() > 0.15;
+
+        analytics.trackResourceUsage(context, {
+            cpu: Math.random() * 5,
+            memory: Math.random() * 100 + 20,
+            io: Math.random() * 1024 * 10,
+            network: Math.random() * 1024 * 5
+        });
+
+        if (success) {
+            analytics.trackExtensionSuccess(context, { status: 'ok', data: {} });
+        } else {
+            analytics.trackExtensionFailure(context, new Error('Sample error'));
+        }
+
+        analytics.trackVersionMetric(extensionId, '1.0.0', {
+            duration,
+            cpu: Math.random() * 5,
+            memory: Math.random() * 100,
+            errorRate: success ? 0 : 1
+        });
+
+        if (Math.random() > 0.7) {
+            const targetExtension = extensions[Math.floor(Math.random() * extensions.length)];
+            if (targetExtension !== extensionId) {
+                const childSpanId = analytics.trackCrossExtensionCall(
+                    context.spanId,
+                    targetExtension,
+                    'delegate',
+                    {}
+                );
+                
+                await new Promise(resolve => setTimeout(resolve, Math.random() * 30));
+                
+                analytics.tracing.endSpan(childSpanId, 'success', {});
+            }
+        }
+
+        if (i % 10 === 0) {
+            console.log(`[Sample Data] Generated ${i} invocations...`);
+        }
+    }
+
+    for (const extensionId of extensions) {
+        analytics.performance.setBaseline(extensionId, '1.0.0');
+        
+        analytics.trackVersionMetric(extensionId, '1.1.0', {
+            duration: Math.random() * 300 + 50,
+            cpu: Math.random() * 8,
+            memory: Math.random() * 150,
+            errorRate: 0.2
+        });
+    }
+
+    await analytics.persist();
+    console.log('[Sample Data] Sample data generated successfully!');
+    console.log('[Sample Data] Start the API server with: node core/analytics/start-api-server.js');
+
+    await analytics.shutdown();
+}
+
+populateSampleData().catch(console.error);

package/core/analytics/index.js

@@ -4,6 +4,7 @@ const CostAttribution = require('./cost-attribution');
 const PerformanceRegression = require('./performance-regression');
 const DistributedTracing = require('./distributed-tracing');
 const RecommendationEngine = require('./recommendation-engine');
+const TelemetryWebSocketServer = require('./telemetry-ws-server');
 const { EventEmitter } = require('events');
 
 class AnalyticsPlatform extends EventEmitter {
@@ -17,6 +18,14 @@ class AnalyticsPlatform extends EventEmitter {
         this.performance = new PerformanceRegression(options);
         this.tracing = new DistributedTracing(options);
         this.recommendations = new RecommendationEngine(options);
+        
+        this.wsServer = null;
+        if (options.enableWebSocket !== false) {
+            this.wsServer = new TelemetryWebSocketServer({
+                port: options.wsPort || 9877,
+                host: options.wsHost || 'localhost'
+            });
+        }
 
         this._setupEventForwarding();
     }
@@ -28,6 +37,14 @@ class AnalyticsPlatform extends EventEmitter {
         await this.tracing.load();
         await this.recommendations.load();
 
+        if (this.wsServer) {
+            try {
+                await this.wsServer.start();
+            } catch (error) {
+                console.error('[AnalyticsPlatform] Failed to start WebSocket server:', error.message);
+            }
+        }
+
         this.emit('initialized');
     }
 
@@ -51,6 +68,17 @@ class AnalyticsPlatform extends EventEmitter {
         
         this.collector.recordSuccess(trackingContext.invocationId, result, duration);
         this.tracing.endSpan(trackingContext.spanId, 'success', { resultSize: JSON.stringify(result).length });
+        
+        if (this.wsServer) {
+            this.wsServer.broadcastToExtension(trackingContext.extensionId || this._getExtensionIdFromInvocation(trackingContext.invocationId), {
+                type: 'invocation-completed',
+                extensionId: trackingContext.extensionId || this._getExtensionIdFromInvocation(trackingContext.invocationId),
+                invocationId: trackingContext.invocationId,
+                status: 'success',
+                duration,
+                timestamp: Date.now()
+            });
+        }
     }
 
     trackExtensionFailure(trackingContext, error) {
@@ -58,6 +86,18 @@ class AnalyticsPlatform extends EventEmitter {
         
         this.collector.recordFailure(trackingContext.invocationId, error, duration);
         this.tracing.endSpan(trackingContext.spanId, 'error', { error: error.message });
+        
+        if (this.wsServer) {
+            this.wsServer.broadcastToExtension(trackingContext.extensionId || this._getExtensionIdFromInvocation(trackingContext.invocationId), {
+                type: 'invocation-completed',
+                extensionId: trackingContext.extensionId || this._getExtensionIdFromInvocation(trackingContext.invocationId),
+                invocationId: trackingContext.invocationId,
+                status: 'failure',
+                duration,
+                error: error.message,
+                timestamp: Date.now()
+            });
+        }
     }
 
     trackResourceUsage(trackingContext, resources) {
@@ -169,6 +209,15 @@ class AnalyticsPlatform extends EventEmitter {
     async shutdown() {
         await this.persist();
         this.collector.shutdown();
+        
+        if (this.wsServer) {
+            try {
+                await this.wsServer.stop();
+            } catch (error) {
+                console.error('[AnalyticsPlatform] Failed to stop WebSocket server:', error.message);
+            }
+        }
+        
         this.emit('shutdown');
     }
 
@@ -204,6 +253,8 @@ class AnalyticsPlatform extends EventEmitter {
     }
 }
 
+const AnalyticsAPIServer = require('./api-server');
+
 module.exports = {
     AnalyticsPlatform,
     AnalyticsCollector,
@@ -211,5 +262,7 @@ module.exports = {
     CostAttribution,
     PerformanceRegression,
     DistributedTracing,
-    RecommendationEngine
+    RecommendationEngine,
+    AnalyticsAPIServer,
+    TelemetryWebSocketServer
 };

package/core/analytics/start-api-server.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+const { AnalyticsAPIServer } = require('./index');
+const path = require('path');
+const os = require('os');
+
+const server = new AnalyticsAPIServer({
+    port: 9876,
+    host: 'localhost',
+    analytics: {
+        persistenceDir: path.join(os.homedir(), '.ghost', 'analytics'),
+        flushInterval: 60000,
+        retentionDays: 30
+    }
+});
+
+async function main() {
+    try {
+        await server.start();
+        console.log('[Analytics] API Server started successfully');
+        console.log('[Analytics] Access dashboard at: http://localhost:9876/api/analytics/dashboard');
+    } catch (error) {
+        console.error('[Analytics] Failed to start API server:', error);
+        process.exit(1);
+    }
+}
+
+process.on('SIGINT', async () => {
+    console.log('\n[Analytics] Shutting down...');
+    await server.stop();
+    process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+    console.log('\n[Analytics] Shutting down...');
+    await server.stop();
+    process.exit(0);
+});
+
+main();

package/core/analytics/start-telemetry-server.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+const { AnalyticsPlatform } = require('./index');
+const path = require('path');
+const os = require('os');
+
+const analytics = new AnalyticsPlatform({
+    persistenceDir: path.join(os.homedir(), '.ghost', 'analytics'),
+    enableWebSocket: true,
+    wsPort: 9877,
+    wsHost: 'localhost'
+});
+
+async function startServer() {
+    try {
+        await analytics.initialize();
+        console.log('[TelemetryServer] Analytics Platform initialized');
+        console.log('[TelemetryServer] WebSocket server running on ws://localhost:9877/telemetry');
+        console.log('[TelemetryServer] Press Ctrl+C to stop');
+
+        analytics.on('invocation-started', (event) => {
+            console.log(`[Invocation] Started: ${event.extensionId} - ${event.method}`);
+        });
+
+        analytics.on('invocation-completed', (event) => {
+            console.log(`[Invocation] Completed: ${event.extensionId} - ${event.status} (${event.duration}ms)`);
+        });
+
+        analytics.on('regression-detected', (alert) => {
+            console.log(`[Alert] Regression detected: ${alert.extensionId} - ${alert.severity}`);
+        });
+    } catch (error) {
+        console.error('[TelemetryServer] Failed to start:', error.message);
+        process.exit(1);
+    }
+}
+
+process.on('SIGINT', async () => {
+    console.log('\n[TelemetryServer] Shutting down...');
+    await analytics.shutdown();
+    process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+    console.log('\n[TelemetryServer] Shutting down...');
+    await analytics.shutdown();
+    process.exit(0);
+});
+
+startServer();