profclaw 0.0.1-beta.3 → 2.3.0

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

package/dist/routes/teams.js

@@ -0,0 +1,210 @@
+/**
+ * Teams API Routes
+ *
+ * Multi-user team management with shared cost budgets.
+ * No other OSS AI tool has this.
+ */
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { initTeamsTables, createTeam, getTeam, getTeamBySlug, listUserTeams, updateTeam, deleteTeam, addMember, removeMember, listMembers, updateMemberRole, getTeamUsage, canMemberSpend, createInvite, acceptInvite, listTeamInvites, } from '../teams/index.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('TeamsRoutes');
+const app = new Hono();
+// Lazy init
+let initialized = false;
+app.use('*', async (_c, next) => {
+    if (!initialized) {
+        initialized = true;
+        try {
+            await initTeamsTables();
+        }
+        catch (e) {
+            initialized = false;
+            log.warn('Failed to init teams tables', { error: e.message });
+        }
+    }
+    await next();
+});
+// Schemas
+const createTeamSchema = z.object({
+    name: z.string().min(1).max(50),
+    slug: z.string().min(1).max(50).regex(/^[a-z0-9-]+$/).optional(),
+    description: z.string().max(200).optional(),
+    ownerId: z.string(),
+    monthlyBudget: z.number().min(0).optional(),
+    dailyBudget: z.number().min(0).optional(),
+});
+const updateTeamSchema = z.object({
+    name: z.string().min(1).max(50).optional(),
+    description: z.string().max(200).optional(),
+    monthlyBudgetUsd: z.number().min(0).optional(),
+    dailyBudgetUsd: z.number().min(0).optional(),
+    budgetAlertThresholds: z.array(z.number().min(0).max(100)).optional(),
+    defaultModel: z.string().optional(),
+    preferredProviders: z.array(z.string()).optional(),
+    smartRoutingEnabled: z.boolean().optional(),
+});
+const addMemberSchema = z.object({
+    userId: z.string(),
+    role: z.enum(['admin', 'member', 'viewer']).optional().default('member'),
+});
+const inviteSchema = z.object({
+    email: z.string().email(),
+    role: z.enum(['admin', 'member', 'viewer']).optional().default('member'),
+    invitedBy: z.string(),
+});
+// Routes
+/**
+ * GET /api/teams - List teams for a user
+ */
+app.get('/', async (c) => {
+    const userId = c.req.query('userId');
+    if (!userId)
+        return c.json({ error: 'userId query param required' }, 400);
+    const teams = await listUserTeams(userId);
+    return c.json({ success: true, teams, total: teams.length });
+});
+/**
+ * POST /api/teams - Create a team
+ */
+app.post('/', zValidator('json', createTeamSchema), async (c) => {
+    try {
+        const body = c.req.valid('json');
+        const team = await createTeam(body);
+        return c.json({ success: true, team }, 201);
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+/**
+ * GET /api/teams/:id - Get team details
+ */
+app.get('/:id', async (c) => {
+    const { id } = c.req.param();
+    const team = id.includes('-') ? await getTeam(id) : await getTeamBySlug(id);
+    if (!team)
+        return c.json({ success: false, error: 'Team not found' }, 404);
+    return c.json({ success: true, team });
+});
+/**
+ * PATCH /api/teams/:id - Update team settings
+ */
+app.patch('/:id', zValidator('json', updateTeamSchema), async (c) => {
+    const { id } = c.req.param();
+    const body = c.req.valid('json');
+    const team = await updateTeam(id, body);
+    if (!team)
+        return c.json({ success: false, error: 'Team not found' }, 404);
+    return c.json({ success: true, team });
+});
+/**
+ * DELETE /api/teams/:id - Delete a team
+ */
+app.delete('/:id', async (c) => {
+    const { id } = c.req.param();
+    await deleteTeam(id);
+    return c.json({ success: true, deleted: true });
+});
+// Members
+/**
+ * GET /api/teams/:id/members - List team members
+ */
+app.get('/:id/members', async (c) => {
+    const { id } = c.req.param();
+    const members = await listMembers(id);
+    return c.json({ success: true, members, total: members.length });
+});
+/**
+ * POST /api/teams/:id/members - Add a member
+ */
+app.post('/:id/members', zValidator('json', addMemberSchema), async (c) => {
+    const { id } = c.req.param();
+    const body = c.req.valid('json');
+    try {
+        const member = await addMember(id, body.userId, body.role);
+        return c.json({ success: true, member }, 201);
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+/**
+ * DELETE /api/teams/:id/members/:userId - Remove a member
+ */
+app.delete('/:id/members/:userId', async (c) => {
+    const { id, userId } = c.req.param();
+    await removeMember(id, userId);
+    return c.json({ success: true, removed: true });
+});
+/**
+ * PATCH /api/teams/:id/members/:userId/role - Change member role
+ */
+app.patch('/:id/members/:userId/role', zValidator('json', z.object({
+    role: z.enum(['admin', 'member', 'viewer']),
+})), async (c) => {
+    const { id, userId } = c.req.param();
+    const { role } = c.req.valid('json');
+    await updateMemberRole(id, userId, role);
+    return c.json({ success: true, role });
+});
+// Budget & Usage
+/**
+ * GET /api/teams/:id/usage - Get team usage summary
+ */
+app.get('/:id/usage', async (c) => {
+    const { id } = c.req.param();
+    try {
+        const usage = await getTeamUsage(id);
+        return c.json({ success: true, usage });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 404);
+    }
+});
+/**
+ * GET /api/teams/:id/budget/check - Check if a member can spend
+ */
+app.get('/:id/budget/check', async (c) => {
+    const { id } = c.req.param();
+    const userId = c.req.query('userId');
+    const cost = parseFloat(c.req.query('cost') ?? '0.01');
+    if (!userId)
+        return c.json({ error: 'userId query param required' }, 400);
+    const result = await canMemberSpend(id, userId, cost);
+    return c.json({ success: true, ...result });
+});
+// Invites
+/**
+ * GET /api/teams/:id/invites - List pending invites
+ */
+app.get('/:id/invites', async (c) => {
+    const { id } = c.req.param();
+    const invites = await listTeamInvites(id);
+    return c.json({ success: true, invites, total: invites.length });
+});
+/**
+ * POST /api/teams/:id/invites - Create an invite
+ */
+app.post('/:id/invites', zValidator('json', inviteSchema), async (c) => {
+    const { id } = c.req.param();
+    const body = c.req.valid('json');
+    const invite = await createInvite(id, body.email, body.role, body.invitedBy);
+    return c.json({ success: true, invite }, 201);
+});
+/**
+ * POST /api/teams/invites/:inviteId/accept - Accept an invite
+ */
+app.post('/invites/:inviteId/accept', zValidator('json', z.object({
+    userId: z.string(),
+})), async (c) => {
+    const { inviteId } = c.req.param();
+    const { userId } = c.req.valid('json');
+    const member = await acceptInvite(inviteId, userId);
+    if (!member)
+        return c.json({ success: false, error: 'Invite not found or expired' }, 404);
+    return c.json({ success: true, member });
+});
+export const teamRoutes = app;
+//# sourceMappingURL=teams.js.map