profclaw 0.0.1-beta.1

package/dist/routes/summaries.js

@@ -0,0 +1,344 @@
+import { Hono } from 'hono';
+import { createSummary, getSummary, querySummaries, searchSummaries, getSummaryStats, getRecentSummaries, deleteSummary, CreateSummaryInputSchema, SummaryQuerySchema, } from '../summaries/index.js';
+import { generatePRDescription, generateChangelog, generateReleaseNotes, generateCommitMessage, TASK_TYPE_TEMPLATES, } from '../summaries/templates.js';
+import { getEmbeddingService } from '../ai/embedding-service.js';
+import { getStorage } from '../storage/index.js';
+import { logger as systemLogger } from '../utils/logger.js';
+const summaries = new Hono();
+// Sparse fieldset: default fields for list view (Phase 17 optimization)
+const SUMMARY_LIST_FIELDS = [
+    'id', 'taskId', 'sessionId', 'agent', 'model', 'title', 'taskType', 'component',
+    'labels', 'repository', 'branch', 'createdAt', 'hasBlobOutput',
+];
+// Helper to pick only specified fields from an object
+function pickSummaryFields(obj, fields) {
+    const result = {};
+    for (const field of fields) {
+        if (field in obj) {
+            result[field] = obj[field];
+        }
+    }
+    return result;
+}
+function encodeCursor(data) {
+    return Buffer.from(JSON.stringify(data)).toString('base64url');
+}
+function decodeCursor(cursor) {
+    try {
+        const json = Buffer.from(cursor, 'base64url').toString('utf-8');
+        const data = JSON.parse(json);
+        if (typeof data.createdAt === 'number' && typeof data.id === 'string') {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function getNextCursor(items, limit) {
+    if (items.length < limit)
+        return null;
+    const lastItem = items[items.length - 1];
+    if (!lastItem?.createdAt)
+        return null;
+    const createdAt = lastItem.createdAt instanceof Date
+        ? lastItem.createdAt.getTime()
+        : typeof lastItem.createdAt === 'string'
+            ? new Date(lastItem.createdAt).getTime()
+            : lastItem.createdAt;
+    return encodeCursor({ createdAt, id: lastItem.id });
+}
+// Get summary statistics (before :id route to avoid conflict)
+summaries.get('/stats', async (c) => {
+    const stats = await getSummaryStats();
+    return c.json(stats);
+});
+// Get recent summaries (before :id route to avoid conflict)
+summaries.get('/recent', async (c) => {
+    const limit = parseInt(c.req.query('limit') || '50');
+    const summaryList = await getRecentSummaries(limit);
+    return c.json({
+        summaries: summaryList,
+        count: summaryList.length,
+    });
+});
+// Search summaries (before :id route to avoid conflict)
+summaries.get('/search', async (c) => {
+    const q = c.req.query('q');
+    const limit = parseInt(c.req.query('limit') || '20');
+    if (!q) {
+        return c.json({ error: 'Query parameter "q" is required' }, 400);
+    }
+    const summaryList = await searchSummaries(q, limit);
+    return c.json({
+        query: q,
+        summaries: summaryList,
+        count: summaryList.length,
+    });
+});
+// Semantic Search
+summaries.get('/semantic', async (c) => {
+    const query = c.req.query('q');
+    const type = c.req.query('type') || 'summary';
+    const limit = parseInt(c.req.query('limit') || '5');
+    if (!query)
+        return c.json({ error: 'Missing query' }, 400);
+    try {
+        const storage = getStorage();
+        if (!storage.searchSimilar) {
+            return c.json({ error: 'Semantic search not supported by current storage tier' }, 501);
+        }
+        let vector;
+        const vectorStr = c.req.query('vector');
+        if (vectorStr) {
+            vector = JSON.parse(vectorStr);
+        }
+        else {
+            const service = getEmbeddingService();
+            vector = await service.generateEmbedding(query);
+        }
+        const results = await storage.searchSimilar(type, vector, limit);
+        const enriched = await Promise.all(results.map(async (r) => ({
+            ...r,
+            summary: type === 'summary' ? await getSummary(r.entityId) : null
+        })));
+        return c.json({
+            query,
+            results: enriched
+        });
+    }
+    catch (error) {
+        systemLogger.error('[API] Semantic search error:', error);
+        return c.json({ error: 'Search failed', message: error.message }, 500);
+    }
+});
+// Generate Changelog
+summaries.get('/changelog', async (c) => {
+    const limit = parseInt(c.req.query('limit') || '50');
+    const version = c.req.query('version');
+    const format = (c.req.query('format') || 'keepachangelog');
+    const date = c.req.query('date');
+    const summaryList = await getRecentSummaries(limit);
+    const changelog = generateChangelog(summaryList, {
+        version,
+        date,
+        format,
+        includeIssueLinks: true,
+    });
+    return c.json({
+        version: version || 'Unreleased',
+        format,
+        count: summaryList.length,
+        changelog,
+    });
+});
+// Generate Release Notes
+summaries.get('/release-notes', async (c) => {
+    const limit = parseInt(c.req.query('limit') || '50');
+    const version = c.req.query('version') || '1.0.0';
+    const title = c.req.query('title');
+    const summaryList = await getRecentSummaries(limit);
+    const notes = generateReleaseNotes(summaryList, {
+        version,
+        title,
+        includeStats: true,
+    });
+    return c.json({
+        version,
+        count: summaryList.length,
+        notes,
+    });
+});
+// Get task type templates
+summaries.get('/templates', async (c) => {
+    return c.json({
+        templates: TASK_TYPE_TEMPLATES,
+        categories: ['Added', 'Changed', 'Fixed', 'Removed', 'Security', 'Deprecated'],
+    });
+});
+// List/query summaries
+summaries.get('/', async (c) => {
+    const queryParams = {};
+    const taskId = c.req.query('taskId');
+    const sessionId = c.req.query('sessionId');
+    const agent = c.req.query('agent');
+    const taskType = c.req.query('taskType');
+    const component = c.req.query('component');
+    const repository = c.req.query('repository');
+    const from = c.req.query('from');
+    const to = c.req.query('to');
+    const search = c.req.query('search');
+    const sortBy = c.req.query('sortBy');
+    const sortOrder = c.req.query('sortOrder');
+    const limit = c.req.query('limit');
+    const offset = c.req.query('offset');
+    // Cursor-based pagination (Phase 17) - takes precedence over offset
+    const cursor = c.req.query('cursor');
+    const cursorData = cursor ? decodeCursor(cursor) : null;
+    // Sparse fieldset support (Phase 17)
+    const fieldsParam = c.req.query('fields'); // Comma-separated field names
+    const sparseFields = fieldsParam ? fieldsParam.split(',').map(f => f.trim()) : null;
+    const includeFull = c.req.query('full') === 'true'; // Backward compat: return full objects
+    if (taskId)
+        queryParams.taskId = taskId;
+    if (sessionId)
+        queryParams.sessionId = sessionId;
+    if (agent)
+        queryParams.agent = agent;
+    if (taskType)
+        queryParams.taskType = taskType;
+    if (component)
+        queryParams.component = component;
+    if (repository)
+        queryParams.repository = repository;
+    if (from)
+        queryParams.from = from;
+    if (to)
+        queryParams.to = to;
+    if (search)
+        queryParams.search = search;
+    if (sortBy)
+        queryParams.sortBy = sortBy;
+    if (sortOrder)
+        queryParams.sortOrder = sortOrder;
+    const pageLimit = limit ? parseInt(limit) : 50;
+    queryParams.limit = pageLimit;
+    // Use cursor for pagination if provided, otherwise fall back to offset
+    if (cursorData) {
+        queryParams.cursorCreatedAt = new Date(cursorData.createdAt);
+        queryParams.cursorId = cursorData.id;
+    }
+    else if (offset) {
+        queryParams.offset = parseInt(offset);
+    }
+    const parsed = SummaryQuerySchema.partial().safeParse(queryParams);
+    if (!parsed.success) {
+        return c.json({
+            error: 'Invalid query parameters',
+            details: parsed.error.flatten(),
+        }, 400);
+    }
+    const result = await querySummaries(parsed.data);
+    // Generate next cursor from full results (before sparse filtering)
+    const nextCursor = getNextCursor(result.summaries, pageLimit);
+    // Apply sparse fieldset - strip rawOutput and large fields by default
+    const summaryList = !includeFull
+        ? result.summaries.map(s => pickSummaryFields(s, sparseFields || [...SUMMARY_LIST_FIELDS]))
+        : result.summaries;
+    return c.json({
+        summaries: summaryList,
+        total: result.total,
+        limit: pageLimit,
+        nextCursor,
+        offset: cursorData ? undefined : (queryParams.offset || 0),
+        sparse: !includeFull,
+    });
+});
+// Create summary
+summaries.post('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        const parsed = CreateSummaryInputSchema.safeParse(body);
+        if (!parsed.success) {
+            return c.json({
+                error: 'Validation failed',
+                details: parsed.error.flatten(),
+            }, 400);
+        }
+        const summary = await createSummary(parsed.data);
+        return c.json({
+            message: 'Summary created',
+            summary,
+        }, 201);
+    }
+    catch (error) {
+        console.error('[API] Error creating summary:', error);
+        return c.json({
+            error: 'Failed to create summary',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+// Generate PR Description
+summaries.get('/:id/pr-description', async (c) => {
+    const id = c.req.param('id');
+    const summary = await getSummary(id);
+    if (!summary) {
+        return c.json({ error: 'Summary not found' }, 404);
+    }
+    const includeFileChanges = c.req.query('includeFiles') !== 'false';
+    const includeDecisions = c.req.query('includeDecisions') !== 'false';
+    const includeBlockers = c.req.query('includeBlockers') !== 'false';
+    const includeTokenStats = c.req.query('includeTokens') === 'true';
+    const description = generatePRDescription(summary, {
+        includeFileChanges,
+        includeDecisions,
+        includeBlockers,
+        includeTokenStats,
+    });
+    return c.json({
+        id: summary.id,
+        title: summary.title,
+        description,
+    });
+});
+// Generate Commit Message
+summaries.get('/:id/commit-message', async (c) => {
+    const id = c.req.param('id');
+    const summary = await getSummary(id);
+    if (!summary) {
+        return c.json({ error: 'Summary not found' }, 404);
+    }
+    const includeBody = c.req.query('includeBody') === 'true';
+    const maxLength = parseInt(c.req.query('maxLength') || '72');
+    const message = generateCommitMessage(summary, {
+        maxLength,
+        includeBody,
+    });
+    return c.json({
+        id: summary.id,
+        message,
+    });
+});
+// Get single summary
+summaries.get('/:id', async (c) => {
+    const id = c.req.param('id');
+    const includeRawOutput = c.req.query('includeRawOutput') === 'true';
+    const summary = await getSummary(id, includeRawOutput);
+    if (!summary) {
+        return c.json({ error: 'Summary not found' }, 404);
+    }
+    return c.json({ summary });
+});
+// Get raw output for a summary (lazy loading - Phase 17)
+summaries.get('/:id/raw-output', async (c) => {
+    const id = c.req.param('id');
+    const storage = getStorage();
+    // Check summary exists
+    const summary = await getSummary(id);
+    if (!summary) {
+        return c.json({ error: 'Summary not found' }, 404);
+    }
+    // Fetch raw output from blob storage
+    const rawOutput = await storage.getSummaryRawOutput(id);
+    if (!rawOutput) {
+        return c.json({ error: 'Raw output not available', hasBlob: false }, 404);
+    }
+    return c.json({
+        id,
+        rawOutput,
+        length: rawOutput.length,
+    });
+});
+// Delete summary
+summaries.delete('/:id', async (c) => {
+    const id = c.req.param('id');
+    const deleted = await deleteSummary(id);
+    if (!deleted) {
+        return c.json({ error: 'Summary not found' }, 404);
+    }
+    return c.json({ message: 'Summary deleted' });
+});
+export { summaries as summariesRoutes };
+//# sourceMappingURL=summaries.js.map

package/dist/routes/sync.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Sync Routes
+ *
+ * Webhook endpoints for external platform sync:
+ * - POST /api/sync/webhook/linear
+ * - POST /api/sync/webhook/github
+ * - GET /api/sync/status
+ * - POST /api/sync/trigger
+ */
+import { Hono } from 'hono';
+declare const syncRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default syncRoutes;
+//# sourceMappingURL=sync.d.ts.map

package/dist/routes/sync.js

@@ -0,0 +1,268 @@
+/**
+ * Sync Routes
+ *
+ * Webhook endpoints for external platform sync:
+ * - POST /api/sync/webhook/linear
+ * - POST /api/sync/webhook/github
+ * - GET /api/sync/status
+ * - POST /api/sync/trigger
+ */
+import { Hono } from 'hono';
+import { handleSyncWebhook, pushTicketToExternal, getSyncStatus } from '../sync/integration.js';
+import { hasSyncEngine, getSyncEngine } from '../sync/engine.js';
+import { loadSyncConfig } from '../sync/config.js';
+import { processGitHubWebhookForTicketSync } from '../integrations/github-ticket-sync.js';
+import crypto from 'crypto';
+const syncRoutes = new Hono();
+async function parseJsonBody(c) {
+    try {
+        const body = await c.req.json();
+        if (!body || typeof body !== 'object' || Array.isArray(body)) {
+            return {
+                ok: false,
+                response: c.json({ error: 'Request body must be a JSON object' }, 400),
+            };
+        }
+        return { ok: true, body: body };
+    }
+    catch {
+        return {
+            ok: false,
+            response: c.json({ error: 'Invalid JSON body' }, 400),
+        };
+    }
+}
+// === Webhook Signature Verification ===
+function verifyLinearSignature(payload, signature, secret) {
+    if (!signature || !secret)
+        return false;
+    const expected = crypto.createHmac('sha256', secret).update(payload).digest('hex');
+    try {
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+    }
+    catch {
+        return false;
+    }
+}
+function verifyGitHubSignature(payload, signature, secret) {
+    if (!signature || !secret)
+        return false;
+    const expected = 'sha256=' + crypto.createHmac('sha256', secret).update(payload).digest('hex');
+    try {
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+    }
+    catch {
+        return false;
+    }
+}
+// === Webhook Endpoints ===
+/**
+ * Linear webhook endpoint
+ * POST /api/sync/webhook/linear
+ */
+syncRoutes.post('/webhook/linear', async (c) => {
+    const config = loadSyncConfig();
+    const linearConfig = config.platforms.linear;
+    // Verify webhook is enabled
+    if (!linearConfig?.enabled) {
+        return c.json({ error: 'Linear sync not enabled' }, 400);
+    }
+    // Get raw body for signature verification
+    const rawBody = await c.req.text();
+    const signature = c.req.header('linear-signature');
+    // Verify signature if secret is configured
+    if (linearConfig.webhookSecret) {
+        if (!verifyLinearSignature(rawBody, signature, linearConfig.webhookSecret)) {
+            console.warn('[SyncRoutes] Invalid Linear webhook signature');
+            return c.json({ error: 'Invalid signature' }, 401);
+        }
+    }
+    // Parse payload
+    let payload;
+    try {
+        payload = JSON.parse(rawBody);
+    }
+    catch {
+        return c.json({ error: 'Invalid JSON' }, 400);
+    }
+    // Handle webhook
+    const result = await handleSyncWebhook('linear', payload);
+    if (result.success) {
+        return c.json({ message: result.message });
+    }
+    else {
+        return c.json({ error: result.message }, 500);
+    }
+});
+/**
+ * GitHub webhook endpoint
+ * POST /api/sync/webhook/github
+ */
+syncRoutes.post('/webhook/github', async (c) => {
+    const config = loadSyncConfig();
+    const githubConfig = config.platforms.github;
+    // Verify webhook is enabled
+    if (!githubConfig?.enabled) {
+        return c.json({ error: 'GitHub sync not enabled' }, 400);
+    }
+    // Get raw body for signature verification
+    const rawBody = await c.req.text();
+    const signature = c.req.header('x-hub-signature-256');
+    // Verify signature if secret is configured
+    if (githubConfig.webhookSecret) {
+        if (!verifyGitHubSignature(rawBody, signature, githubConfig.webhookSecret)) {
+            console.warn('[SyncRoutes] Invalid GitHub webhook signature');
+            return c.json({ error: 'Invalid signature' }, 401);
+        }
+    }
+    // Check event type
+    const eventType = c.req.header('x-github-event');
+    if (!['issues', 'issue_comment'].includes(eventType || '')) {
+        // Acknowledge but ignore other events
+        return c.json({ message: `Ignored event type: ${eventType}` });
+    }
+    // Parse payload
+    let payload;
+    try {
+        payload = JSON.parse(rawBody);
+    }
+    catch {
+        return c.json({ error: 'Invalid JSON' }, 400);
+    }
+    // Try ticket sync handler first (for already-synced tickets)
+    try {
+        const ticketSyncResult = await processGitHubWebhookForTicketSync(eventType, payload);
+        if (ticketSyncResult.action !== 'ignored') {
+            console.log(`[SyncRoutes] GitHub ticket sync: ${ticketSyncResult.action}`, ticketSyncResult);
+            return c.json({
+                message: `Ticket sync: ${ticketSyncResult.action}`,
+                ticketId: ticketSyncResult.ticketId,
+                commentId: ticketSyncResult.commentId,
+            });
+        }
+    }
+    catch (error) {
+        console.error('[SyncRoutes] Ticket sync error (falling back to legacy):', error);
+    }
+    // Fallback to legacy sync webhook handler (for sync engine)
+    const result = await handleSyncWebhook('github', payload);
+    if (result.success) {
+        return c.json({ message: result.message });
+    }
+    else {
+        return c.json({ error: result.message }, 500);
+    }
+});
+// === Status & Management ===
+/**
+ * Get sync status
+ * GET /api/sync/status
+ */
+syncRoutes.get('/status', async (c) => {
+    const status = getSyncStatus();
+    // Add health check for each adapter
+    let health = {};
+    if (hasSyncEngine()) {
+        health = await getSyncEngine().healthCheck();
+    }
+    return c.json({
+        ...status,
+        health,
+    });
+});
+/**
+ * Trigger manual sync
+ * POST /api/sync/trigger
+ */
+syncRoutes.post('/trigger', async (c) => {
+    if (!hasSyncEngine()) {
+        return c.json({ error: 'Sync engine not initialized' }, 400);
+    }
+    const parsed = await parseJsonBody(c);
+    if (!parsed.ok) {
+        return parsed.response;
+    }
+    const body = parsed.body;
+    const engine = getSyncEngine();
+    try {
+        if (typeof body.platform === 'string' && body.platform.length > 0) {
+            // Sync specific platform
+            const results = await engine.syncPlatform(body.platform);
+            return c.json({
+                message: `Synced ${body.platform}`,
+                results,
+            });
+        }
+        else {
+            // Sync all platforms
+            const results = await engine.syncAll();
+            return c.json({
+                message: 'Synced all platforms',
+                results,
+            });
+        }
+    }
+    catch (error) {
+        console.error('[SyncRoutes] Sync trigger failed:', error);
+        return c.json({
+            error: error instanceof Error ? error.message : 'Sync failed',
+        }, 500);
+    }
+});
+/**
+ * Push ticket to external platform
+ * POST /api/sync/push/:ticketId
+ */
+syncRoutes.post('/push/:ticketId', async (c) => {
+    const ticketId = c.req.param('ticketId');
+    const parsed = await parseJsonBody(c);
+    if (!parsed.ok) {
+        return parsed.response;
+    }
+    const platform = typeof parsed.body.platform === 'string' ? parsed.body.platform : undefined;
+    const result = await pushTicketToExternal(ticketId, platform);
+    if (result.success) {
+        return c.json({
+            message: 'Ticket pushed successfully',
+            externalId: result.externalId,
+        });
+    }
+    else {
+        return c.json({ error: result.error }, 400);
+    }
+});
+/**
+ * Get pending conflicts
+ * GET /api/sync/conflicts
+ */
+syncRoutes.get('/conflicts', async (c) => {
+    if (!hasSyncEngine()) {
+        return c.json({ conflicts: [] });
+    }
+    const engine = getSyncEngine();
+    const conflicts = engine.getPendingConflicts();
+    return c.json({ conflicts, count: conflicts.length });
+});
+/**
+ * Resolve a conflict
+ * POST /api/sync/conflicts/:ticketId/resolve
+ */
+syncRoutes.post('/conflicts/:ticketId/resolve', async (c) => {
+    if (!hasSyncEngine()) {
+        return c.json({ error: 'Sync engine not initialized' }, 400);
+    }
+    const ticketId = c.req.param('ticketId');
+    const parsed = await parseJsonBody(c);
+    if (!parsed.ok) {
+        return parsed.response;
+    }
+    const resolution = parsed.body.resolution;
+    if (resolution !== 'local' && resolution !== 'remote') {
+        return c.json({ error: 'Invalid resolution. Must be "local" or "remote"' }, 400);
+    }
+    const engine = getSyncEngine();
+    engine.resolvePendingConflict(ticketId, resolution);
+    return c.json({ message: 'Conflict resolved', resolution });
+});
+export default syncRoutes;
+//# sourceMappingURL=sync.js.map

package/dist/routes/tasks.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+declare const tasks: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { tasks as tasksRoutes };
+//# sourceMappingURL=tasks.d.ts.map