@leejungkiin/awkit 1.1.0 → 1.1.2

package/symphony/mcp/tools/workspace.js

@@ -0,0 +1,143 @@
+/**
+ * Symphony MCP Tools — Workspace Management
+ * 
+ * Tools for workspace/git operations:
+ * - symphony_workspace_status: Get workspace info + diff stats
+ * - symphony_merge_task: Trigger auto-merge pipeline
+ */
+const { z } = require('zod');
+const workspaceManager = require('../../core/workspace-manager');
+const mergePipeline = require('../../core/merge-pipeline');
+
+const tools = [];
+
+// ─── symphony_workspace_status ──────────────────────────────────────────────
+
+tools.push({
+    name: 'symphony_workspace_status',
+    description: 'Get workspace info for a task — branch, path, diff stats, and commit log.',
+    schema: {
+        task_id: z.string().describe('Task ID to check workspace for'),
+    },
+    handler: async ({ task_id }) => {
+        try {
+            const ws = workspaceManager.getWorkspace(task_id);
+
+            if (!ws) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            exists: false,
+                            message: `No active workspace for task ${task_id}`,
+                        }),
+                    }],
+                };
+            }
+
+            // Get repo path from workspace path
+            const path = require('path');
+            const repoPath = getRepoPath(ws.path);
+
+            const diff = mergePipeline.getDiff(task_id, repoPath);
+            const log = mergePipeline.getBranchLog(task_id, repoPath);
+            const conflicts = mergePipeline.checkConflicts(task_id, repoPath);
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        exists: true,
+                        workspace: {
+                            id: ws.id,
+                            path: ws.path,
+                            branch: ws.branch,
+                            type: ws.type,
+                            created_at: ws.created_at,
+                        },
+                        diff: {
+                            files: diff.files,
+                            insertions: diff.insertions,
+                            deletions: diff.deletions,
+                        },
+                        commits: log.length,
+                        commitLog: log.slice(0, 10),
+                        hasConflicts: conflicts.hasConflicts,
+                        conflictingFiles: conflicts.conflictingFiles,
+                    }),
+                }],
+            };
+        } catch (error) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }],
+                isError: true,
+            };
+        }
+    },
+});
+
+// ─── symphony_merge_task ────────────────────────────────────────────────────
+
+tools.push({
+    name: 'symphony_merge_task',
+    description: 'Run auto-merge pipeline for a completed task: rebase → merge → cleanup.',
+    schema: {
+        task_id: z.string().describe('Task ID to merge'),
+        repo_path: z.string().optional().describe('Repository path (auto-detected if omitted)'),
+    },
+    handler: async ({ task_id, repo_path }) => {
+        try {
+            const ws = workspaceManager.getWorkspace(task_id);
+            if (!ws) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            status: 'error',
+                            message: `No active workspace for task ${task_id}`,
+                        }),
+                    }],
+                    isError: true,
+                };
+            }
+
+            const repoPath = repo_path || getRepoPath(ws.path);
+            const result = mergePipeline.autoMerge(task_id, repoPath);
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify(result),
+                }],
+                isError: result.status === 'error',
+            };
+        } catch (error) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }],
+                isError: true,
+            };
+        }
+    },
+});
+
+// ─── Helper ─────────────────────────────────────────────────────────────────
+
+/**
+ * Derive the main repo path from a workspace path.
+ * Workspaces are typically in .symphony/workspaces/<task-id> relative to repo.
+ */
+function getRepoPath(wsPath) {
+    const path = require('path');
+    // Walk up from workspace to find .git
+    let current = path.dirname(wsPath);
+    for (let i = 0; i < 5; i++) {
+        const gitDir = path.join(current, '.git');
+        const fs = require('fs');
+        if (fs.existsSync(gitDir)) return current;
+        current = path.dirname(current);
+    }
+    // Fallback: assume workspace is in .symphony/workspaces/ under repo root
+    return path.resolve(wsPath, '..', '..', '..');
+}
+
+module.exports = tools;

package/symphony/next.config.mjs

@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // Allow requiring CommonJS core modules from API routes
+  serverExternalPackages: ['better-sqlite3'],
+};
+
+export default nextConfig;

package/symphony/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "awkit-symphony",
+  "version": "0.1.0",
+  "description": "Multi-Agent Orchestration for AI Coding Assistants — task management, git isolation, file locking, and real-time dashboard",
+  "keywords": [
+    "ai",
+    "multi-agent",
+    "orchestration",
+    "mcp",
+    "git",
+    "worktree",
+    "dashboard",
+    "coding-assistant"
+  ],
+  "license": "MIT",
+  "main": "core/orchestrator.js",
+  "bin": {
+    "symphony": "./cli/index.js"
+  },
+  "files": [
+    "core/",
+    "cli/",
+    "mcp/",
+    "lib/",
+    "app/",
+    "scripts/",
+    "symphony.config.js",
+    "next.config.mjs",
+    "jsconfig.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "dev": "next dev -p 3100",
+    "build": "next build",
+    "start": "next start -p 3100",
+    "postinstall": "node scripts/postinstall.js",
+    "cli": "node cli/index.js",
+    "mcp": "node mcp/server.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "better-sqlite3": "^12.6.2",
+    "commander": "^14.0.3",
+    "nanoid": "^3.3.11",
+    "next": "16.1.6",
+    "react": "19.2.3",
+    "react-dom": "19.2.3",
+    "zod": "^4.3.6"
+  }
+}

package/symphony/scripts/postinstall.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+/**
+ * Symphony Postinstall Script
+ * Automatically builds the Next.js dashboard after `npm install`.
+ * Skips build during development (when running from source directory).
+ */
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const ROOT = path.join(__dirname, '..');
+
+// Skip if .next/ already exists (already built)
+if (fs.existsSync(path.join(ROOT, '.next'))) {
+    console.log('✅ Symphony dashboard already built — skipping.');
+    process.exit(0);
+}
+
+// Skip if we're in a CI environment that doesn't need the dashboard
+if (process.env.CI || process.env.SYMPHONY_SKIP_BUILD) {
+    console.log('⏭️  Skipping Symphony build (CI or SYMPHONY_SKIP_BUILD set).');
+    process.exit(0);
+}
+
+console.log('');
+console.log('🎼 Symphony — Building dashboard...');
+console.log('   This only happens once after installation.');
+console.log('');
+
+try {
+    execSync('npx next build', {
+        cwd: ROOT,
+        stdio: 'inherit',
+        env: { ...process.env, NODE_ENV: 'production' },
+    });
+    console.log('');
+    console.log('✅ Symphony dashboard built successfully!');
+    console.log('   Run `symphony start` to launch.');
+    console.log('');
+} catch (err) {
+    console.error('');
+    console.error('⚠️  Symphony dashboard build failed.');
+    console.error('   You can manually build later with: symphony build');
+    console.error('   The CLI commands will still work without the dashboard.');
+    console.error('');
+    // Don't fail the install — CLI/MCP still work without dashboard
+    process.exit(0);
+}

package/symphony/symphony.config.js

@@ -0,0 +1,41 @@
+/**
+ * Symphony Configuration
+ * Default settings for the AWKit Symphony orchestration platform.
+ */
+module.exports = {
+    // Server
+    port: 3100,
+
+    // Concurrency
+    maxAgents: 3,
+
+    // Workspace
+    workspace: {
+        root: '.symphony/workspaces',
+        type: 'hybrid',       // 'worktree' | 'clone' | 'hybrid'
+        cloneThreshold: 30,   // files > 30 → full clone instead of worktree
+    },
+
+    // Git
+    git: {
+        autoMerge: true,
+        targetBranch: 'main',
+        branchPrefix: 'symphony/',
+    },
+
+    // File Locks
+    locks: {
+        strategy: 'pessimistic',
+        autoRelease: 3600,    // seconds — auto-release stuck locks
+    },
+
+    // Dashboard
+    dashboard: {
+        theme: 'dark',
+    },
+
+    // Database
+    db: {
+        path: null, // null = auto-detect (~/.symphony/symphony.db or .symphony/symphony.db)
+    },
+};

package/templates/conductor-tracks.md

@@ -0,0 +1,38 @@
+# 🎼 Strategic Tracks — Conductor Roadmap
+
+> This file is managed by the Conductor (Gemini CLI).
+> Antigravity IDE reads this for context. CLI writes strategic updates.
+
+---
+
+## Active Tracks
+
+### Track 1: [Track Name]
+- **Goal:** [What we're trying to achieve]
+- **Status:** 🔵 Planning | 🟢 In Progress | ✅ Done
+- **Milestones:**
+  - [ ] Milestone 1
+  - [ ] Milestone 2
+  - [ ] Milestone 3
+- **Key Decisions:**
+  - [Decision 1 — rationale]
+- **Notes:**
+  - [Any important context]
+
+---
+
+## Completed Tracks
+
+<!-- Move completed tracks here for reference -->
+
+---
+
+## Decision Log
+
+| Date | Decision | Rationale | Track |
+|------|----------|-----------|-------|
+| YYYY-MM-DD | ... | ... | #1 |
+
+---
+
+*Last updated by Conductor: [timestamp]*

package/templates/specs/PROJECT.md

@@ -0,0 +1,50 @@
+# {{PROJECT_NAME}} — Project Spec
+
+> Created: {{DATE}} | Last Updated: {{DATE}}
+
+## Vision
+
+[1-2 sentences describing the core purpose and value proposition of this project.]
+
+## Goals
+
+1. **Primary Goal:** [What is the #1 thing this project must achieve?]
+2. **Secondary Goal:** [What else matters?]
+3. **Stretch Goal:** [Nice-to-have if time permits]
+
+## Target Audience
+
+| Segment | Description | Pain Point |
+|---------|-------------|------------|
+| Primary | [Who is the main user?] | [What problem do they face?] |
+| Secondary | [Other user group] | [Their specific need] |
+
+## Success Metrics
+
+- [ ] **Metric 1:** [e.g., 1000 DAU within 3 months]
+- [ ] **Metric 2:** [e.g., 4.5+ App Store rating]
+- [ ] **Metric 3:** [e.g., < 2s cold start time]
+
+## Scope
+
+### In Scope (v1)
+- Feature A
+- Feature B
+- Feature C
+
+### Out of Scope (v1)
+- Feature X (deferred to v2)
+- Feature Y (requires further research)
+
+## Key Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| [e.g., Backend] | [e.g., Firebase] | [Why this choice] |
+| [e.g., State Mgmt] | [e.g., SwiftUI @Observable] | [Why] |
+
+## References
+
+- [Design inspiration link]
+- [Competitor analysis link]
+- [Technical reference]

package/templates/specs/ROADMAP.md

@@ -0,0 +1,79 @@
+# {{PROJECT_NAME}} — Roadmap
+
+> Created: {{DATE}} | Last Updated: {{DATE}}
+> Source of truth: PROJECT.md
+
+## Overview
+
+| Phase | Title | Status | Priority |
+|-------|-------|--------|----------|
+| 1 | [Phase title] | 🔲 Not Started | P0 |
+| 2 | [Phase title] | 🔲 Not Started | P1 |
+| 3 | [Phase title] | 🔲 Not Started | P2 |
+
+---
+
+## Phase 1: [Title] — [Target Date]
+
+**Goal:** [What this phase delivers in 1 sentence]
+
+**Requirements Covered:** REQUIREMENTS.md § R1, R2
+
+### Features
+- [ ] Feature 1.1 — [Short description]
+- [ ] Feature 1.2 — [Short description]
+- [ ] Feature 1.3 — [Short description]
+
+### Dependencies
+- [External service / API / library needed]
+
+### Definition of Done
+- [ ] All features functional
+- [ ] Core tests passing
+- [ ] No P0 bugs
+
+---
+
+## Phase 2: [Title] — [Target Date]
+
+**Goal:** [What this phase delivers]
+
+**Requirements Covered:** REQUIREMENTS.md § R3, R4
+
+### Features
+- [ ] Feature 2.1
+- [ ] Feature 2.2
+
+### Dependencies
+- Phase 1 complete
+
+### Definition of Done
+- [ ] All features functional
+- [ ] Integration tests passing
+
+---
+
+## Phase 3: [Title] — [Target Date]
+
+**Goal:** [What this phase delivers]
+
+**Requirements Covered:** REQUIREMENTS.md § R5+
+
+### Features
+- [ ] Feature 3.1
+- [ ] Feature 3.2
+
+### Definition of Done
+- [ ] All features functional
+- [ ] Performance benchmarks met
+- [ ] Ready for production release
+
+---
+
+## Milestone Tracking
+
+| Milestone | Target | Actual | Status |
+|-----------|--------|--------|--------|
+| MVP (Phase 1) | [Date] | — | 🔲 |
+| Beta (Phase 2) | [Date] | — | 🔲 |
+| Launch (Phase 3) | [Date] | — | 🔲 |

package/templates/specs/TECH-SPEC.md

@@ -0,0 +1,81 @@
+# {{PROJECT_NAME}} — Technical Specification
+
+> Created: {{DATE}} | Last Updated: {{DATE}}
+> Companion to: PROJECT.md, REQUIREMENTS.md
+
+## Architecture Overview
+
+[1-2 sentences describing the high-level architecture pattern being used.]
+
+```
+[Simple ASCII diagram of the system architecture]
+```
+
+## Tech Stack
+
+| Layer | Technology | Version | Rationale |
+|-------|-----------|---------|-----------|
+| Language | [e.g., Swift] | [e.g., 6.0] | [Why] |
+| Framework | [e.g., SwiftUI] | [e.g., iOS 17+] | [Why] |
+| Backend | [e.g., Firebase] | [e.g., v11] | [Why] |
+| Database | [e.g., GRDB] | [e.g., 7.x] | [Why] |
+| AI/ML | [e.g., Gemini 2.5] | — | [Why] |
+| Analytics | [e.g., Firebase Analytics] | — | [Why] |
+
+## Architecture Decisions
+
+### AD-1: [Decision Title]
+
+**Context:** [What problem or question prompted this decision?]
+**Decision:** [What was decided]
+**Consequences:** [What trade-offs or implications does this have?]
+**Alternatives Considered:** [What else was evaluated?]
+
+### AD-2: [Decision Title]
+
+**Context:** [...]  
+**Decision:** [...]  
+**Consequences:** [...]
+
+## Patterns & Conventions
+
+### Code Organization
+```
+[Folder structure with descriptions]
+```
+
+### Naming Conventions
+- Files: [e.g., PascalCase for types, camelCase for functions]
+- Modules: [e.g., feature-based grouping]
+- Tests: [e.g., Test suffix, describe/it pattern]
+
+### Error Handling
+[Standard error handling approach for the project]
+
+### State Management
+[How state is managed across the app]
+
+## Constraints & Non-Negotiables
+
+> [!CAUTION]
+> These constraints MUST be followed in ALL implementation plans.
+
+1. **[Constraint 1]:** [e.g., All network calls must have offline fallback]
+2. **[Constraint 2]:** [e.g., No hardcoded strings — use localization]
+3. **[Constraint 3]:** [e.g., All AI calls must respect quota limits]
+4. **[Constraint 4]:** [e.g., Minimum iOS 17 / Android 14 support]
+
+## Security Requirements
+
+- Authentication: [e.g., Firebase Auth with Apple/Google Sign-In]
+- Data at rest: [e.g., Keychain for sensitive data]
+- API keys: [e.g., Firebase Remote Config, never hardcoded]
+
+## Performance Targets
+
+| Metric | Target | How to Measure |
+|--------|--------|----------------|
+| Cold start | < [X]s | Instruments / Profiler |
+| API response | < [X]ms | Network logs |
+| Memory | < [X]MB | Memory profiler |
+| App size | < [X]MB | Archive build |

package/templates/specs/task-spec-template.xml

@@ -0,0 +1,65 @@
+<!-- 
+  AWF Task Spec Template (XML Format)
+  
+  Usage: Copy this structure into implementation_plan.md for each task.
+  AI parses these blocks precisely during EXECUTION mode.
+  
+  Attributes:
+    type="auto"   → AI executes without user interaction
+    type="manual" → Requires user action (e.g., config, credentials)
+    
+  Elements:
+    <name>       → Short task title
+    <files>      → Comma-separated list of files to create/modify
+    <spec_ref>   → Reference to REQUIREMENTS.md or TECH-SPEC.md section
+    <depends_on> → Task names this depends on (for wave grouping)
+    <action>     → Specific implementation instructions
+    <verify>     → Command or check to verify task completion
+    <done>       → Expected final state description
+-->
+
+<!-- Example: Single independent task -->
+<task type="auto">
+  <name>Create User model</name>
+  <files>Models/User.swift, Models/UserRepository.swift</files>
+  <spec_ref>REQUIREMENTS.md § R1, TECH-SPEC.md § AD-1</spec_ref>
+  <depends_on>none</depends_on>
+  <action>
+    Create User struct with Codable conformance.
+    Implement UserRepository with GRDB persistence.
+    Follow offline-first pattern from TECH-SPEC.md.
+  </action>
+  <verify>Unit test: UserRepositoryTests — insert, fetch, delete pass</verify>
+  <done>User model persists to local DB with full CRUD</done>
+</task>
+
+<!-- Example: Dependent task -->
+<task type="auto">
+  <name>Create login endpoint</name>
+  <files>Services/AuthService.swift, ViewModels/LoginViewModel.swift</files>
+  <spec_ref>REQUIREMENTS.md § R2</spec_ref>
+  <depends_on>Create User model</depends_on>
+  <action>
+    Use Firebase Auth for authentication.
+    Store session in Keychain per TECH-SPEC.md § Security.
+    Handle offline: queue login attempt, retry on connectivity.
+  </action>
+  <verify>Login with test credentials returns valid session token</verify>
+  <done>User can log in; session persists across app restarts</done>
+</task>
+
+<!-- Example: Manual task -->
+<task type="manual">
+  <name>Configure Firebase project</name>
+  <files>GoogleService-Info.plist</files>
+  <spec_ref>TECH-SPEC.md § Tech Stack</spec_ref>
+  <depends_on>none</depends_on>
+  <action>
+    User must:
+    1. Create Firebase project at console.firebase.google.com
+    2. Download GoogleService-Info.plist
+    3. Add to Xcode project root
+  </action>
+  <verify>FirebaseApp.configure() succeeds without crash</verify>
+  <done>Firebase SDK initialized on app launch</done>
+</task>

package/templates/workflow_dual_mode_template.md

@@ -34,7 +34,7 @@ description: [Short description of the workflow]
 ### Phase 1: Context & Setup
 1. **Understand Intent:**
    - "Bạn muốn làm gì với [Command]?"
-   - (AI analyzes context from `.project-identity` & `.beads`)
+   - (AI analyzes context from `.project-identity` & `.symphony`)
 
 2. **Configuration:**
    - [Question 1]
@@ -68,7 +68,7 @@ description: [Short description of the workflow]
    - Locations of artifacts.
 
 2. **Memory Sync:**
-   - Auto-sync with Beads (Task) & Brain (Knowledge).
+   - Auto-sync with Symphony (Task) & Brain (Knowledge).
 
 3. **Next Steps Menu:**
    ```markdown
@@ -79,9 +79,9 @@ description: [Short description of the workflow]
 
 ---
 
-## 🧠 Brain & Beads Integration
+## 🧠 Brain & Symphony Integration
 
-- **Input:** Check `bd list --status in_progress` to resume context.
+- **Input:** Check `symphony_available_tasks(filter="my")` to resume context.
 - **Output:**
-  - Create/Update Beads task.
+  - Create/Update Symphony task.
   - Create Brain memory file if knowledge is valuable.

package/workflows/_uncategorized/AGENTS.md

@@ -0,0 +1,38 @@
+# Agent Instructions
+
+This project uses **Symphony** for task management and issue tracking.
+
+## Quick Reference
+
+```bash
+symphony_available_tasks          # Find available work
+symphony_claim_task <id>          # Claim a task
+symphony_report_progress <id>     # Report progress
+symphony_complete_task <id>       # Complete work
+symphony_status                   # Check system status
+```
+
+## Landing the Plane (Session Completion)
+
+**When ending a work session**, you MUST complete ALL steps below. Work is NOT complete until `git push` succeeds.
+
+**MANDATORY WORKFLOW:**
+
+1. **File issues for remaining work** — Create tasks for anything that needs follow-up
+2. **Run quality gates** (if code changed) — Tests, linters, builds
+3. **Update task status** — Complete finished work, update in-progress items
+4. **PUSH TO REMOTE** — This is MANDATORY:
+   ```bash
+   git pull --rebase
+   git push
+   git status  # MUST show "up to date with origin"
+   ```
+5. **Clean up** — Clear stashes, prune remote branches
+6. **Verify** — All changes committed AND pushed
+7. **Hand off** — Provide context for next session
+
+**CRITICAL RULES:**
+- Work is NOT complete until `git push` succeeds
+- NEVER stop before pushing — that leaves work stranded locally
+- NEVER say "ready to push when you are" — YOU must push
+- If push fails, resolve and retry until it succeeds