@leejungkiin/awkit 1.1.0 → 1.1.2

package/symphony/app/api/agents/route.js

@@ -0,0 +1,152 @@
+import { NextResponse } from 'next/server';
+import {
+    listAllAgents, registerAgent, updateAgentProfile, removeAgent, dispatchTask,
+    listProjectAgents, getProjectAgent, createProjectAgent, updateProjectAgent,
+    removeProjectAgent, attachProjectAgentSession, detachProjectAgentSession,
+} from '../../../lib/core.mjs';
+
+// GET /api/agents — List agents (supports ?project=X for project-scoped filtering)
+export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const project = searchParams.get('project');
+        const type = searchParams.get('type') || 'project'; // 'project' (default) or 'legacy'
+
+        if (type === 'legacy') {
+            const agents = listAllAgents();
+            return NextResponse.json({ agents, type: 'legacy' });
+        }
+
+        const agents = listProjectAgents(project || undefined);
+        return NextResponse.json({ agents, type: 'project' });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+// POST /api/agents — Create agent (project-scoped or legacy)
+export async function POST(request) {
+    try {
+        const body = await request.json();
+        if (!body.id) {
+            return NextResponse.json({ error: 'Agent ID is required' }, { status: 400 });
+        }
+
+        // Project-scoped agent (new)
+        if (body.projectId || body.project_id) {
+            const agent = createProjectAgent({
+                id: body.id,
+                projectId: body.projectId || body.project_id,
+                name: body.name || body.id,
+                skills: body.skills || [],
+                icon: body.icon,
+                color: body.color,
+            });
+            return NextResponse.json({ agent, type: 'project' }, { status: 201 });
+        }
+
+        // Legacy agent
+        const agent = registerAgent(body.id, body.name);
+        if (body.specialties || body.color || body.max_concurrent) {
+            updateAgentProfile(body.id, {
+                specialties: body.specialties,
+                color: body.color,
+                max_concurrent: body.max_concurrent,
+            });
+        }
+        const updated = listAllAgents().find(a => a.id === body.id);
+        return NextResponse.json({ agent: updated, type: 'legacy' }, { status: 201 });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+// PATCH /api/agents — Update agent, assign task, attach, or detach
+export async function PATCH(request) {
+    try {
+        const body = await request.json();
+        if (!body.id) {
+            return NextResponse.json({ error: 'Agent ID is required' }, { status: 400 });
+        }
+
+        // Check if this is a project agent
+        const projectAgent = getProjectAgent(body.id);
+
+        if (projectAgent) {
+            // Project agent actions
+            if (body.action === 'attach' && body.sessionId) {
+                const agent = attachProjectAgentSession(body.id, body.sessionId);
+                return NextResponse.json({ agent, action: 'attached' });
+            }
+            if (body.action === 'detach') {
+                const agent = detachProjectAgentSession(body.id);
+                return NextResponse.json({ agent, action: 'detached' });
+            }
+            if (body.action === 'assign' && body.taskId) {
+                const task = dispatchTask(body.id, body.taskId);
+                return NextResponse.json({ task, action: 'assigned' });
+            }
+
+            // Update project agent fields
+            const agent = updateProjectAgent(body.id, {
+                name: body.name,
+                skills: body.skills,
+                icon: body.icon,
+                color: body.color,
+            });
+            return NextResponse.json({ agent, type: 'project' });
+        }
+
+        // Legacy agent fallback
+        if (body.action === 'assign' && body.taskId) {
+            const task = dispatchTask(body.id, body.taskId);
+            return NextResponse.json({ task });
+        }
+
+        const agent = updateAgentProfile(body.id, {
+            name: body.name,
+            specialties: body.specialties,
+            color: body.color,
+            max_concurrent: body.max_concurrent,
+        });
+        const updated = listAllAgents().find(a => a.id === body.id);
+        return NextResponse.json({ agent: updated, type: 'legacy' });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+// DELETE /api/agents — Remove agent
+export async function DELETE(request) {
+    try {
+        const body = await request.json();
+        if (!body.id) {
+            return NextResponse.json({ error: 'Agent ID is required' }, { status: 400 });
+        }
+
+        // Try project agent first
+        const projectAgent = getProjectAgent(body.id);
+        if (projectAgent) {
+            removeProjectAgent(body.id);
+            return NextResponse.json({ success: true, type: 'project' });
+        }
+
+        // Legacy fallback
+        removeAgent(body.id);
+        return NextResponse.json({ success: true, type: 'legacy' });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: 500 }
+        );
+    }
+}

package/symphony/app/api/events/route.js

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server';
+import { queryEvents } from '../../../lib/core.mjs';
+
+// GET /api/events — List recent events (scoped by project)
+export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const since = searchParams.get('since') || undefined;
+        const eventType = searchParams.get('type') || undefined;
+        const project = searchParams.get('project') || undefined;
+        const limit = parseInt(searchParams.get('limit') || '30');
+
+        const events = queryEvents({ since, eventType, project, limit });
+
+        return NextResponse.json({ events });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: 500 }
+        );
+    }
+}

package/symphony/app/api/knowledge/route.js

@@ -0,0 +1,253 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+
+const KNOWLEDGE_DIR = path.join(
+    process.env.HOME || process.env.USERPROFILE,
+    '.gemini', 'antigravity', 'knowledge'
+);
+
+/**
+ * GET /api/knowledge
+ * 
+ * Query params:
+ *   - (none)          → List all KI summaries
+ *   - id=<folder>     → Get KI detail + artifact list
+ *   - id=<folder>&file=<path> → Read artifact file content
+ */
+export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const id = searchParams.get('id');
+        const file = searchParams.get('file');
+
+        // Read a specific artifact file
+        if (id && file) {
+            const filePath = path.join(KNOWLEDGE_DIR, id, file);
+            if (!filePath.startsWith(KNOWLEDGE_DIR)) {
+                return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+            }
+            if (!fs.existsSync(filePath)) {
+                return NextResponse.json({ error: 'File not found' }, { status: 404 });
+            }
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return NextResponse.json({ content, path: file });
+        }
+
+        // Get detail of a specific KI
+        if (id) {
+            const kiDir = path.join(KNOWLEDGE_DIR, id);
+            if (!fs.existsSync(kiDir)) {
+                return NextResponse.json({ error: 'KI not found' }, { status: 404 });
+            }
+            const metadata = readMetadata(kiDir);
+            const artifacts = listArtifacts(kiDir);
+            return NextResponse.json({ item: { id, ...metadata, artifacts } });
+        }
+
+        // List all KIs
+        if (!fs.existsSync(KNOWLEDGE_DIR)) {
+            return NextResponse.json({ items: [] });
+        }
+        const entries = fs.readdirSync(KNOWLEDGE_DIR, { withFileTypes: true });
+        const items = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+            const kiDir = path.join(KNOWLEDGE_DIR, entry.name);
+            const metaPath = path.join(kiDir, 'metadata.json');
+            if (!fs.existsSync(metaPath)) continue;
+            const metadata = readMetadata(kiDir);
+            const artifactCount = countArtifacts(kiDir);
+            const stat = fs.statSync(metaPath);
+            items.push({
+                id: entry.name,
+                title: metadata.title || entry.name,
+                summary: metadata.summary || '',
+                referenceCount: (metadata.references || []).length,
+                artifactCount,
+                updatedAt: stat.mtime.toISOString(),
+            });
+        }
+        // Sort by updatedAt desc
+        items.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+        return NextResponse.json({ items });
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+
+/**
+ * POST /api/knowledge — Create a new KI
+ * Body: { id, title, summary, references? }
+ */
+export async function POST(request) {
+    try {
+        const body = await request.json();
+        if (!body.id || !body.title) {
+            return NextResponse.json({ error: 'id and title are required' }, { status: 400 });
+        }
+        // Sanitize id
+        const safeId = body.id.replace(/[^a-z0-9_-]/gi, '_').toLowerCase();
+        const kiDir = path.join(KNOWLEDGE_DIR, safeId);
+        if (fs.existsSync(kiDir)) {
+            return NextResponse.json({ error: 'KI already exists' }, { status: 409 });
+        }
+        const artifactsDir = path.join(kiDir, 'artifacts');
+        fs.mkdirSync(artifactsDir, { recursive: true });
+
+        const metadata = {
+            title: body.title,
+            summary: body.summary || '',
+            references: body.references || [],
+        };
+        fs.writeFileSync(
+            path.join(kiDir, 'metadata.json'),
+            JSON.stringify(metadata, null, 2),
+            'utf-8'
+        );
+        // Create overview.md stub
+        fs.writeFileSync(
+            path.join(artifactsDir, 'overview.md'),
+            `# ${body.title}\n\n${body.summary || 'TODO: Add content'}\n`,
+            'utf-8'
+        );
+        return NextResponse.json({
+            item: { id: safeId, ...metadata, artifacts: ['artifacts/overview.md'] }
+        }, { status: 201 });
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+
+/**
+ * PATCH /api/knowledge — Update metadata or file content
+ * Body: { id, file?, content?, metadata? }
+ */
+export async function PATCH(request) {
+    try {
+        const body = await request.json();
+        if (!body.id) {
+            return NextResponse.json({ error: 'id is required' }, { status: 400 });
+        }
+        const kiDir = path.join(KNOWLEDGE_DIR, body.id);
+        if (!fs.existsSync(kiDir)) {
+            return NextResponse.json({ error: 'KI not found' }, { status: 404 });
+        }
+
+        // Update file content
+        if (body.file && body.content !== undefined) {
+            const filePath = path.join(kiDir, body.file);
+            if (!filePath.startsWith(KNOWLEDGE_DIR)) {
+                return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+            }
+            // Ensure parent dir exists
+            const parentDir = path.dirname(filePath);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, body.content, 'utf-8');
+            return NextResponse.json({ success: true, file: body.file });
+        }
+
+        // Update metadata
+        if (body.metadata) {
+            const metaPath = path.join(kiDir, 'metadata.json');
+            const existing = readMetadata(kiDir);
+            const updated = {
+                ...existing,
+                ...body.metadata,
+            };
+            fs.writeFileSync(metaPath, JSON.stringify(updated, null, 2), 'utf-8');
+            return NextResponse.json({ success: true, metadata: updated });
+        }
+
+        return NextResponse.json({ error: 'No update specified (need file+content or metadata)' }, { status: 400 });
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+
+/**
+ * DELETE /api/knowledge — Delete an artifact file
+ * Body: { id, file }
+ */
+export async function DELETE(request) {
+    try {
+        const body = await request.json();
+        if (!body.id || !body.file) {
+            return NextResponse.json({ error: 'id and file are required' }, { status: 400 });
+        }
+        // Prevent deleting metadata.json
+        if (body.file === 'metadata.json') {
+            return NextResponse.json({ error: 'Cannot delete metadata.json' }, { status: 400 });
+        }
+        const filePath = path.join(KNOWLEDGE_DIR, body.id, body.file);
+        if (!filePath.startsWith(KNOWLEDGE_DIR)) {
+            return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+        }
+        if (!fs.existsSync(filePath)) {
+            return NextResponse.json({ error: 'File not found' }, { status: 404 });
+        }
+        fs.unlinkSync(filePath);
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function readMetadata(kiDir) {
+    const metaPath = path.join(kiDir, 'metadata.json');
+    if (!fs.existsSync(metaPath)) return { title: '', summary: '', references: [] };
+    try {
+        return JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+    } catch {
+        return { title: '', summary: '', references: [] };
+    }
+}
+
+function listArtifacts(kiDir) {
+    const results = [];
+    function walk(dir, prefix) {
+        if (!fs.existsSync(dir)) return;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.name === 'metadata.json') continue;
+            if (entry.name === '.DS_Store') continue;
+            if (entry.isDirectory()) {
+                walk(path.join(dir, entry.name), relPath);
+            } else {
+                const stat = fs.statSync(path.join(dir, entry.name));
+                results.push({
+                    path: relPath,
+                    name: entry.name,
+                    size: stat.size,
+                    updatedAt: stat.mtime.toISOString(),
+                });
+            }
+        }
+    }
+    walk(kiDir, '');
+    return results;
+}
+
+function countArtifacts(kiDir) {
+    const artifactsDir = path.join(kiDir, 'artifacts');
+    if (!fs.existsSync(artifactsDir)) return 0;
+    let count = 0;
+    function walk(dir) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === '.DS_Store') continue;
+            if (entry.isDirectory()) {
+                walk(path.join(dir, entry.name));
+            } else {
+                count++;
+            }
+        }
+    }
+    walk(artifactsDir);
+    return count;
+}

package/symphony/app/api/locks/route.js

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server';
+import { forceReleaseLock } from '../../../lib/core.mjs';
+
+// DELETE /api/locks — Force-release a file lock
+export async function DELETE(request) {
+    try {
+        const body = await request.json();
+
+        if (!body.file) {
+            return NextResponse.json(
+                { error: 'File path is required' },
+                { status: 400 }
+            );
+        }
+
+        const released = forceReleaseLock(body.file);
+
+        return NextResponse.json({
+            released,
+            file: body.file,
+            message: released ? 'Lock released' : 'No lock found',
+        });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: 500 }
+        );
+    }
+}

package/symphony/app/api/notes/route.js

@@ -0,0 +1,125 @@
+import { NextResponse } from 'next/server';
+import { createNote, listNotes, getNote, updateNote, deleteNote } from '../../../lib/core.mjs';
+
+// GET /api/notes — List notes with filters
+export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const projectId = searchParams.get('projectId') || undefined;
+        const type = searchParams.get('type') || undefined;
+        const conversationId = searchParams.get('conversationId') || undefined;
+        const taskId = searchParams.get('taskId') || undefined;
+        const limit = searchParams.get('limit') || '50';
+
+        const notes = listNotes({
+            projectId,
+            type,
+            conversationId,
+            taskId,
+            limit: parseInt(limit),
+        });
+
+        return NextResponse.json({ notes });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+// POST /api/notes — Create a note
+export async function POST(request) {
+    try {
+        const body = await request.json();
+
+        if (!body.project_id && !body.projectId) {
+            return NextResponse.json(
+                { error: 'project_id is required' },
+                { status: 400 }
+            );
+        }
+        if (!body.type) {
+            return NextResponse.json(
+                { error: 'type is required' },
+                { status: 400 }
+            );
+        }
+        if (!body.title) {
+            return NextResponse.json(
+                { error: 'title is required' },
+                { status: 400 }
+            );
+        }
+
+        const note = createNote({
+            projectId: body.project_id || body.projectId,
+            type: body.type,
+            title: body.title,
+            content: body.content,
+            filePath: body.file_path || body.filePath,
+            conversationId: body.conversation_id || body.conversationId,
+            taskId: body.task_id || body.taskId,
+            metadata: body.metadata,
+        });
+
+        return NextResponse.json({ note }, { status: 201 });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: error.message.includes('required') ? 400 : 500 }
+        );
+    }
+}
+
+// PATCH /api/notes — Update a note
+export async function PATCH(request) {
+    try {
+        const body = await request.json();
+
+        if (!body.id) {
+            return NextResponse.json(
+                { error: 'Note ID is required' },
+                { status: 400 }
+            );
+        }
+
+        const note = updateNote(body.id, {
+            title: body.title,
+            content: body.content,
+            file_path: body.file_path || body.filePath,
+            task_id: body.task_id || body.taskId,
+            metadata: body.metadata,
+            conversation_id: body.conversation_id || body.conversationId,
+        });
+
+        return NextResponse.json({ note });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: error.message.includes('not found') ? 404 : 500 }
+        );
+    }
+}
+
+// DELETE /api/notes — Delete a note
+export async function DELETE(request) {
+    try {
+        const body = await request.json();
+
+        if (!body.id) {
+            return NextResponse.json(
+                { error: 'Note ID is required' },
+                { status: 400 }
+            );
+        }
+
+        deleteNote(body.id);
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error.message },
+            { status: error.message.includes('not found') ? 404 : 500 }
+        );
+    }
+}

package/symphony/app/api/preflight/route.js

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server';
+import { getPreflightStatus } from '../../../lib/core.mjs';
+
+// GET /api/preflight — Single-call gate check for AI agents
+// Returns server health, active project, task summary, and gate status
+export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const project = searchParams.get('project') || undefined;
+
+        const preflight = getPreflightStatus(project);
+        return NextResponse.json(preflight);
+    } catch (error) {
+        return NextResponse.json(
+            {
+                gate_status: 'FAIL',
+                error: error.message,
+                server: { status: 'error' },
+            },
+            { status: 500 }
+        );
+    }
+}