@archznn/crewloop-skills 0.5.0 → 0.7.0

package/servers/dashboard/src/lib/format.ts

@@ -0,0 +1,44 @@
+export function formatDuration(ms: number | undefined | null): string {
+  if (!ms || ms < 0) return '00:00';
+  const totalSeconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(totalSeconds / 60).toString().padStart(2, '0');
+  const seconds = (totalSeconds % 60).toString().padStart(2, '0');
+  if (totalSeconds < 3600) return `${minutes}:${seconds}`;
+  const hours = Math.floor(totalSeconds / 3600);
+  const mins = Math.floor((totalSeconds % 3600) / 60)
+    .toString()
+    .padStart(2, '0');
+  return `${hours}:${mins}:${seconds}`;
+}
+
+export function formatTime(ts: number): string {
+  const d = new Date(ts);
+  return d.toLocaleTimeString(undefined, {
+    hour12: false,
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  });
+}
+
+export function truncate(str: string | undefined | null, n: number): string {
+  if (!str) return '';
+  return str.length > n ? str.slice(0, n - 1) + '…' : str;
+}
+
+export function escapeHtml(str: unknown): string {
+  return String(str)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#039;');
+}
+
+export function prettyJson(obj: unknown): string {
+  try {
+    return JSON.stringify(obj, null, 2);
+  } catch {
+    return String(obj);
+  }
+}

package/servers/dashboard/src/lib/graph.ts

@@ -0,0 +1,69 @@
+import type { ClientSession } from '../types';
+import type { ToolInvocation } from './invocations';
+import { resolvePath } from './paths';
+
+export interface GraphNode {
+  id: string;
+  type: 'skill' | 'tool' | 'file';
+  label: string;
+  weight: number;
+  x?: number;
+  y?: number;
+  z?: number;
+}
+
+export interface GraphLink {
+  source: string;
+  target: string;
+  weight: number;
+}
+
+export interface Graph3D {
+  nodes: GraphNode[];
+  links: GraphLink[];
+}
+
+export function buildGraph3D(session: ClientSession | undefined, invocations: ToolInvocation[]): Graph3D {
+  const nodes = new Map<string, GraphNode>();
+  const links: GraphLink[] = [];
+
+  const skillName = session?.activeSkill?.name || session?.skill || 'unknown';
+  const skillId = `skill:${skillName}`;
+  nodes.set(skillId, { id: skillId, type: 'skill', label: skillName, weight: 1 });
+
+  function ensureNode(id: string, type: GraphNode['type'], label: string, weight = 0): GraphNode {
+    const existing = nodes.get(id);
+    if (existing) {
+      existing.weight += weight;
+      return existing;
+    }
+    const node: GraphNode = { id, type, label, weight };
+    nodes.set(id, node);
+    return node;
+  }
+
+  function addLink(sourceId: string, targetId: string, weight = 1) {
+    const existing = links.find((l) => l.source === sourceId && l.target === targetId);
+    if (existing) {
+      existing.weight += weight;
+    } else {
+      links.push({ source: sourceId, target: targetId, weight });
+    }
+  }
+
+  for (const inv of invocations) {
+    if (inv.meta) continue;
+    const toolId = `tool:${inv.tool}`;
+    ensureNode(toolId, 'tool', inv.tool, 1);
+    addLink(skillId, toolId, 1);
+
+    const path = resolvePath(inv.input, inv.output);
+    if (path) {
+      const fileId = `file:${path}`;
+      ensureNode(fileId, 'file', path, 1);
+      addLink(toolId, fileId, 1);
+    }
+  }
+
+  return { nodes: Array.from(nodes.values()), links };
+}

package/servers/dashboard/src/lib/invocations.test.ts

@@ -0,0 +1,70 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { projectInvocations } from './invocations';
+import type { ClientEvent } from '../types';
+
+function makeEvent(overrides: Partial<ClientEvent> & { id: string }): ClientEvent {
+  return {
+    timestamp: Date.now(),
+    event_type: 'tool_start',
+    ...overrides,
+  } as ClientEvent;
+}
+
+describe('projectInvocations', () => {
+  it('pairs tool_start and tool_end by id when tool names differ or are missing', () => {
+    const start = makeEvent({
+      id: 'agy:conv-1:0',
+      event_type: 'tool_start',
+      tool: 'Bash',
+      detail: 'git status',
+    });
+    const end = makeEvent({
+      id: 'agy:conv-1:0',
+      event_type: 'tool_end',
+      status: 'success',
+      output: { result: 'ok' },
+    });
+
+    const invocations = projectInvocations([end, start]);
+    assert.strictEqual(invocations.length, 1);
+    assert.strictEqual(invocations[0].tool, 'Bash');
+    assert.strictEqual(invocations[0].status, 'success');
+    assert.strictEqual(invocations[0].detail, 'git status');
+    assert.deepStrictEqual(invocations[0].output, { result: 'ok' });
+  });
+
+  it('falls back to tool-name pairing when ids do not match', () => {
+    const start = makeEvent({
+      id: 'kimi-1',
+      event_type: 'tool_start',
+      tool: 'Read',
+      detail: '/tmp/foo.txt',
+    });
+    const end = makeEvent({
+      id: 'kimi-2',
+      event_type: 'tool_end',
+      tool: 'Read',
+      status: 'success',
+    });
+
+    const invocations = projectInvocations([end, start]);
+    assert.strictEqual(invocations.length, 1);
+    assert.strictEqual(invocations[0].tool, 'Read');
+    assert.strictEqual(invocations[0].status, 'success');
+  });
+
+  it('renders orphaned tool_end when no matching start exists', () => {
+    const end = makeEvent({
+      id: 'agy:conv-1:5',
+      event_type: 'tool_end',
+      status: 'error',
+      output: { error: 'failed' },
+    });
+
+    const invocations = projectInvocations([end]);
+    assert.strictEqual(invocations.length, 1);
+    assert.strictEqual(invocations[0].eventType, 'tool_end');
+    assert.strictEqual(invocations[0].status, 'error');
+  });
+});

package/servers/dashboard/src/lib/invocations.ts

@@ -0,0 +1,172 @@
+import type { ClientEvent } from '../types';
+
+const MAX_EVENTS = 100;
+
+export interface ToolInvocation {
+  id: string;
+  tool: string;
+  eventType: string;
+  status: 'running' | 'success' | 'error' | string;
+  startTime: number;
+  endTime?: number;
+  durationMs?: number;
+  detail?: string;
+  skill?: string;
+  input?: Record<string, unknown>;
+  output?: Record<string, unknown>;
+  meta?: boolean;
+}
+
+export interface FileOp {
+  id: string;
+  type: 'read' | 'edit' | 'other';
+  status: string;
+  timestamp: number;
+  tool: string;
+  snippet?: string;
+}
+
+export interface FileEntry {
+  path: string;
+  ops: FileOp[];
+  snippet?: string;
+}
+
+function statusFromEvent(ev: ClientEvent): string {
+  return ev.status || (ev.event_type && ev.event_type.endsWith('_end') ? 'success' : 'meta');
+}
+
+export function operationType(tool: string): 'read' | 'edit' | 'other' {
+  const t = tool.toLowerCase();
+  if (t === 'read') return 'read';
+  if (['write', 'edit', 'editfile'].includes(t)) return 'edit';
+  return 'other';
+}
+
+export function projectInvocations(events: ClientEvent[]): ToolInvocation[] {
+  const chronological = events.slice().reverse();
+  const invocations: ToolInvocation[] = [];
+  const runningById = new Map<string, ToolInvocation>();
+  const runningByTool = new Map<string, ToolInvocation[]>();
+
+  for (const ev of chronological) {
+    const tool = ev.tool || ev.event_type;
+    const status = statusFromEvent(ev);
+
+    if (ev.event_type === 'tool_start' && ev.tool) {
+      const inv: ToolInvocation = {
+        id: ev.id,
+        tool: ev.tool,
+        eventType: ev.event_type,
+        status: 'running',
+        startTime: ev.timestamp,
+        detail: ev.detail,
+        skill: ev.skill,
+        input: ev.input,
+        output: undefined,
+      };
+      invocations.push(inv);
+      runningById.set(ev.id, inv);
+      if (!runningByTool.has(ev.tool)) runningByTool.set(ev.tool, []);
+      runningByTool.get(ev.tool)!.push(inv);
+      continue;
+    }
+
+    if (ev.event_type === 'tool_end') {
+      let inv: ToolInvocation | undefined;
+
+      if (runningById.has(ev.id)) {
+        inv = runningById.get(ev.id);
+        runningById.delete(ev.id);
+        const stack = runningByTool.get(inv!.tool);
+        if (stack) {
+          const idx = stack.lastIndexOf(inv!);
+          if (idx !== -1) stack.splice(idx, 1);
+        }
+      } else if (ev.tool) {
+        const stack = runningByTool.get(ev.tool);
+        if (stack && stack.length) {
+          inv = stack.pop();
+        }
+      }
+
+      if (inv) {
+        inv.status = status;
+        inv.endTime = ev.timestamp;
+        inv.durationMs = ev.duration_ms;
+        inv.output = ev.output;
+        inv.detail = ev.detail || inv.detail;
+        continue;
+      }
+
+      invocations.push({
+        id: ev.id,
+        tool: ev.tool || ev.event_type,
+        eventType: ev.event_type,
+        status,
+        startTime: ev.timestamp,
+        endTime: ev.timestamp,
+        durationMs: ev.duration_ms,
+        detail: ev.detail,
+        skill: ev.skill,
+        input: ev.input,
+        output: ev.output,
+      });
+      continue;
+    }
+
+    invocations.push({
+      id: ev.id,
+      tool,
+      eventType: ev.event_type,
+      status,
+      startTime: ev.timestamp,
+      endTime: ev.timestamp,
+      durationMs: ev.duration_ms,
+      detail: ev.detail,
+      skill: ev.skill,
+      input: ev.input,
+      output: ev.output,
+      meta: true,
+    });
+  }
+
+  const recent = invocations.slice(-MAX_EVENTS);
+  recent.reverse();
+  return recent;
+}
+
+export function buildFileActivity(
+  invocations: ToolInvocation[],
+  resolvePathFn: (input?: unknown, output?: unknown) => string | undefined
+): FileEntry[] {
+  const files = new Map<string, FileEntry>();
+
+  for (const inv of invocations) {
+    const path = resolvePathFn(inv.input, inv.output);
+    if (!path) continue;
+
+    if (!files.has(path)) {
+      files.set(path, { path, ops: [] });
+    }
+    const entry = files.get(path)!;
+    entry.ops.push({
+      id: inv.id,
+      type: operationType(inv.tool),
+      status: inv.status,
+      timestamp: inv.startTime,
+      tool: inv.tool,
+      snippet: (inv.output?.diff as string | undefined) || (inv.output?.contentSnippet as string | undefined),
+    });
+  }
+
+  return Array.from(files.values()).map((entry) => {
+    entry.ops.sort((a, b) => a.timestamp - b.timestamp);
+    let snippet: string | undefined;
+    for (const op of entry.ops) {
+      if (op.snippet) snippet = op.snippet;
+    }
+    entry.snippet = snippet;
+    return entry;
+  });
+}

package/servers/dashboard/src/lib/paths.ts

@@ -0,0 +1,35 @@
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function firstOperationPath(operations: unknown): string | undefined {
+  if (!Array.isArray(operations)) return undefined;
+  for (const op of operations) {
+    if (isPlainObject(op)) {
+      const p = op.path ?? op.file_path;
+      if (typeof p === 'string') return p;
+    }
+  }
+  return undefined;
+}
+
+export function resolvePath(input?: unknown, output?: unknown): string | undefined {
+  const candidates = [
+    isPlainObject(input) ? input.path : undefined,
+    isPlainObject(input) ? input.file_path : undefined,
+    isPlainObject(input) ? input.filePath : undefined,
+    isPlainObject(input) && isPlainObject(input.args) ? input.args.path : undefined,
+    isPlainObject(input) && isPlainObject(input.args) ? input.args.file_path : undefined,
+    isPlainObject(input) && isPlainObject(input.args) ? input.args.filePath : undefined,
+    isPlainObject(input) ? firstOperationPath(input.operations) : undefined,
+    isPlainObject(output) ? output.path : undefined,
+    isPlainObject(output) ? output.file_path : undefined,
+    isPlainObject(output) && isPlainObject(output.args) ? output.args.path : undefined,
+    isPlainObject(output) && isPlainObject(output.args) ? output.args.file_path : undefined,
+    isPlainObject(output) ? firstOperationPath(output.operations) : undefined,
+  ];
+  for (const p of candidates) {
+    if (typeof p === 'string') return p;
+  }
+  return undefined;
+}

package/servers/dashboard/src/presenter.ts

@@ -10,6 +10,8 @@ export function presentEvent(event: Session['events'][number]): ClientEvent {
     status: event.status,
     duration_ms: event.duration_ms,
     skill: event.skill,
+    input: event.input,
+    output: event.output,
   };
 }
 

package/servers/dashboard/src/server.ts

@@ -127,7 +127,7 @@ export function createDashboardServer(config: ServerConfig): DashboardServer {
     filePath: string,
     contentType: string
   ): void {
-    const publicDir = path.resolve(__dirname, '..', 'public');
+    const publicDir = path.resolve(__dirname, '..', 'dist', 'public');
     const fullPath = path.resolve(publicDir, filePath);
     if (!fullPath.startsWith(publicDir + path.sep)) {
       res.statusCode = 403;
@@ -181,6 +181,10 @@ export function createDashboardServer(config: ServerConfig): DashboardServer {
         httpServer.listen(config.port, config.host, () => {
           httpServer.off('error', onError);
           wss.off('error', onError);
+          const uiIndex = path.resolve(__dirname, '..', 'dist', 'public', 'index.html');
+          if (!fs.existsSync(uiIndex)) {
+            console.warn('Warning: built UI not found at dist/public/index.html. Run `npm run build` first.');
+          }
           console.log(`CrewLoop dashboard running at http://${config.host}:${config.port}`);
           resolve();
         });

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

@@ -52,12 +52,20 @@ describe('SkillInferenceEngine', () => {
     assert.equal(result.confidence, 'explicit');
   });
 
-  it('infers researcher from Read tool', () => {
+  it('returns unknown for generic 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');
+    assert.equal(result.skill, undefined);
+    assert.equal(result.confidence, 'unknown');
+  });
+
+  it('returns unknown for generic Bash tool', () => {
+    const engine = new SkillInferenceEngine(skills);
+    const event = makeEvent({ tool: 'Bash', detail: 'ls -la' });
+    const result = engine.infer(event, makeSession());
+    assert.equal(result.skill, undefined);
+    assert.equal(result.confidence, 'unknown');
   });
 
   it('infers shipper from git commit command', () => {

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

@@ -1,5 +1,5 @@
 import type { DashboardEvent, Session, SkillInferenceResult, SkillMeta } from '../types';
-import { inferFromTool, inferFromGitCommand } from './mapping';
+import { inferFromGitCommand } from './mapping';
 
 export class SkillInferenceEngine {
   private skillNames: Set<string>;
@@ -35,13 +35,6 @@ export class SkillInferenceEngine {
       }
     }
 
-    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' };
     }

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

@@ -1,23 +1,3 @@
-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';

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

@@ -16,7 +16,6 @@ const SKILL_ICONS: Record<string, string> = {
   researcher: 'microscope',
   'security-guard': 'shield',
   'accessibility-auditor': 'person',
-  'obsidian-second-brain': 'brain',
 };
 
 export class SkillRegistry {