profclaw 2.0.0 → 2.3.0

package/dist/routes/cron.js

@@ -9,6 +9,7 @@ import { zValidator } from '@hono/zod-validator';
 import { z } from 'zod';
 import { createScheduledJob, getScheduledJob, listScheduledJobs, updateScheduledJob, pauseScheduledJob, resumeScheduledJob, deleteScheduledJob, archiveScheduledJob, restoreScheduledJob, triggerScheduledJob, getJobRunHistory, getScheduler, } from '../cron/scheduler.js';
 import { listJobTemplates, getJobTemplate, createJobTemplate, deleteJobTemplate, applyJobTemplate, initBuiltInTemplates, } from '../cron/templates.js';
+import { parseNaturalLanguage, cronToHuman } from '../cron/natural-language.js';
 import { createContextualLogger } from '../utils/logger.js';
 const log = createContextualLogger('CronRoutes');
 const app = new Hono();
@@ -34,7 +35,7 @@ app.use('*', async (_c, next) => {
 });
 // Schemas
 const deliveryChannelSchema = z.object({
-    type: z.enum(['slack', 'webhook', 'email']),
+    type: z.enum(['slack', 'webhook', 'email', 'telegram', 'discord']),
     target: z.string(),
     onSuccess: z.boolean().optional(),
     onFailure: z.boolean().optional(),
@@ -64,7 +65,7 @@ const createJobSchema = z.object({
     // Event trigger (alternative to schedule)
     eventTrigger: eventTriggerSchema.optional(),
     // Execution
-    jobType: z.enum(['http', 'tool', 'script', 'message']),
+    jobType: z.enum(['http', 'tool', 'script', 'message', 'agent_session']),
     payload: z.record(z.any()),
     templateId: z.string().optional(),
     // Delivery
@@ -98,7 +99,7 @@ const updateJobSchema = z.object({
 });
 const listQuerySchema = z.object({
     status: z.enum(['active', 'paused', 'completed', 'failed', 'archived']).optional(),
-    jobType: z.enum(['http', 'tool', 'script', 'message']).optional(),
+    jobType: z.enum(['http', 'tool', 'script', 'message', 'agent_session']).optional(),
     projectId: z.string().optional(),
     userId: z.string().optional(),
     limit: z.coerce.number().min(1).max(100).optional().default(50),
@@ -107,8 +108,8 @@ const createTemplateSchema = z.object({
     name: z.string().min(1).max(100),
     description: z.string().max(500).optional(),
     icon: z.string().max(10).optional(),
-    category: z.enum(['sync', 'report', 'cleanup', 'notification', 'monitoring', 'custom']).optional(),
-    jobType: z.enum(['http', 'tool', 'script', 'message']),
+    category: z.enum(['sync', 'report', 'cleanup', 'notification', 'monitoring', 'automation', 'custom']).optional(),
+    jobType: z.enum(['http', 'tool', 'script', 'message', 'agent_session']),
     payloadTemplate: z.record(z.any()),
     suggestedCron: z.string().optional(),
     suggestedIntervalMs: z.number().min(1000).optional(),
@@ -166,6 +167,79 @@ app.get('/jobs', zValidator('query', listQuerySchema), async (c) => {
         }, 500);
     }
 });
+/**
+ * POST /api/cron/automate - Create a job from natural language
+ *
+ * Example: { "input": "every morning at 8am summarize my GitHub notifications and send to telegram" }
+ *
+ * Returns the parsed schedule, intent, and delivery - then creates the job.
+ * Use ?dryRun=true to preview without creating.
+ */
+app.post('/automate', zValidator('json', z.object({
+    input: z.string().min(5).max(500),
+})), async (c) => {
+    try {
+        const { input } = c.req.valid('json');
+        const dryRun = c.req.query('dryRun') === 'true';
+        const result = parseNaturalLanguage(input);
+        if (!result.success || !result.jobParams) {
+            return c.json({
+                success: false,
+                error: result.error ?? 'Could not understand the request',
+                parsed: {
+                    schedule: result.schedule,
+                    intent: result.intent,
+                    delivery: result.delivery,
+                },
+                hint: 'Try: "every morning at 8am summarize GitHub notifications and send to telegram"',
+            }, 400);
+        }
+        // Dry run: return what would be created
+        if (dryRun) {
+            return c.json({
+                success: true,
+                dryRun: true,
+                parsed: {
+                    schedule: result.schedule,
+                    intent: result.intent,
+                    delivery: result.delivery,
+                    humanReadable: result.schedule?.humanReadable,
+                    cronExpression: result.jobParams.cronExpression,
+                    cronExplained: result.jobParams.cronExpression
+                        ? cronToHuman(result.jobParams.cronExpression)
+                        : undefined,
+                },
+                jobParams: result.jobParams,
+                message: `Would create: "${result.jobParams.name}" running ${result.schedule?.humanReadable ?? 'on schedule'}`,
+            });
+        }
+        // Create the job
+        const job = await createScheduledJob(result.jobParams);
+        log.info(`Created job from natural language: ${job.name} (${job.id})`, {
+            input: input.slice(0, 80),
+            cron: result.jobParams.cronExpression,
+            schedule: result.schedule?.humanReadable,
+        });
+        return c.json({
+            success: true,
+            job,
+            parsed: {
+                schedule: result.schedule?.humanReadable,
+                cronExpression: result.jobParams.cronExpression,
+                intent: result.intent?.action,
+                delivery: result.delivery?.channel,
+            },
+            message: `Created "${job.name}" - ${result.schedule?.humanReadable ?? 'scheduled'}`,
+        }, 201);
+    }
+    catch (error) {
+        log.error('Failed to create job from natural language:', error instanceof Error ? error : new Error(String(error)));
+        return c.json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to create automation',
+        }, 500);
+    }
+});
 /**
  * POST /api/cron/jobs - Create a scheduled job
  * Supports: cron, interval, one-shot (runAt), or event-triggered
@@ -534,6 +608,7 @@ app.get('/stats', async (c) => {
                 tool: activeJobs.filter((j) => j.jobType === 'tool').length,
                 script: activeJobs.filter((j) => j.jobType === 'script').length,
                 message: activeJobs.filter((j) => j.jobType === 'message').length,
+                agent_session: activeJobs.filter((j) => j.jobType === 'agent_session').length,
             },
             byScheduleType: {
                 cron: activeJobs.filter((j) => j.cronExpression).length,

package/dist/routes/feeds.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Feed Routes
+ *
+ * REST API for managing RSS/Atom feeds and article digests.
+ * All endpoints are under /api/feeds.
+ */
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;
+//# sourceMappingURL=feeds.d.ts.map

package/dist/routes/feeds.js

@@ -0,0 +1,168 @@
+/**
+ * Feed Routes
+ *
+ * REST API for managing RSS/Atom feeds and article digests.
+ * All endpoints are under /api/feeds.
+ */
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { addFeed, addFeedBundle, listFeeds, getFeed, updateFeed, removeFeed, toggleFeed, pollFeed, pollAllFeeds, getDigestArticles, markAsDigested, getFeedStats, listCategories, discoverFeedUrl, FEED_BUNDLES, } from '../feeds/index.js';
+const app = new Hono();
+// Schemas
+const createFeedSchema = z.object({
+    name: z.string().min(1).max(200),
+    url: z.string().url(),
+    category: z.string().max(50).optional(),
+    tags: z.array(z.string()).optional(),
+    pollIntervalMs: z.number().min(60000).optional(), // Min 1 minute
+    metadata: z.record(z.unknown()).optional(),
+});
+const updateFeedSchema = z.object({
+    name: z.string().min(1).max(200).optional(),
+    category: z.string().max(50).optional(),
+    tags: z.array(z.string()).optional(),
+    pollIntervalMs: z.number().min(60000).optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+// Routes
+/** List all feeds */
+app.get('/', async (c) => {
+    const category = c.req.query('category');
+    const tag = c.req.query('tag');
+    const enabled = c.req.query('enabled');
+    const feeds = await listFeeds({
+        category: category || undefined,
+        tag: tag || undefined,
+        enabled: enabled !== undefined ? enabled === 'true' : undefined,
+    });
+    return c.json({ success: true, data: feeds });
+});
+/** Get feed stats */
+app.get('/stats', async (c) => {
+    const stats = await getFeedStats();
+    return c.json({ success: true, data: stats });
+});
+/** List available categories */
+app.get('/categories', async (c) => {
+    const categories = await listCategories();
+    return c.json({ success: true, data: categories });
+});
+/** List available bundles */
+app.get('/bundles', (c) => {
+    const bundles = Object.entries(FEED_BUNDLES).map(([name, feeds]) => ({
+        name,
+        feedCount: feeds.length,
+        feeds: feeds.map((f) => ({ name: f.name, url: f.url, category: f.category })),
+    }));
+    return c.json({ success: true, data: bundles });
+});
+/** Get a single feed */
+app.get('/:id', async (c) => {
+    const feed = await getFeed(c.req.param('id'));
+    if (!feed) {
+        return c.json({ success: false, error: { code: 'NOT_FOUND', message: 'Feed not found' } }, 404);
+    }
+    return c.json({ success: true, data: feed });
+});
+/** Create a new feed */
+app.post('/', async (c) => {
+    const body = await c.req.json();
+    const parsed = createFeedSchema.safeParse(body);
+    if (!parsed.success) {
+        return c.json({ success: false, error: { code: 'VALIDATION_ERROR', message: parsed.error.message } }, 400);
+    }
+    try {
+        const feed = await addFeed(parsed.data);
+        return c.json({ success: true, data: feed }, 201);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'Failed to create feed';
+        return c.json({ success: false, error: { code: 'CREATE_FAILED', message: msg } }, 400);
+    }
+});
+/** Install a feed bundle */
+app.post('/bundles/:name/install', async (c) => {
+    const bundleName = c.req.param('name');
+    try {
+        const feeds = await addFeedBundle(bundleName);
+        return c.json({ success: true, data: { installed: feeds.length, feeds } });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'Failed to install bundle';
+        return c.json({ success: false, error: { code: 'BUNDLE_FAILED', message: msg } }, 400);
+    }
+});
+/** Discover feed URL from a website */
+app.post('/discover', async (c) => {
+    const body = await c.req.json();
+    if (!body.url) {
+        return c.json({ success: false, error: { code: 'VALIDATION_ERROR', message: 'url is required' } }, 400);
+    }
+    const feedUrl = await discoverFeedUrl(body.url);
+    return c.json({ success: true, data: { feedUrl } });
+});
+/** Update a feed */
+app.patch('/:id', async (c) => {
+    const body = await c.req.json();
+    const parsed = updateFeedSchema.safeParse(body);
+    if (!parsed.success) {
+        return c.json({ success: false, error: { code: 'VALIDATION_ERROR', message: parsed.error.message } }, 400);
+    }
+    await updateFeed(c.req.param('id'), parsed.data);
+    const feed = await getFeed(c.req.param('id'));
+    return c.json({ success: true, data: feed });
+});
+/** Toggle feed enabled/disabled */
+app.post('/:id/toggle', async (c) => {
+    const body = await c.req.json();
+    const enabled = body.enabled !== false;
+    await toggleFeed(c.req.param('id'), enabled);
+    return c.json({ success: true, data: { enabled } });
+});
+/** Delete a feed */
+app.delete('/:id', async (c) => {
+    const removed = await removeFeed(c.req.param('id'));
+    if (!removed) {
+        return c.json({ success: false, error: { code: 'NOT_FOUND', message: 'Feed not found' } }, 404);
+    }
+    return c.json({ success: true });
+});
+/** Poll a specific feed */
+app.post('/:id/poll', async (c) => {
+    const result = await pollFeed(c.req.param('id'));
+    return c.json({ success: true, data: result });
+});
+/** Poll all due feeds */
+app.post('/poll-all', async (c) => {
+    const result = await pollAllFeeds();
+    return c.json({ success: true, data: result });
+});
+/** Get digest articles */
+app.get('/digest/articles', async (c) => {
+    const since = c.req.query('since');
+    const category = c.req.query('category');
+    const tag = c.req.query('tag');
+    const feedId = c.req.query('feedId');
+    const limit = c.req.query('limit');
+    const undigestedOnly = c.req.query('undigestedOnly');
+    const articles = await getDigestArticles({
+        since: since ? new Date(since) : undefined,
+        category: category || undefined,
+        tag: tag || undefined,
+        feedId: feedId || undefined,
+        limit: limit ? parseInt(limit) : undefined,
+        undigestedOnly: undigestedOnly === 'true',
+    });
+    return c.json({ success: true, data: articles });
+});
+/** Mark articles as digested */
+app.post('/digest/mark', async (c) => {
+    const body = await c.req.json();
+    if (!body.articleIds?.length) {
+        return c.json({ success: false, error: { code: 'VALIDATION_ERROR', message: 'articleIds required' } }, 400);
+    }
+    await markAsDigested(body.articleIds);
+    return c.json({ success: true });
+});
+export default app;
+//# sourceMappingURL=feeds.js.map

package/dist/routes/mcp.js

@@ -25,6 +25,27 @@ async function getMcpRuntime() {
     }
     return runtimePromise;
 }
+// GET / - MCP overview (alias for /status)
+mcpRoutes.get('/', async (c) => {
+    try {
+        const { mcpClientManager, adaptToolsToMCP } = await getMcpRuntime();
+        const connectedServers = mcpClientManager.getStatus();
+        const adaptedTools = adaptToolsToMCP();
+        return c.json({
+            server: {
+                enabled: true,
+                toolsExposed: adaptedTools.length,
+            },
+            clients: connectedServers,
+            connectedCount: connectedServers.filter((s) => s.connected).length,
+            totalServers: connectedServers.length,
+        });
+    }
+    catch (error) {
+        logger.error('[MCP Routes] Status error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to get MCP status' }, 500);
+    }
+});
 // GET /status - MCP server/client status
 mcpRoutes.get('/status', async (c) => {
     try {

package/dist/routes/memory.js

@@ -9,6 +9,8 @@ import { zValidator } from '@hono/zod-validator';
 import { z } from 'zod';
 import { initMemoryTables, syncMemoryFiles, searchMemory, getMemoryContent, getMemoryStats, listMemoryFiles, listFileChunks, deleteMemoryChunk, deleteMemoryFile, clearAllMemories, listMemorySessions, createMemorySession, archiveSession, DEFAULT_MEMORY_CONFIG, getMemoryWatcher, } from '../memory/index.js';
 import { initExperienceStore, recordExperience, getExperience, deleteExperience, listExperiences, findSimilarExperiences, markUsed, applyDecay, pruneExpired, getStats as getExperienceStats, trackPreference, getUserPreferences, } from '../memory/experience-store.js';
+import { observeConversation } from '../memory/observational.js';
+import { importFrom, listImportSources } from '../cli/commands/import.js';
 import { logger } from '../utils/logger.js';
 const memory = new Hono();
 // Schema Validators
@@ -618,5 +620,133 @@ memory.get('/preferences/:userId', async (c) => {
         return c.json({ error: 'Failed to get preferences', message: error instanceof Error ? error.message : 'Unknown error' }, 500);
     }
 });
+/**
+ * POST /api/memory/observe - Extract observations from a conversation
+ * Manually trigger observational memory on a conversation snapshot.
+ */
+memory.post('/observe', zValidator('json', z.object({
+    conversationId: z.string(),
+    messages: z.array(z.object({
+        role: z.enum(['user', 'assistant', 'system']),
+        content: z.string(),
+        toolsUsed: z.array(z.string()).optional(),
+    })),
+    userId: z.string().optional(),
+})), async (c) => {
+    try {
+        const body = c.req.valid('json');
+        const result = await observeConversation({
+            conversationId: body.conversationId,
+            messages: body.messages,
+            metadata: { userId: body.userId },
+        });
+        return c.json({
+            success: true,
+            data: {
+                observations: result.observations.map(o => ({
+                    type: o.type,
+                    summary: o.summary,
+                    confidence: o.confidence,
+                })),
+                experiencesRecorded: result.experiencesRecorded,
+                preferencesTracked: result.preferencesTracked,
+                processingTimeMs: result.processingTimeMs,
+            },
+        });
+    }
+    catch (error) {
+        logger.error('[Memory API] Observe failed:', error);
+        return c.json({ error: 'Failed to observe conversation', message: error instanceof Error ? error.message : 'Unknown error' }, 500);
+    }
+});
+/**
+ * GET /api/memory/insights - Dashboard summary of what profClaw has learned
+ * Shows learned patterns, top tool chains, preferences, and learning velocity.
+ */
+memory.get('/insights', async (c) => {
+    try {
+        const stats = await getExperienceStats();
+        const recentChains = await listExperiences({ type: 'tool_chain', limit: 10, minWeight: 0.1 });
+        const recentPrefs = await listExperiences({ type: 'user_preference', limit: 10 });
+        const recentSolutions = await listExperiences({ type: 'task_solution', limit: 5 });
+        const recentRecoveries = await listExperiences({ type: 'error_recovery', limit: 5 });
+        // Build top tool chains summary
+        const topChains = recentChains.experiences
+            .filter(e => e.useCount >= 2)
+            .sort((a, b) => b.useCount - a.useCount)
+            .slice(0, 5)
+            .map(e => {
+            const chain = e.solution;
+            return {
+                intent: e.intent.slice(0, 100),
+                tools: chain.tools?.map(t => t.name) ?? [],
+                useCount: e.useCount,
+                successScore: e.successScore,
+                lastUsed: new Date(e.lastUsedAt).toISOString(),
+            };
+        });
+        // Learning velocity: experiences recorded per day (last 7 days)
+        const now = Date.now();
+        const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
+        const allRecent = await listExperiences({ limit: 100 });
+        const recentCount = allRecent.experiences.filter(e => e.createdAt > sevenDaysAgo).length;
+        const learningRate = Math.round((recentCount / 7) * 10) / 10;
+        return c.json({
+            success: true,
+            data: {
+                stats,
+                learningRate: `${learningRate} experiences/day`,
+                topToolChains: topChains,
+                recentPreferences: recentPrefs.experiences.slice(0, 5).map(e => ({
+                    intent: e.intent,
+                    useCount: e.useCount,
+                    weight: Math.round(e.weight * 100) / 100,
+                })),
+                recentSolutions: recentSolutions.total,
+                errorRecoveries: recentRecoveries.total,
+                summary: stats.total === 0
+                    ? 'No experiences recorded yet. profClaw learns as you use it - tool chains, preferences, and error recovery patterns improve over time.'
+                    : `profClaw has learned ${stats.total} experiences across ${Object.keys(stats.byType).length} categories. Learning rate: ${learningRate}/day. ${topChains.length > 0 ? `Most-used pattern: ${topChains[0].tools.join(' -> ')} (${topChains[0].useCount}x).` : ''}`,
+            },
+        });
+    }
+    catch (error) {
+        logger.error('[Memory API] Insights failed:', error);
+        return c.json({ error: 'Failed to generate insights', message: error instanceof Error ? error.message : 'Unknown error' }, 500);
+    }
+});
+/**
+ * GET /api/memory/import/sources - List available import sources
+ */
+memory.get('/import/sources', (_c) => {
+    return _c.json({ success: true, sources: listImportSources() });
+});
+/**
+ * POST /api/memory/import - Import data from another AI assistant
+ */
+memory.post('/import', zValidator('json', z.object({
+    source: z.enum(['openclaw', 'chatgpt', 'aider']),
+    path: z.string().optional(),
+    file: z.string().optional(),
+    dryRun: z.boolean().optional().default(false),
+})), async (c) => {
+    try {
+        const body = c.req.valid('json');
+        const result = await importFrom(body.source, {
+            path: body.path,
+            file: body.file,
+            dryRun: body.dryRun,
+        });
+        return c.json({
+            success: result.errors.length === 0,
+            data: result,
+            summary: `Imported from ${result.source}: ${result.memories} memories, ${result.conversations} conversations, ${result.skills} skills, ${result.preferences} preferences${result.errors.length > 0 ? ` (${result.errors.length} errors)` : ''}`,
+        });
+    }
+    catch (error) {
+        logger.error('[Memory API] Import failed:', error);
+        return c.json({ error: 'Import failed', message: error instanceof Error ? error.message : 'Unknown error' }, 500);
+    }
+});
 export { memory as memoryRoutes };
 //# sourceMappingURL=memory.js.map

package/dist/routes/skills.js

@@ -149,4 +149,133 @@ skillsRoutes.post('/:name/toggle', async (c) => {
         enabled: skill.enabled,
     });
 });
+// --- Marketplace Routes ---
+import { getMarketplace } from '../skills/marketplace.js';
+import { getSkillEffectiveness } from '../skills/compiler.js';
+/** Search marketplace for skills */
+skillsRoutes.get('/marketplace/search', async (c) => {
+    const marketplace = getMarketplace();
+    const query = c.req.query('q');
+    const category = c.req.query('category');
+    const tag = c.req.query('tag');
+    const sortBy = c.req.query('sortBy');
+    const limit = c.req.query('limit');
+    const results = await marketplace.search({
+        query: query || undefined,
+        category: category || undefined,
+        tag: tag || undefined,
+        sortBy,
+        limit: limit ? parseInt(limit) : undefined,
+    });
+    return c.json({ success: true, data: results });
+});
+/** Install a skill from marketplace, GitHub, or URL */
+skillsRoutes.post('/marketplace/install', async (c) => {
+    const body = await c.req.json();
+    if (!body.source) {
+        return c.json({ success: false, error: { code: 'VALIDATION_ERROR', message: 'source is required' } }, 400);
+    }
+    const marketplace = getMarketplace();
+    const result = await marketplace.install(body.source);
+    if (result.success) {
+        // Reload skills registry to pick up new skill
+        const registry = getSkillsRegistry();
+        await registry.reload();
+    }
+    return c.json({ success: result.success, data: result });
+});
+/** Uninstall a managed skill */
+skillsRoutes.delete('/marketplace/:name', async (c) => {
+    const marketplace = getMarketplace();
+    const removed = await marketplace.uninstall(c.req.param('name'));
+    if (removed) {
+        const registry = getSkillsRegistry();
+        await registry.reload();
+    }
+    return c.json({ success: removed });
+});
+/** Check for skill updates */
+skillsRoutes.get('/marketplace/updates', async (c) => {
+    const marketplace = getMarketplace();
+    const updates = await marketplace.checkUpdates();
+    return c.json({ success: true, data: updates });
+});
+/** List configured registries */
+skillsRoutes.get('/marketplace/registries', (c) => {
+    const marketplace = getMarketplace();
+    return c.json({ success: true, data: marketplace.listRegistries() });
+});
+/** Get all categories from installed skills */
+skillsRoutes.get('/categories', (_c) => {
+    const registry = getSkillsRegistry();
+    const entries = registry.getAllEntries();
+    const categories = new Map();
+    for (const entry of entries) {
+        const cats = entry.metadata?.toolCategories ?? [];
+        if (cats.length === 0) {
+            categories.set('uncategorized', (categories.get('uncategorized') ?? 0) + 1);
+        }
+        for (const cat of cats) {
+            categories.set(cat, (categories.get(cat) ?? 0) + 1);
+        }
+    }
+    const sorted = [...categories.entries()]
+        .map(([name, count]) => ({ name, count }))
+        .sort((a, b) => b.count - a.count);
+    return _c.json({ success: true, data: sorted });
+});
+/** Get skill effectiveness/usage stats */
+skillsRoutes.get('/:name/effectiveness', (c) => {
+    const name = c.req.param('name');
+    const records = getSkillEffectiveness(name);
+    const totalAttempts = records.reduce((s, r) => s + r.attempts, 0);
+    const totalSuccesses = records.reduce((s, r) => s + r.successes, 0);
+    const overallRate = totalAttempts > 0 ? totalSuccesses / totalAttempts : 0;
+    return c.json({
+        success: true,
+        data: {
+            skillId: name,
+            totalAttempts,
+            totalSuccesses,
+            overallSuccessRate: Math.round(overallRate * 100),
+            byModel: records.map(r => ({
+                model: r.modelId,
+                attempts: r.attempts,
+                successRate: Math.round(r.successRate * 100),
+                avgDurationMs: Math.round(r.avgDurationMs),
+            })),
+        },
+    });
+});
+/** Get aggregate skill stats for dashboard */
+skillsRoutes.get('/stats/overview', (_c) => {
+    const registry = getSkillsRegistry();
+    const entries = registry.getAllEntries();
+    const registryStats = registry.getStats();
+    // Group by category
+    const byCategory = {};
+    for (const entry of entries) {
+        for (const cat of entry.metadata?.toolCategories ?? ['other']) {
+            byCategory[cat] = (byCategory[cat] ?? 0) + 1;
+        }
+    }
+    // Count user vs model invocable
+    const userInvocable = entries.filter(e => e.invocation.userInvocable).length;
+    const modelInvocable = entries.filter(e => e.invocation.modelInvocable).length;
+    const eligible = entries.filter(e => e.eligible !== false).length;
+    const enabled = entries.filter(e => e.enabled !== false).length;
+    return _c.json({
+        success: true,
+        data: {
+            total: registryStats.totalSkills,
+            enabled,
+            eligible,
+            bySource: registryStats.bySource,
+            byCategory,
+            userInvocable,
+            modelInvocable,
+            mcpServers: registryStats.mcpServers,
+        },
+    });
+});
 //# sourceMappingURL=skills.js.map

package/dist/routes/teams.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Teams API Routes
+ *
+ * Multi-user team management with shared cost budgets.
+ * No other OSS AI tool has this.
+ */
+import { Hono } from 'hono';
+export declare const teamRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=teams.d.ts.map