gru-ai 0.1.0

package/dist-server/server/watchers/state-watcher.d.ts

@@ -0,0 +1,36 @@
+import type { Aggregator } from '../state/aggregator.js';
+import type { ConductorConfig } from '../types.js';
+import type { FullWorkState } from '../state/work-item-types.js';
+/**
+ * Watches .context/ source files (directive.json, project.json,
+ * reports, lessons) and builds FullWorkState directly.
+ *
+ * Replaces the old two-stage pipeline (ContextWatcher -> indexer -> state/*.json -> StateWatcher).
+ * Now reads source files directly via glob patterns.
+ */
+export declare class StateWatcher {
+    private watchers;
+    private aggregator;
+    private config;
+    private debounceTimer;
+    private _ready;
+    private _state;
+    constructor(aggregator: Aggregator, config: ConductorConfig);
+    start(): void;
+    get ready(): boolean;
+    stop(): Promise<void>;
+    readCurrentState(): FullWorkState;
+    /** Force a re-read of all source files */
+    refresh(): void;
+    private handleChange;
+    private readAndUpdate;
+    private mapProjectStatus;
+    private mapDirectiveStatus;
+    private mapBacklogStatus;
+    private mapPriority;
+    private readJson;
+    private listDirs;
+    private listFiles;
+    private extractFirstHeading;
+    private fileMtime;
+}

package/dist-server/server/watchers/state-watcher.js

@@ -0,0 +1,369 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { watch } from 'chokidar';
+/**
+ * Watches .context/ source files (directive.json, project.json,
+ * reports, lessons) and builds FullWorkState directly.
+ *
+ * Replaces the old two-stage pipeline (ContextWatcher -> indexer -> state/*.json -> StateWatcher).
+ * Now reads source files directly via glob patterns.
+ */
+export class StateWatcher {
+    watchers = [];
+    aggregator;
+    config;
+    debounceTimer = null;
+    _ready = false;
+    _state = {
+        features: null,
+        backlogs: null,
+        conductor: null,
+        index: null,
+    };
+    constructor(aggregator, config) {
+        this.aggregator = aggregator;
+        this.config = config;
+    }
+    start() {
+        if (this.config.projects.length === 0) {
+            console.log('[state-watcher] No projects configured, skipping');
+            this._ready = true;
+            return;
+        }
+        // Read initial state
+        this.readAndUpdate();
+        for (const project of this.config.projects) {
+            const contextDir = path.join(project.path, '.context');
+            if (!fs.existsSync(contextDir)) {
+                console.log(`[state-watcher] No .context/ dir for ${project.name}, skipping`);
+                continue;
+            }
+            console.log(`[state-watcher] Watching ${contextDir} (${project.name})`);
+            const watcher = watch(contextDir, {
+                ignoreInitial: true,
+                persistent: true,
+                ignored: [
+                    '**/node_modules/**',
+                    // Ignore checkpoints dir to avoid feedback loops
+                    path.join(contextDir, 'directives', 'checkpoints', '**'),
+                ],
+                awaitWriteFinish: {
+                    stabilityThreshold: 300,
+                    pollInterval: 50,
+                },
+                depth: 5,
+            });
+            watcher.on('all', (_event, filePath) => {
+                if (!filePath.endsWith('.json') && !filePath.endsWith('.md'))
+                    return;
+                this.handleChange();
+            });
+            watcher.on('ready', () => {
+                console.log(`[state-watcher] Ready for ${project.name}`);
+            });
+            watcher.on('error', (err) => {
+                console.error(`[state-watcher] Error for ${project.name}:`, err);
+            });
+            this.watchers.push(watcher);
+        }
+        this._ready = true;
+    }
+    get ready() {
+        return this._ready;
+    }
+    async stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        for (const watcher of this.watchers) {
+            await watcher.close();
+        }
+        this.watchers = [];
+    }
+    readCurrentState() {
+        return this._state;
+    }
+    /** Force a re-read of all source files */
+    refresh() {
+        this.readAndUpdate();
+    }
+    handleChange() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.readAndUpdate();
+        }, 500);
+    }
+    readAndUpdate() {
+        const state = {
+            features: null,
+            backlogs: null,
+            conductor: null,
+            index: null,
+        };
+        const generated = new Date().toISOString();
+        const allProjects = [];
+        const allBacklog = [];
+        const allDirectives = [];
+        const allReports = [];
+        const allLessons = [];
+        for (const project of this.config.projects) {
+            const contextDir = path.join(project.path, '.context');
+            if (!fs.existsSync(contextDir))
+                continue;
+            // Derive repoId from the project path (last directory component, lowercased)
+            const repoId = path.basename(project.path).toLowerCase();
+            const repoName = project.name;
+            // --- Directives (directory format: {id}/directive.json) ---
+            const directivesDir = path.join(contextDir, 'directives');
+            if (fs.existsSync(directivesDir)) {
+                const directiveDirs = this.listDirs(directivesDir);
+                for (const dirId of directiveDirs) {
+                    const filePath = path.join(directivesDir, dirId, 'directive.json');
+                    const dirJson = this.readJson(filePath);
+                    if (!dirJson)
+                        continue;
+                    const dirStatus = this.mapDirectiveStatus(String(dirJson.status ?? 'pending'));
+                    const category = dirJson.category ? String(dirJson.category) : undefined;
+                    allDirectives.push({
+                        id: dirId,
+                        type: 'directive',
+                        title: String(dirJson.title ?? dirId),
+                        status: dirStatus,
+                        createdAt: String(dirJson.created ?? generated),
+                        updatedAt: String(dirJson.updated ?? dirJson.created ?? generated),
+                        projects: [],
+                        weight: dirJson.weight ? String(dirJson.weight) : undefined,
+                        category,
+                        producedFeatures: Array.isArray(dirJson.produced_features) ? dirJson.produced_features.map(String) : undefined,
+                        report: dirJson.report != null ? String(dirJson.report) : null,
+                        backlogSources: Array.isArray(dirJson.backlog_sources) ? dirJson.backlog_sources.map(String) : undefined,
+                    });
+                    // --- Projects under this directive ---
+                    const projectsDir = path.join(directivesDir, dirId, 'projects');
+                    if (fs.existsSync(projectsDir)) {
+                        const projectIds = this.listDirs(projectsDir);
+                        for (const projId of projectIds) {
+                            const projJsonPath = path.join(projectsDir, projId, 'project.json');
+                            const projJson = this.readJson(projJsonPath);
+                            if (!projJson)
+                                continue;
+                            const tasks = Array.isArray(projJson.tasks) ? projJson.tasks : [];
+                            const taskCount = tasks.length;
+                            const completedTaskCount = tasks.filter((t) => t.status === 'completed' || t.status === 'done').length;
+                            const projStatus = this.mapProjectStatus(String(projJson.status ?? 'pending'));
+                            const featureId = `${dirId}/${projId}`;
+                            const record = {
+                                id: featureId,
+                                type: 'feature',
+                                title: String(projJson.title ?? projId),
+                                status: projStatus,
+                                category,
+                                createdAt: String(projJson.created ?? generated),
+                                updatedAt: String(projJson.updated ?? generated),
+                                taskCount,
+                                completedTaskCount,
+                                hasSpec: false,
+                                hasDesign: false,
+                                specSummary: projJson.description
+                                    ? String(projJson.description).slice(0, 200)
+                                    : undefined,
+                                repoId,
+                                repoName,
+                            };
+                            allProjects.push(record);
+                        }
+                    }
+                }
+            }
+            // --- Reports ---
+            const reportsDir = path.join(contextDir, 'reports');
+            if (fs.existsSync(reportsDir)) {
+                const mdFiles = this.listFiles(reportsDir, '.md');
+                for (const file of mdFiles) {
+                    const filePath = path.join(reportsDir, file);
+                    const title = this.extractFirstHeading(filePath) || file.replace('.md', '');
+                    const mtime = this.fileMtime(filePath);
+                    const directiveMatch = file.match(/^(.+?)(?:-v\d+)?-\d{4}-\d{2}-\d{2}\.md$/);
+                    const sourceDirective = directiveMatch ? directiveMatch[1] : undefined;
+                    allReports.push({
+                        id: `report/${file.replace('.md', '')}`,
+                        type: 'report',
+                        title,
+                        status: 'done',
+                        createdAt: mtime,
+                        updatedAt: mtime,
+                        filePath: `reports/${file}`,
+                        sourceDirective,
+                    });
+                }
+            }
+            // --- Lessons ---
+            const lessonsDir = path.join(contextDir, 'lessons');
+            if (fs.existsSync(lessonsDir)) {
+                const mdFiles = this.listFiles(lessonsDir, '.md');
+                for (const file of mdFiles) {
+                    const filePath = path.join(lessonsDir, file);
+                    const title = this.extractFirstHeading(filePath) || file.replace('.md', '');
+                    const lessonId = file.replace('.md', '');
+                    allLessons.push({
+                        id: lessonId,
+                        title,
+                        filePath: `lessons/${file}`,
+                        topics: [lessonId],
+                        updatedAt: this.fileMtime(filePath),
+                    });
+                }
+            }
+        }
+        // Build state objects
+        state.features = { generated, features: allProjects };
+        state.backlogs = { generated, items: allBacklog };
+        state.conductor = {
+            generated,
+            directives: allDirectives,
+            reports: allReports,
+            discussions: [],
+            research: [],
+            lessons: allLessons,
+        };
+        state.index = {
+            generated,
+            counts: {
+                activeFeatures: allProjects.filter((f) => f.status !== 'completed').length,
+                doneFeatures: allProjects.filter((f) => f.status === 'completed').length,
+                pendingTasks: 0, // TODO: aggregate from project tasks
+                completedTasks: 0,
+                backlogItems: allBacklog.filter((b) => b.status !== 'completed').length,
+                directives: allDirectives.length,
+                reports: allReports.length,
+                discussions: 0,
+                lessons: allLessons.length,
+            },
+        };
+        this._state = state;
+        const projectCount = allProjects.length;
+        const backlogCount = allBacklog.length;
+        const directiveCount = allDirectives.length;
+        console.log(`[state-watcher] Direct read: ${projectCount} projects, ${backlogCount} backlog items, ${directiveCount} directives`);
+        this.aggregator.updateWorkState(state);
+    }
+    // --- Status Mappers ---
+    mapProjectStatus(status) {
+        switch (status) {
+            case 'in_progress': return 'in_progress';
+            case 'active': return 'in_progress'; // legacy
+            case 'pending': return 'pending';
+            case 'proposed': return 'pending';
+            case 'completed': return 'completed';
+            case 'blocked': return 'blocked';
+            case 'deferred': return 'deferred';
+            case 'abandoned': return 'abandoned';
+            default: return 'pending';
+        }
+    }
+    mapDirectiveStatus(status) {
+        switch (status) {
+            case 'pending': return 'pending';
+            case 'triaged': return 'pending';
+            case 'in_progress': return 'in_progress';
+            case 'executing': return 'in_progress'; // legacy
+            case 'awaiting_completion': return 'in_progress';
+            case 'completed': return 'completed';
+            case 'cancelled': return 'abandoned';
+            case 'rejected': return 'abandoned';
+            default: return 'pending';
+        }
+    }
+    mapBacklogStatus(status) {
+        switch (status) {
+            case 'pending': return 'pending';
+            case 'proposed': return 'pending';
+            case 'approved': return 'pending';
+            case 'promoted': return 'completed';
+            case 'in_progress': return 'in_progress';
+            case 'completed': return 'completed';
+            case 'deferred': return 'deferred';
+            case 'blocked': return 'blocked';
+            case 'rejected': return 'abandoned';
+            default: return 'pending';
+        }
+    }
+    mapPriority(p) {
+        const s = String(p ?? '').toUpperCase();
+        if (s === 'P0')
+            return 'P0';
+        if (s === 'P1')
+            return 'P1';
+        if (s === 'P2')
+            return 'P2';
+        return undefined;
+    }
+    // --- File Helpers ---
+    readJson(filePath) {
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    listDirs(dirPath) {
+        try {
+            return fs.readdirSync(dirPath).filter((name) => {
+                if (name.startsWith('.') || name.startsWith('_'))
+                    return false;
+                try {
+                    return fs.statSync(path.join(dirPath, name)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    listFiles(dirPath, ext) {
+        try {
+            return fs.readdirSync(dirPath).filter((name) => {
+                if (name.startsWith('.'))
+                    return false;
+                if (ext && !name.endsWith(ext))
+                    return false;
+                try {
+                    return fs.statSync(path.join(dirPath, name)).isFile();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    extractFirstHeading(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const match = content.match(/^#\s+(.+)/m);
+            return match ? match[1].trim() : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    fileMtime(filePath) {
+        try {
+            return fs.statSync(filePath).mtime.toISOString().split('T')[0];
+        }
+        catch {
+            return new Date().toISOString().split('T')[0];
+        }
+    }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "gru-ai",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist/",
+    "dist-server/",
+    "cli/templates/",
+    ".claude/skills/",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "concurrently \"tsx watch server/index.ts\" \"vite\"",
+    "dev:server": "tsx watch server/index.ts",
+    "dev:client": "vite",
+    "build:client": "vite build",
+    "build:server": "tsc -p server/tsconfig.json",
+    "build": "npm run build:client && npm run build:server",
+    "prepublishOnly": "npm run build",
+    "start": "node dist-server/server/index.js",
+    "lint": "eslint .",
+    "type-check": "tsc --noEmit",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-scroll-area": "^1.2.10",
+    "@radix-ui/react-slot": "^1.2.4",
+    "@tanstack/react-virtual": "^3.13.18",
+    "better-sqlite3": "^12.6.2",
+    "chokidar": "^5.0.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "concurrently": "^9.2.1",
+    "lucide-react": "^0.575.0",
+    "radix-ui": "^1.4.3",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-router-dom": "^7.13.0",
+    "tailwind-merge": "^3.5.0",
+    "ws": "^8.19.0",
+    "zustand": "^5.0.11"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@tailwindcss/vite": "^4.2.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^5.1.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "pngjs": "^7.0.0",
+    "tailwindcss": "^4.2.0",
+    "tsx": "^4.21.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.48.0",
+    "vite": "^7.3.1"
+  }
+}