@leejungkiin/awkit 1.0.9 → 1.1.1

package/skills/telegram-notify/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: telegram-notify
+description: Send Telegram notifications via AWKit CLI (Bot API). Use when tasks complete, deploys finish, or user requests Telegram alerts.
+triggers:
+  - keywords: ["telegram", "tg", "notify", "gửi telegram", "báo telegram", "thông báo"]
+  - events: ["deploy_complete", "task_complete", "user_request"]
+priority: low
+---
+
+# Telegram Notify Skill
+
+Send messages to Telegram groups/topics via `awkit tg` CLI command (Bot API, zero MCP needed).
+
+## When to Use
+
+- User explicitly asks to send a Telegram message
+- After deploy/release completion (if user has configured notifications)
+- Task completion summaries when user requests
+
+## Prerequisites
+
+User must have run `awkit tg setup` first. If not configured, guide them:
+
+```bash
+awkit tg setup
+# Prompts: Bot Token → Chat ID → Topic ID (optional)
+```
+
+## Commands
+
+```bash
+# Send plain text
+awkit tg send "message here"
+
+# Send to specific chat
+awkit tg send --chat -100xxx "message"
+
+# Send to specific forum topic
+awkit tg send --topic 123 "message"
+
+# Markdown formatting
+awkit tg send --parse-mode md "**bold** _italic_ `code`"
+
+# HTML formatting
+awkit tg send --parse-mode html "<b>bold</b> <i>italic</i>"
+
+# Combine flags
+awkit tg send --chat -100xxx --topic 456 --parse-mode md "**Done!**"
+```
+
+## AI Usage Rules
+
+1. **NEVER send without user consent** — always confirm before sending
+2. **Keep messages concise** — summarize, don't dump full logs
+3. **Use Markdown** for formatted messages (`--parse-mode md`)
+4. **Config location**: `~/.gemini/antigravity/.tg_config.json`
+5. If `awkit tg send` returns error about config, tell user to run `awkit tg setup`

package/symphony/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AWKit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/symphony/README.md

@@ -0,0 +1,178 @@
+# 🎼 AWKit Symphony
+
+> Multi-Agent Orchestration for AI Coding Assistants
+
+Symphony coordinates multiple AI agents working on the same codebase — managing tasks, preventing file conflicts, and providing real-time visibility through a dashboard.
+
+## ✨ Features
+
+| Feature | Description |
+|---------|-------------|
+| **Task Management** | Create, assign, track tasks with priority & acceptance criteria |
+| **Git Isolation** | Auto worktree/clone per task — agents work on separate branches |
+| **File Locking** | Pessimistic locking prevents two agents from editing the same file |
+| **Merge Pipeline** | Auto-rebase + fast-forward merge when tasks complete |
+| **MCP Server** | 14 tools for IDE integration via Model Context Protocol |
+| **Dashboard** | Real-time Kanban board, agent status, events feed |
+| **Context Bus** | Event pub/sub — agents notify each other of changes |
+
+## 🚀 Quick Start
+
+```bash
+# Install
+cd symphony
+npm install
+
+# Start dashboard (port 3100)
+npm run dev
+
+# Or use CLI
+node cli/index.js status
+node cli/index.js task list
+```
+
+## 📋 CLI Commands
+
+```bash
+# System
+symphony status                        # Show system status
+symphony start                         # Start dashboard server
+symphony dashboard                     # Open dashboard in browser
+
+# Tasks
+symphony task list [-s ready]          # List tasks (filter by status)
+symphony task create "Feature X" -p 1  # Create task (priority 1-3)
+symphony task show <id>                # Show task details
+
+# Workspaces
+symphony workspace list                # List active workspaces
+symphony workspace create <task-id>    # Create workspace for task
+symphony workspace merge <task-id>     # Auto-merge completed task
+symphony workspace clean               # Remove merged workspaces
+
+# File Locks
+symphony lock list                     # Show active locks
+symphony lock release <file>           # Force-release stuck lock
+
+# MCP Server
+symphony mcp-serve [-n "Agent Name"]   # Start MCP server (stdio)
+```
+
+## 🔌 MCP Integration
+
+Add to your IDE's MCP config:
+
+```json
+{
+  "mcpServers": {
+    "symphony": {
+      "command": "node",
+      "args": ["/path/to/symphony/mcp/server.js"],
+      "env": {
+        "SYMPHONY_AGENT_NAME": "my-agent"
+      }
+    }
+  }
+}
+```
+
+### Available MCP Tools (14)
+
+| Tool | Description |
+|------|-------------|
+| `symphony_available_tasks` | List available tasks |
+| `symphony_claim_task` | Claim a task (get workspace + branch) |
+| `symphony_report_progress` | Report progress (0-100%) |
+| `symphony_complete_task` | Complete task + trigger merge |
+| `symphony_abandon_task` | Abandon a task |
+| `symphony_check_files` | Check file lock status |
+| `symphony_lock_files` | Lock files for editing |
+| `symphony_unlock_files` | Release file locks |
+| `symphony_broadcast` | Broadcast event to other agents |
+| `symphony_events` | Query context bus events |
+| `symphony_status` | Get system status |
+| `symphony_create_task` | Create a new task |
+| `symphony_workspace_status` | Get workspace info + diff stats |
+| `symphony_merge_task` | Run auto-merge pipeline |
+
+## 🏗️ Architecture
+
+```
+symphony/
+├── core/                    # Engine
+│   ├── db.js                # SQLite (WAL mode)
+│   ├── task-manager.js      # Task CRUD + state machine
+│   ├── workspace-manager.js # Git worktree lifecycle
+│   ├── merge-pipeline.js    # Auto-rebase + merge
+│   ├── file-lock-manager.js # Pessimistic file locking
+│   ├── context-bus.js       # Event pub/sub
+│   └── orchestrator.js      # Agent dispatch + state
+├── mcp/                     # MCP Server
+│   ├── server.js            # stdio transport
+│   ├── index.js             # Tool registry (14 tools)
+│   └── tools/               # Tool implementations
+├── cli/                     # CLI
+│   └── index.js             # Commander.js commands
+├── app/                     # Dashboard (Next.js)
+│   ├── page.js              # Kanban + status + events
+│   └── api/                 # REST API routes
+└── lib/
+    └── core.mjs             # ESM bridge for Turbopack
+```
+
+## ⚙️ Configuration
+
+Edit `symphony.config.js`:
+
+```js
+module.exports = {
+    port: 3100,
+    maxAgents: 3,
+    workspace: {
+        type: 'hybrid',       // 'worktree' | 'clone' | 'hybrid'
+        cloneThreshold: 30,   // files > 30 → full clone
+    },
+    git: {
+        autoMerge: true,
+        targetBranch: 'main',
+        branchPrefix: 'symphony/',
+    },
+    locks: {
+        strategy: 'pessimistic',
+        autoRelease: 3600,    // seconds
+    },
+};
+```
+
+## 📊 Dashboard
+
+The dashboard runs on `http://localhost:3100` and provides:
+
+- **Kanban Board** — Tasks by status (Ready → In Progress → Review → Done)
+- **Agent Panel** — Connected agents with live status
+- **Events Feed** — Real-time context bus events
+- **Lock Panel** — Active file locks with force-release
+- **Stats Bar** — Task counts and system health
+
+## 🔄 Task Lifecycle
+
+```
+Ready → Claimed → In Progress → Review → Done
+  │                                        │
+  └─── Abandoned ◀────────────────────────┘
+```
+
+1. **Create** task via CLI or dashboard
+2. **Agent claims** via MCP → gets isolated workspace + branch
+3. **Agent works** → reports progress, locks files, broadcasts events
+4. **Agent completes** → triggers auto-merge pipeline
+5. **Merge** → rebase onto main, fast-forward, cleanup workspace
+
+## 📦 Tech Stack
+
+- **Runtime:** Node.js
+- **Database:** SQLite (via better-sqlite3, WAL mode)
+- **Dashboard:** Next.js 16 + React 19
+- **MCP:** @modelcontextprotocol/sdk
+- **CLI:** Commander.js
+- **Git:** Native git commands (worktree, rebase, merge)

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;
+}