@archznn/crewloop-skills 0.2.0 → 0.4.0

package/servers/dashboard/src/presenter.ts

@@ -0,0 +1,56 @@
+import type { Session, DashboardState, ClientSession, ClientEvent, ClientWebSocketMessage } from './types';
+
+export function presentEvent(event: Session['events'][number]): ClientEvent {
+  return {
+    id: event.id,
+    timestamp: event.timestamp,
+    event_type: event.event_type,
+    tool: event.tool,
+    detail: event.detail,
+    status: event.status,
+    duration_ms: event.duration_ms,
+    skill: event.skill,
+  };
+}
+
+export function presentSession(session: Session): ClientSession {
+  return {
+    id: session.id,
+    source: session.source,
+    skill: session.active_skill,
+    activeSkill:
+      session.active_skill
+        ? {
+            name: session.active_skill,
+            confidence: session.active_confidence || 'unknown',
+          }
+        : undefined,
+    status: session.status,
+    events: session.events.map(presentEvent),
+    startTime: session.started_at,
+    lastActivity: session.last_event_at,
+    toolCounts: session.tool_counts,
+  };
+}
+
+export function presentState(state: DashboardState): ClientSession[] {
+  return Object.values(state.sessions).map(presentSession);
+}
+
+export function createSnapshotMessage(sessions: Session[]): ClientWebSocketMessage {
+  return {
+    type: 'snapshot',
+    sessions: sessions.map(presentSession),
+  };
+}
+
+export function createUpdateMessage(
+  session: Session,
+  activeSessionId?: string
+): ClientWebSocketMessage {
+  return {
+    type: 'update',
+    session: presentSession(session),
+    isActive: activeSessionId === session.id,
+  };
+}

package/servers/dashboard/src/server.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import WebSocket from 'ws';
+import { createDashboardServer } from './server';
+import type { ServerConfig } from './types';
+
+function httpGetStatus(port: number, path: string): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const req = http.get({ hostname: '127.0.0.1', port, path }, (res) => {
+      resolve(res.statusCode || 0);
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function getFreePort(): Promise<number> {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      server.close(() => resolve(port));
+    });
+  });
+}
+
+function makeConfig(port: number, packageRoot: string): ServerConfig {
+  return {
+    port,
+    host: '127.0.0.1',
+    packageRoot,
+    maxEventsPerSession: 100,
+    sessionMaxAgeMs: 60000,
+    pruneIntervalMs: 60000,
+  };
+}
+
+describe('DashboardServer', () => {
+  let server: ReturnType<typeof createDashboardServer>;
+  let port: number;
+
+  before(async () => {
+    port = await getFreePort();
+    server = createDashboardServer(makeConfig(port, process.cwd()));
+    await server.start();
+  });
+
+  after(async () => {
+    await server.stop();
+  });
+
+  it('serves index.html', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/`);
+    assert.equal(res.status, 200);
+    const text = await res.text();
+    assert.ok(text.includes('<html'));
+  });
+
+  it('accepts POST /event and broadcasts via WebSocket', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+    const snapshot = await new Promise<unknown>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('WebSocket timeout')), 2000);
+      ws.once('message', (data) => {
+        clearTimeout(timer);
+        resolve(JSON.parse(data.toString()));
+      });
+    });
+
+    assert.equal((snapshot as { type: string }).type, 'snapshot');
+
+    const updatePromise = new Promise<unknown>((resolve) => {
+      ws.on('message', (data) => {
+        const message = JSON.parse(data.toString());
+        if (message.type === 'update') {
+          resolve(message);
+        }
+      });
+    });
+
+    const res = await fetch(`http://127.0.0.1:${port}/event`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        id: 'ev-1',
+        timestamp: Date.now(),
+        source: 'kimi',
+        session_id: 'sess-1',
+        event_type: 'tool_start',
+        tool: 'Read',
+      }),
+    });
+    assert.equal(res.status, 200);
+
+    const update = await updatePromise;
+    assert.equal((update as { session: { id: string } }).session.id, 'sess-1');
+    assert.equal((update as { isActive: boolean }).isActive, true);
+
+    ws.close();
+  });
+
+  it('rejects events with dangerous fields', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/event`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        id: 'ev-bad',
+        timestamp: Date.now(),
+        source: 'kimi',
+        session_id: 'sess-bad',
+        event_type: 'tool_start',
+        command: 'rm -rf /',
+      }),
+    });
+    assert.equal(res.status, 400);
+  });
+
+  it('blocks static file path traversal', async () => {
+    const status = await httpGetStatus(port, '/../../package.json');
+    assert.equal(status, 403);
+  });
+});

package/servers/dashboard/src/server.ts

@@ -0,0 +1,191 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { WebSocketServer, WebSocket } from 'ws';
+import type { ServerConfig, ClientWebSocketMessage } from './types';
+import { StateStore } from './state';
+import { SkillRegistry } from './skills/registry';
+import { SkillInferenceEngine } from './skills/infer';
+import { createEventHandler } from './api/event';
+import { createSkillsHandler } from './api/skills';
+import { createSnapshotMessage } from './presenter';
+
+export interface DashboardServer {
+  httpServer: http.Server;
+  wss: WebSocketServer;
+  state: StateStore;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+}
+
+export function createDashboardServer(config: ServerConfig): DashboardServer {
+  const state = new StateStore({
+    maxEventsPerSession: config.maxEventsPerSession,
+    sessionMaxAgeMs: config.sessionMaxAgeMs,
+  });
+
+  const registry = new SkillRegistry(config.packageRoot);
+  registry.load();
+
+  const inference = new SkillInferenceEngine(registry.getSkills());
+  const clients = new Set<WebSocket>();
+  let activeSessionId: string | undefined;
+
+  function broadcast(message: ClientWebSocketMessage): void {
+    const data = JSON.stringify(message);
+    for (const client of clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    }
+  }
+
+  function sendSnapshot(client: WebSocket): void {
+    const message = createSnapshotMessage(state.getAllSessions());
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(JSON.stringify(message));
+    }
+  }
+
+  const eventHandler = createEventHandler({
+    state,
+    inference,
+    broadcast,
+    getActiveSessionId: () => activeSessionId,
+    setActiveSessionId: (id: string) => {
+      activeSessionId = id;
+    },
+  });
+  const skillsHandler = createSkillsHandler(registry);
+
+  const httpServer = http.createServer((req, res) => {
+    res.setHeader('Content-Type', 'application/json');
+
+    if (req.method === 'POST' && req.url === '/event') {
+      eventHandler(req, res).catch((err) => {
+        console.error('Event handler error:', err);
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: 'Internal server error' }));
+      });
+      return;
+    }
+
+    if (req.method === 'GET' && req.url === '/api/skills') {
+      skillsHandler(req, res).catch((err) => {
+        console.error('Skills handler error:', err);
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: 'Internal server error' }));
+      });
+      return;
+    }
+
+    if (req.method === 'GET' && req.url === '/') {
+      serveStaticFile(res, 'index.html', 'text/html');
+      return;
+    }
+
+    if (req.method === 'GET') {
+      const filePath = req.url?.slice(1) || '';
+      const ext = path.extname(filePath);
+      const contentType = CONTENT_TYPES[ext] || 'application/octet-stream';
+      serveStaticFile(res, filePath, contentType);
+      return;
+    }
+
+    res.statusCode = 404;
+    res.end(JSON.stringify({ error: 'Not found' }));
+  });
+
+  const wss = new WebSocketServer({ server: httpServer });
+
+  wss.on('connection', (client) => {
+    clients.add(client);
+    sendSnapshot(client);
+
+    client.on('message', (raw) => {
+      try {
+        const message = JSON.parse(raw.toString()) as { type?: string };
+        if (message.type === 'ping') {
+          client.send(JSON.stringify({ type: 'pong' }));
+        }
+      } catch {
+        // Ignore malformed client messages.
+      }
+    });
+
+    client.on('close', () => {
+      clients.delete(client);
+    });
+  });
+
+  const pruneInterval = setInterval(() => {
+    state.pruneInactive();
+  }, config.pruneIntervalMs);
+
+  function serveStaticFile(
+    res: http.ServerResponse,
+    filePath: string,
+    contentType: string
+  ): void {
+    const publicDir = path.resolve(__dirname, '..', 'public');
+    const fullPath = path.resolve(publicDir, filePath);
+    if (!fullPath.startsWith(publicDir + path.sep)) {
+      res.statusCode = 403;
+      res.end(JSON.stringify({ error: 'Forbidden' }));
+      return;
+    }
+
+    if (!fs.existsSync(fullPath)) {
+      res.statusCode = 404;
+      res.end(JSON.stringify({ error: 'Not found' }));
+      return;
+    }
+
+    fs.readFile(fullPath, (err, data) => {
+      if (err) {
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: 'Failed to read file' }));
+        return;
+      }
+      res.setHeader('Content-Type', contentType);
+      res.statusCode = 200;
+      res.end(data);
+    });
+  }
+
+  return {
+    httpServer,
+    wss,
+    state,
+    start: () =>
+      new Promise<void>((resolve, reject) => {
+        httpServer.listen(config.port, config.host, () => {
+          console.log(`CrewLoop dashboard running at http://${config.host}:${config.port}`);
+          resolve();
+        });
+        httpServer.on('error', reject);
+      }),
+    stop: () =>
+      new Promise<void>((resolve) => {
+        clearInterval(pruneInterval);
+        for (const client of clients) {
+          client.terminate();
+        }
+        wss.close(() => {
+          httpServer.close(() => {
+            resolve();
+          });
+        });
+      }),
+  };
+}
+
+const CONTENT_TYPES: Record<string, string> = {
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.ico': 'image/x-icon',
+};

package/servers/dashboard/src/skills/infer.test.ts

@@ -0,0 +1,86 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { SkillInferenceEngine } from './infer';
+import type { DashboardEvent, Session } from '../types';
+
+function makeSession(overrides: Partial<Session> = {}): Session {
+  return {
+    id: 'sess-1',
+    source: 'kimi',
+    events: [],
+    tool_counts: {},
+    started_at: Date.now(),
+    last_event_at: Date.now(),
+    ...overrides,
+  };
+}
+
+function makeEvent(overrides: Partial<DashboardEvent> = {}): DashboardEvent {
+  return {
+    id: 'ev-1',
+    timestamp: Date.now(),
+    source: 'kimi',
+    session_id: 'sess-1',
+    event_type: 'tool_start',
+    ...overrides,
+  };
+}
+
+const skills = [
+  { name: 'orchestrator', description: '', icon: 'target' },
+  { name: 'architect', description: '', icon: 'blueprint' },
+  { name: 'engineer', description: '', icon: 'wrench' },
+  { name: 'shipper', description: '', icon: 'rocket-launch' },
+  { name: 'researcher', description: '', icon: 'microscope' },
+];
+
+describe('SkillInferenceEngine', () => {
+  it('infers explicit skill from skill_change event', () => {
+    const engine = new SkillInferenceEngine(skills);
+    const event = makeEvent({ event_type: 'skill_change', skill: 'architect' });
+    const result = engine.infer(event, makeSession());
+    assert.equal(result.skill, 'architect');
+    assert.equal(result.confidence, 'explicit');
+  });
+
+  it('infers explicit skill from Skill tool detail', () => {
+    const engine = new SkillInferenceEngine(skills);
+    const event = makeEvent({ tool: 'Skill', detail: 'engineer' });
+    const result = engine.infer(event, makeSession());
+    assert.equal(result.skill, 'engineer');
+    assert.equal(result.confidence, 'explicit');
+  });
+
+  it('infers researcher from Read tool', () => {
+    const engine = new SkillInferenceEngine(skills);
+    const event = makeEvent({ tool: 'Read', detail: 'README.md' });
+    const result = engine.infer(event, makeSession());
+    assert.equal(result.skill, 'researcher');
+    assert.equal(result.confidence, 'heuristic');
+  });
+
+  it('infers shipper from git commit command', () => {
+    const engine = new SkillInferenceEngine(skills);
+    const event = makeEvent({ tool: 'Bash', detail: 'git commit -m "feat: x"' });
+    const result = engine.infer(event, makeSession());
+    assert.equal(result.skill, 'shipper');
+    assert.equal(result.confidence, 'heuristic');
+  });
+
+  it('falls back to session active skill', () => {
+    const engine = new SkillInferenceEngine(skills);
+    const session = makeSession({ active_skill: 'architect' });
+    const event = makeEvent({ tool: 'UnknownTool' });
+    const result = engine.infer(event, session);
+    assert.equal(result.skill, 'architect');
+    assert.equal(result.confidence, 'heuristic');
+  });
+
+  it('returns unknown when nothing matches', () => {
+    const engine = new SkillInferenceEngine(skills);
+    const event = makeEvent({ tool: 'UnknownTool' });
+    const result = engine.infer(event, makeSession());
+    assert.equal(result.skill, undefined);
+    assert.equal(result.confidence, 'unknown');
+  });
+});

package/servers/dashboard/src/skills/infer.ts

@@ -0,0 +1,53 @@
+import type { DashboardEvent, Session, SkillInferenceResult, SkillMeta } from '../types';
+import { inferFromTool, inferFromGitCommand } from './mapping';
+
+export class SkillInferenceEngine {
+  private skillNames: Set<string>;
+
+  constructor(skills: SkillMeta[]) {
+    this.skillNames = new Set(skills.map((skill) => skill.name));
+  }
+
+  infer(event: DashboardEvent, session: Session): SkillInferenceResult {
+    if (event.event_type === 'skill_change' && event.skill) {
+      return { skill: event.skill, confidence: 'explicit' };
+    }
+
+    if (event.tool === 'Skill' && event.detail) {
+      const skill = this.normalizeSkillName(event.detail);
+      if (skill) {
+        return { skill, confidence: 'explicit' };
+      }
+    }
+
+    if (event.tool === 'Bash' && event.detail) {
+      const gitSkill = inferFromGitCommand(event.detail);
+      if (gitSkill) {
+        return { skill: gitSkill, confidence: 'heuristic' };
+      }
+    }
+
+    if (event.tool) {
+      const mapped = inferFromTool(event.tool);
+      if (mapped && this.skillNames.has(mapped)) {
+        return { skill: mapped, confidence: 'heuristic' };
+      }
+    }
+
+    if (session.active_skill && this.skillNames.has(session.active_skill)) {
+      return { skill: session.active_skill, confidence: 'heuristic' };
+    }
+
+    return { skill: undefined, confidence: 'unknown' };
+  }
+
+  private normalizeSkillName(raw: string): string | undefined {
+    const normalized = raw.toLowerCase().trim();
+    for (const name of this.skillNames) {
+      if (name.toLowerCase() === normalized) {
+        return name;
+      }
+    }
+    return undefined;
+  }
+}

package/servers/dashboard/src/skills/mapping.ts

@@ -0,0 +1,26 @@
+import type { ToolToSkillMap } from '../types';
+
+export const DEFAULT_TOOL_TO_SKILL_MAP: ToolToSkillMap = {
+  Task: 'orchestrator',
+  Agent: 'orchestrator',
+  Read: 'researcher',
+  Grep: 'researcher',
+  Glob: 'researcher',
+  WebSearch: 'researcher',
+  FetchURL: 'researcher',
+  Edit: 'engineer',
+  Write: 'engineer',
+  Bash: 'engineer',
+  Skill: undefined,
+};
+
+export function inferFromTool(toolName: string): string | undefined {
+  return DEFAULT_TOOL_TO_SKILL_MAP[toolName];
+}
+
+export function inferFromGitCommand(command: string): string | undefined {
+  if (/\b(git\s+(commit|push|branch|merge|tag|checkout))\b/.test(command)) {
+    return 'shipper';
+  }
+  return undefined;
+}

package/servers/dashboard/src/skills/registry.ts

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { SkillMeta } from '../types';
+
+const SKILL_ICONS: Record<string, string> = {
+  orchestrator: 'target',
+  architect: 'blueprint',
+  designer: 'palette',
+  engineer: 'wrench',
+  reviewer: 'magnifying-glass',
+  shipper: 'rocket-launch',
+  'docs-writer': 'article',
+  tester: 'flask',
+  'product-manager': 'chart-bar',
+  maintainer: 'toolbox',
+  researcher: 'microscope',
+  'security-guard': 'shield',
+  'accessibility-auditor': 'person',
+  'obsidian-second-brain': 'brain',
+};
+
+export class SkillRegistry {
+  private skills: SkillMeta[] = [];
+  private packageRoot: string;
+
+  constructor(packageRoot: string) {
+    this.packageRoot = packageRoot;
+  }
+
+  load(): SkillMeta[] {
+    const skillsDir = path.join(this.packageRoot, 'skills');
+    if (fs.existsSync(skillsDir)) {
+      this.skills = fs
+        .readdirSync(skillsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({
+          name: entry.name,
+          description: '',
+          icon: SKILL_ICONS[entry.name] || 'circle',
+        }));
+    }
+
+    return this.skills;
+  }
+
+  getSkills(): SkillMeta[] {
+    if (this.skills.length === 0) {
+      this.load();
+    }
+    return this.skills;
+  }
+
+  getIcon(skillName: string): string {
+    return SKILL_ICONS[skillName] || 'circle';
+  }
+
+  hasSkill(skillName: string): boolean {
+    return this.getSkills().some((skill) => skill.name === skillName);
+  }
+}

package/servers/dashboard/src/state.test.ts

@@ -0,0 +1,88 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { StateStore } from './state';
+import type { DashboardEvent } from './types';
+
+function makeEvent(overrides: Partial<DashboardEvent> = {}): DashboardEvent {
+  return {
+    id: 'ev-1',
+    timestamp: Date.now(),
+    source: 'kimi',
+    session_id: 'sess-1',
+    event_type: 'tool_start',
+    tool: 'Read',
+    ...overrides,
+  };
+}
+
+describe('StateStore', () => {
+  it('creates session on first event', () => {
+    const store = new StateStore({ maxEventsPerSession: 10, sessionMaxAgeMs: 60000 });
+    const session = store.applyEvent(makeEvent());
+    assert.equal(session.id, 'sess-1');
+    assert.equal(session.source, 'kimi');
+    assert.equal(session.events.length, 1);
+  });
+
+  it('caps events per session', () => {
+    const store = new StateStore({ maxEventsPerSession: 3, sessionMaxAgeMs: 60000 });
+    for (let i = 0; i < 5; i++) {
+      store.applyEvent(makeEvent({ id: `ev-${i}`, timestamp: Date.now() + i }));
+    }
+    const session = store.getSession('sess-1')!;
+    assert.equal(session.events.length, 3);
+  });
+
+  it('counts tool usage', () => {
+    const store = new StateStore({ maxEventsPerSession: 10, sessionMaxAgeMs: 60000 });
+    store.applyEvent(makeEvent({ tool: 'Read' }));
+    store.applyEvent(makeEvent({ tool: 'Read' }));
+    store.applyEvent(makeEvent({ tool: 'Edit' }));
+    const session = store.getSession('sess-1')!;
+    assert.equal(session.tool_counts['Read'], 2);
+    assert.equal(session.tool_counts['Edit'], 1);
+  });
+
+  it('sets active skill when event carries skill', () => {
+    const store = new StateStore({ maxEventsPerSession: 10, sessionMaxAgeMs: 60000 });
+    store.applyEvent(makeEvent({ skill: 'architect', event_type: 'skill_change' }));
+    const session = store.getSession('sess-1')!;
+    assert.equal(session.active_skill, 'architect');
+    assert.equal(session.active_confidence, 'explicit');
+  });
+
+  it('derives running status from tool_start', () => {
+    const store = new StateStore({ maxEventsPerSession: 10, sessionMaxAgeMs: 60000 });
+    store.applyEvent(makeEvent({ event_type: 'tool_start' }));
+    assert.equal(store.getSession('sess-1')!.status, 'running');
+  });
+
+  it('derives success status from tool_end', () => {
+    const store = new StateStore({ maxEventsPerSession: 10, sessionMaxAgeMs: 60000 });
+    store.applyEvent(makeEvent({ event_type: 'tool_end', status: 'success' }));
+    assert.equal(store.getSession('sess-1')!.status, 'success');
+  });
+
+  it('derives error status from failed tool_end', () => {
+    const store = new StateStore({ maxEventsPerSession: 10, sessionMaxAgeMs: 60000 });
+    store.applyEvent(makeEvent({ event_type: 'tool_end', status: 'error' }));
+    assert.equal(store.getSession('sess-1')!.status, 'error');
+  });
+
+  it('prunes inactive sessions', () => {
+    const store = new StateStore({ maxEventsPerSession: 10, sessionMaxAgeMs: 1000 });
+    store.applyEvent(makeEvent());
+    const removed = store.pruneInactive(Date.now() + 2000);
+    assert.equal(removed, 1);
+    assert.equal(store.getSession('sess-1'), undefined);
+  });
+
+  it('returns sessions sorted by last event', () => {
+    const store = new StateStore({ maxEventsPerSession: 10, sessionMaxAgeMs: 60000 });
+    store.applyEvent(makeEvent({ session_id: 'a', timestamp: 1000 }));
+    store.applyEvent(makeEvent({ session_id: 'b', timestamp: 2000 }));
+    const sessions = store.getAllSessions();
+    assert.equal(sessions[0].id, 'b');
+    assert.equal(sessions[1].id, 'a');
+  });
+});