@ng-annotate/vite-plugin 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export default ngAnnotateMcp;
+export declare function ngAnnotateMcp(): Plugin[];

package/dist/index.js

@@ -0,0 +1,14 @@
+import { createWsHandler } from './ws-handler.js';
+import { createManifestPlugin } from './manifest.js';
+// Default export for Angular's angular.json `plugins` option — Angular calls it as a function.
+export default ngAnnotateMcp;
+export function ngAnnotateMcp() {
+    const mainPlugin = {
+        name: 'ng-annotate-mcp',
+        apply: 'serve',
+        configureServer(server) {
+            createWsHandler(server);
+        },
+    };
+    return [mainPlugin, createManifestPlugin()];
+}

package/dist/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vite';
+export interface ManifestEntry {
+    component: string;
+    template?: string;
+}
+export declare function createManifestPlugin(): Plugin;

package/dist/manifest.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+export function createManifestPlugin() {
+    const manifest = {};
+    let projectRoot = '';
+    return {
+        name: 'ng-annotate-mcp:manifest',
+        configResolved(config) {
+            projectRoot = config.root;
+        },
+        transform(code, id) {
+            if (!id.endsWith('.ts') || !code.includes('@Component'))
+                return null;
+            // Extract class name
+            const classMatch = /export\s+class\s+(\w+)/.exec(code);
+            if (!classMatch)
+                return null;
+            const className = classMatch[1];
+            // Compute relative path from project root
+            const relPath = path.relative(projectRoot, id).replace(/\\/g, '/');
+            // Extract templateUrl if present
+            const templateMatch = /templateUrl\s*:\s*['"`]([^'"`]+)['"`]/.exec(code);
+            const entry = { component: relPath };
+            if (templateMatch) {
+                const templateAbsPath = path.resolve(path.dirname(id), templateMatch[1]);
+                entry.template = path.relative(projectRoot, templateAbsPath).replace(/\\/g, '/');
+            }
+            manifest[className] = entry;
+            return null;
+        },
+        transformIndexHtml(html) {
+            const scriptTag = `<script>window.__NG_ANNOTATE_MANIFEST__ = ${JSON.stringify(manifest)};</script>`;
+            return html.replace('</head>', `  ${scriptTag}\n</head>`);
+        },
+    };
+}

package/dist/store.d.ts

@@ -0,0 +1,47 @@
+export type AnnotationStatus = 'pending' | 'acknowledged' | 'resolved' | 'dismissed';
+export interface Session {
+    id: string;
+    createdAt: string;
+    lastSeenAt: string;
+    active: boolean;
+    url: string;
+}
+export interface AnnotationReply {
+    id: string;
+    createdAt: string;
+    author: 'agent' | 'user';
+    message: string;
+}
+export interface Annotation {
+    id: string;
+    sessionId: string;
+    createdAt: string;
+    status: AnnotationStatus;
+    replies: AnnotationReply[];
+    componentName: string;
+    componentFilePath: string;
+    templateFilePath?: string;
+    selector: string;
+    inputs: Record<string, unknown>;
+    domSnapshot: string;
+    componentTreePath: string[];
+    annotationText: string;
+    selectionText?: string;
+}
+export declare const STORE_DIR = ".ng-annotate";
+export declare const STORE_PATH: string;
+export declare function ensureStore(): void;
+type WatcherFn = (annotation: Annotation) => void;
+export declare function addWatcher(fn: WatcherFn): () => void;
+export declare const store: {
+    createSession(payload: Omit<Session, "id" | "createdAt" | "lastSeenAt">): Promise<Session>;
+    updateSession(id: string, patch: Partial<Session>): Promise<Session | undefined>;
+    listSessions(): Promise<Session[]>;
+    getSession(id: string): Promise<Session | undefined>;
+    createAnnotation(payload: Omit<Annotation, "id" | "createdAt" | "status" | "replies">): Promise<Annotation>;
+    getAnnotation(id: string): Promise<Annotation | undefined>;
+    listAnnotations(sessionId?: string, status?: AnnotationStatus): Promise<Annotation[]>;
+    updateAnnotation(id: string, patch: Partial<Annotation>): Promise<Annotation | undefined>;
+    addReply(annotationId: string, reply: Omit<AnnotationReply, "id" | "createdAt">): Promise<Annotation | undefined>;
+};
+export {};

package/dist/store.js

@@ -0,0 +1,146 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { v4 as uuidv4 } from 'uuid';
+const EMPTY_STORE = { sessions: {}, annotations: {} };
+// ─── File paths ───────────────────────────────────────────────────────────────
+export const STORE_DIR = '.ng-annotate';
+export const STORE_PATH = path.join(process.cwd(), STORE_DIR, 'store.json');
+// ─── Store init ───────────────────────────────────────────────────────────────
+export function ensureStore() {
+    const dir = path.join(process.cwd(), STORE_DIR);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(STORE_PATH)) {
+        fs.writeFileSync(STORE_PATH, JSON.stringify(EMPTY_STORE, null, 2), 'utf8');
+    }
+}
+// ─── File locking ─────────────────────────────────────────────────────────────
+// In-process mutex: serializes all writes from the same process using a promise chain.
+// writeQueue always resolves (never rejects) so the chain is never broken by a
+// failing task. The Promise returned to the caller still rejects on error.
+// Note: cross-process safety (Vite plugin + MCP server) can be layered on top
+// via proper-lockfile if needed, but requires a platform-reliable approach.
+let writeQueue = Promise.resolve();
+async function withLock(fn) {
+    ensureStore();
+    const result = writeQueue.then(async () => {
+        const raw = fs.readFileSync(STORE_PATH, 'utf8');
+        const data = JSON.parse(raw);
+        const updated = await fn(data);
+        fs.writeFileSync(STORE_PATH, JSON.stringify(updated, null, 2), 'utf8');
+        return updated;
+    });
+    // Keep the queue alive even when this task fails
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    writeQueue = result.catch(() => { });
+    return result;
+}
+function readStore() {
+    ensureStore();
+    return JSON.parse(fs.readFileSync(STORE_PATH, 'utf8'));
+}
+const watchers = new Set();
+export function addWatcher(fn) {
+    watchers.add(fn);
+    return () => watchers.delete(fn);
+}
+function notifyWatchers(annotation) {
+    for (const fn of watchers)
+        fn(annotation);
+}
+// ─── Store API ────────────────────────────────────────────────────────────────
+export const store = {
+    async createSession(payload) {
+        const now = new Date().toISOString();
+        const session = {
+            id: uuidv4(),
+            createdAt: now,
+            lastSeenAt: now,
+            ...payload,
+        };
+        await withLock((data) => {
+            data.sessions[session.id] = session;
+            return data;
+        });
+        return session;
+    },
+    async updateSession(id, patch) {
+        let result;
+        await withLock((data) => {
+            const existing = data.sessions[id];
+            if (!existing)
+                return data;
+            const updated = { ...existing, ...patch, id };
+            data.sessions[id] = updated;
+            result = updated;
+            return data;
+        });
+        return result;
+    },
+    listSessions() {
+        const data = readStore();
+        return Promise.resolve(Object.values(data.sessions).filter((s) => s !== undefined));
+    },
+    getSession(id) {
+        const data = readStore();
+        return Promise.resolve(data.sessions[id]);
+    },
+    async createAnnotation(payload) {
+        const annotation = {
+            id: uuidv4(),
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+            replies: [],
+            ...payload,
+        };
+        await withLock((data) => {
+            data.annotations[annotation.id] = annotation;
+            return data;
+        });
+        notifyWatchers(annotation);
+        return annotation;
+    },
+    getAnnotation(id) {
+        const data = readStore();
+        return Promise.resolve(data.annotations[id]);
+    },
+    listAnnotations(sessionId, status) {
+        const data = readStore();
+        let list = Object.values(data.annotations).filter((a) => a !== undefined);
+        if (sessionId)
+            list = list.filter((a) => a.sessionId === sessionId);
+        if (status)
+            list = list.filter((a) => a.status === status);
+        return Promise.resolve(list.sort((a, b) => a.createdAt.localeCompare(b.createdAt)));
+    },
+    async updateAnnotation(id, patch) {
+        let result;
+        await withLock((data) => {
+            const existing = data.annotations[id];
+            if (!existing)
+                return data;
+            const updated = { ...existing, ...patch, id };
+            data.annotations[id] = updated;
+            result = updated;
+            return data;
+        });
+        return result;
+    },
+    async addReply(annotationId, reply) {
+        let result;
+        await withLock((data) => {
+            const annotation = data.annotations[annotationId];
+            if (!annotation)
+                return data;
+            const newReply = {
+                id: uuidv4(),
+                createdAt: new Date().toISOString(),
+                ...reply,
+            };
+            annotation.replies.push(newReply);
+            result = annotation;
+            return data;
+        });
+        return result;
+    },
+};

package/dist/ws-handler.d.ts

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from 'vite';
+export declare function createWsHandler(server: ViteDevServer): void;

package/dist/ws-handler.js

@@ -0,0 +1,71 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { store } from './store.js';
+const WS_PATH = '/__annotate';
+const SYNC_INTERVAL_MS = 2000;
+export function createWsHandler(server) {
+    const wss = new WebSocketServer({ noServer: true });
+    const sessionSockets = new Map();
+    // Upgrade only /__annotate connections
+    server.httpServer?.on('upgrade', (req, socket, head) => {
+        const url = req.url ?? '';
+        if (!url.startsWith(WS_PATH))
+            return;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit('connection', ws, req);
+        });
+    });
+    wss.on('connection', (ws, req) => {
+        void (async () => {
+            const referer = req.headers.referer ?? req.headers.origin ?? '';
+            const session = await store.createSession({ active: true, url: referer });
+            const sessionId = session.id;
+            ws.send(JSON.stringify({ type: 'session:created', session }));
+            sessionSockets.set(sessionId, ws);
+            ws.on('message', (raw) => {
+                void (async () => {
+                    let msg;
+                    try {
+                        msg = JSON.parse(raw.toString());
+                    }
+                    catch {
+                        return;
+                    }
+                    if (msg.type === 'annotation:create') {
+                        const annotation = await store.createAnnotation({
+                            ...msg.payload,
+                            sessionId,
+                        });
+                        ws.send(JSON.stringify({ type: 'annotation:created', annotation }));
+                    }
+                    else if (msg.type === 'annotation:reply') {
+                        const annotation = await store.addReply(msg.id, { author: 'user', message: msg.message });
+                        if (annotation) {
+                            ws.send(JSON.stringify({ type: 'annotation:updated', annotation }));
+                        }
+                    }
+                    else {
+                        const annotation = await store.updateAnnotation(msg.id, { status: 'dismissed' });
+                        if (annotation) {
+                            ws.send(JSON.stringify({ type: 'annotation:updated', annotation }));
+                        }
+                    }
+                })();
+            });
+            ws.on('close', () => {
+                void store.updateSession(sessionId, { active: false });
+                sessionSockets.delete(sessionId);
+            });
+        })();
+    });
+    // Sync annotation status updates back to browsers every 2s
+    setInterval(() => {
+        void (async () => {
+            for (const [sessionId, ws] of sessionSockets) {
+                if (ws.readyState !== WebSocket.OPEN)
+                    continue;
+                const annotations = await store.listAnnotations(sessionId);
+                ws.send(JSON.stringify({ type: 'annotations:sync', annotations }));
+            }
+        })();
+    }, SYNC_INTERVAL_MS);
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ng-annotate/vite-plugin",
+  "version": "0.2.1",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yngvebn/ngagentify"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix"
+  },
+  "peerDependencies": {
+    "vite": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.2",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.18.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "~5.6.0",
+    "vite": "^5.0.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "proper-lockfile": "^4.1.2",
+    "uuid": "^13.0.0",
+    "ws": "^8.19.0"
+  }
+}