@archznn/crewloop-skills 0.6.0 → 0.7.0

package/servers/dashboard/src/tests/adapters.test.ts

@@ -0,0 +1,198 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { normalizeKimi } from '../adapters/kimi';
+import { normalizeCodex } from '../adapters/codex';
+import { normalizeAgy } from '../adapters/agy';
+
+describe('normalizeKimi', () => {
+  it('forwards tool_input as input', () => {
+    const event = normalizeKimi({
+      hook_event_name: 'PreToolUse',
+      session_id: 'session-1',
+      cwd: '/tmp',
+      tool_name: 'Bash',
+      tool_input: { command: 'echo hello' },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.event_type, 'tool_start');
+    assert.deepStrictEqual(event!.input, { command: 'echo hello' });
+    assert.strictEqual(event!.output, undefined);
+  });
+
+  it('forwards tool_output object as output', () => {
+    const event = normalizeKimi({
+      hook_event_name: 'PostToolUse',
+      session_id: 'session-1',
+      cwd: '/tmp',
+      tool_name: 'Bash',
+      tool_input: { command: 'echo hello' },
+      tool_output: { stdout: 'hello\n' },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.event_type, 'tool_end');
+    assert.deepStrictEqual(event!.input, { command: 'echo hello' });
+    assert.deepStrictEqual(event!.output, { stdout: 'hello\n' });
+  });
+
+  it('wraps string tool_output in an object', () => {
+    const event = normalizeKimi({
+      hook_event_name: 'PostToolUse',
+      session_id: 'session-1',
+      cwd: '/tmp',
+      tool_name: 'Bash',
+      tool_input: { command: 'echo hello' },
+      tool_output: 'hello\n',
+    });
+
+    assert.ok(event);
+    assert.deepStrictEqual(event!.output, { output: 'hello\n' });
+  });
+});
+
+describe('normalizeCodex', () => {
+  it('forwards toolInput as input and toolResponse as output', () => {
+    const event = normalizeCodex({
+      hook_event_name: 'PostToolUse',
+      sessionId: 'session-2',
+      toolName: 'ReadFile',
+      toolInput: { path: '/tmp/foo.txt' },
+      toolResponse: { content: 'bar' },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.event_type, 'tool_end');
+    assert.deepStrictEqual(event!.input, { path: '/tmp/foo.txt' });
+    assert.deepStrictEqual(event!.output, { content: 'bar' });
+  });
+});
+
+describe('normalizeAgy', () => {
+  it('normalizes PreToolUse with tool mapping and detail extraction', () => {
+    const event = normalizeAgy({
+      hook_event_name: 'PreToolUse',
+      conversationId: 'conv-1',
+      stepIdx: 3,
+      toolCall: {
+        name: 'run_command',
+        args: { CommandLine: 'git status', Cwd: '/tmp' },
+      },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.source, 'agy');
+    assert.strictEqual(event!.event_type, 'tool_start');
+    assert.strictEqual(event!.session_id, 'conv-1');
+    assert.strictEqual(event!.tool, 'Bash');
+    assert.strictEqual(event!.detail, 'git status');
+    assert.strictEqual(event!.id, 'agy:conv-1:3');
+    assert.deepStrictEqual(event!.input, { CommandLine: 'git status', Cwd: '/tmp' });
+  });
+
+  it('normalizes PostToolUse without tool name and wraps error', () => {
+    const event = normalizeAgy({
+      hook_event_name: 'PostToolUse',
+      conversationId: 'conv-1',
+      stepIdx: 3,
+      error: 'exit status 1',
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.event_type, 'tool_end');
+    assert.strictEqual(event!.session_id, 'conv-1');
+    assert.strictEqual(event!.tool, undefined);
+    assert.strictEqual(event!.id, 'agy:conv-1:3');
+    assert.deepStrictEqual(event!.output, { error: 'exit status 1' });
+  });
+
+  it('maps AGY view_file to Read and extracts AbsolutePath', () => {
+    const event = normalizeAgy({
+      hook_event_name: 'PreToolUse',
+      conversationId: 'conv-2',
+      stepIdx: 0,
+      toolCall: {
+        name: 'view_file',
+        args: { AbsolutePath: '/home/user/README.md' },
+      },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.tool, 'Read');
+    assert.strictEqual(event!.detail, '/home/user/README.md');
+  });
+
+  it('ignores unsupported hook event names', () => {
+    const event = normalizeAgy({
+      hook_event_name: 'PreInvocation',
+      conversationId: 'conv-3',
+      stepIdx: 0,
+    });
+
+    assert.strictEqual(event, undefined);
+  });
+
+  it('falls back to sessionId and random id when conversationId is missing', () => {
+    const event = normalizeAgy({
+      hook_event_name: 'PreToolUse',
+      sessionId: 'sess-fallback',
+      toolCall: { name: 'list_dir', args: { DirectoryPath: '/tmp' } },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.session_id, 'sess-fallback');
+    assert.ok(event!.id.startsWith('agy:sess-fallback:'));
+    assert.strictEqual(event!.tool, 'Glob');
+  });
+
+  it('infers skill from AGY skill file read', () => {
+    const event = normalizeAgy({
+      hook_event_name: 'PreToolUse',
+      conversationId: 'conv-skill',
+      stepIdx: 0,
+      toolCall: {
+        name: 'view_file',
+        args: {
+          AbsolutePath: '/home/arch/.agents/skills/orchestrator/SKILL.md',
+          IsSkillFile: true,
+          toolSummary: 'Orchestrator skill',
+        },
+      },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.tool, 'Read');
+    assert.strictEqual(event!.skill, 'orchestrator');
+  });
+
+  it('does not infer skill for ordinary AGY file reads', () => {
+    const event = normalizeAgy({
+      hook_event_name: 'PreToolUse',
+      conversationId: 'conv-file',
+      stepIdx: 0,
+      toolCall: {
+        name: 'view_file',
+        args: { AbsolutePath: '/home/arch/README.md' },
+      },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.tool, 'Read');
+    assert.strictEqual(event!.skill, undefined);
+  });
+
+  it('infers skill from Windows-style skill file path', () => {
+    const event = normalizeAgy({
+      hook_event_name: 'PreToolUse',
+      conversationId: 'conv-win',
+      stepIdx: 0,
+      toolCall: {
+        name: 'view_file',
+        args: { AbsolutePath: 'C:\\Users\\arch\\.agents\\skills\\engineer\\SKILL.md' },
+      },
+    });
+
+    assert.ok(event);
+    assert.strictEqual(event!.skill, 'engineer');
+  });
+});

package/servers/dashboard/src/tests/lib-helpers.test.ts

@@ -0,0 +1,133 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { formatDuration, formatTime, truncate, escapeHtml, prettyJson } from '../lib/format';
+import { resolvePath } from '../lib/paths';
+import { projectInvocations, buildFileActivity, operationType } from '../lib/invocations';
+import { buildGraph3D } from '../lib/graph';
+import type { ClientEvent, ClientSession } from '../types';
+
+describe('format', () => {
+  it('formats duration', () => {
+    assert.equal(formatDuration(0), '00:00');
+    assert.equal(formatDuration(61000), '01:01');
+    assert.equal(formatDuration(3661000), '1:01:01');
+    assert.equal(formatDuration(undefined), '00:00');
+  });
+
+  it('formats time', () => {
+    const ts = new Date('2026-06-26T14:30:45').getTime();
+    assert.equal(formatTime(ts), '14:30:45');
+  });
+
+  it('truncates strings', () => {
+    assert.equal(truncate('hello', 10), 'hello');
+    assert.equal(truncate('hello world', 6), 'hello…');
+  });
+
+  it('escapes html', () => {
+    assert.equal(escapeHtml('<div>"x" & \'y\'</div>'), '&lt;div&gt;&quot;x&quot; &amp; &#039;y&#039;&lt;/div&gt;');
+  });
+
+  it('pretty prints json', () => {
+    assert.equal(prettyJson({ a: 1 }), '{\n  "a": 1\n}');
+  });
+});
+
+describe('resolvePath', () => {
+  it('resolves input.path', () => {
+    assert.equal(resolvePath({ path: 'a.txt' }), 'a.txt');
+  });
+
+  it('prefers input.path over output.path', () => {
+    assert.equal(resolvePath({ path: 'in.txt' }, { path: 'out.txt' }), 'in.txt');
+  });
+
+  it('resolves operations[].path', () => {
+    assert.equal(resolvePath({ operations: [{ path: 'op.txt' }] }), 'op.txt');
+  });
+
+  it('resolves camelCase filePath', () => {
+    assert.equal(resolvePath({ filePath: 'camel.txt' }), 'camel.txt');
+  });
+});
+
+describe('projectInvocations', () => {
+  it('pairs tool_start with tool_end (server newest-first order)', () => {
+    const events: ClientEvent[] = [
+      { id: '2', timestamp: 1100, event_type: 'tool_end', tool: 'Read', status: 'success', duration_ms: 100, output: { content: 'hi' } },
+      { id: '1', timestamp: 1000, event_type: 'tool_start', tool: 'Read', input: { path: 'a.txt' } },
+    ];
+    const invs = projectInvocations(events);
+    assert.equal(invs.length, 1);
+    assert.equal(invs[0].status, 'success');
+    assert.equal(invs[0].durationMs, 100);
+  });
+
+  it('keeps running invocations when end is missing', () => {
+    const events: ClientEvent[] = [
+      { id: '1', timestamp: 1000, event_type: 'tool_start', tool: 'Bash', input: { command: 'ls' } },
+    ];
+    const invs = projectInvocations(events);
+    assert.equal(invs.length, 1);
+    assert.equal(invs[0].status, 'running');
+  });
+
+  it('renders newest invocations at the top', () => {
+    const events: ClientEvent[] = [
+      { id: '4', timestamp: 4000, event_type: 'tool_end', tool: 'Read', status: 'success' },
+      { id: '3', timestamp: 3000, event_type: 'tool_start', tool: 'Read' },
+      { id: '2', timestamp: 2000, event_type: 'tool_end', tool: 'Write', status: 'success' },
+      { id: '1', timestamp: 1000, event_type: 'tool_start', tool: 'Write' },
+    ];
+    const invs = projectInvocations(events);
+    assert.equal(invs.length, 2);
+    assert.equal(invs[0].tool, 'Read');
+    assert.equal(invs[1].tool, 'Write');
+  });
+});
+
+describe('buildFileActivity', () => {
+  it('groups operations by path', () => {
+    const invs = [
+      { id: '1', tool: 'Write', eventType: 'tool_end', startTime: 1000, status: 'success', input: { path: 'a.txt' }, output: { diff: '+x' } },
+      { id: '2', tool: 'Read', eventType: 'tool_end', startTime: 1100, status: 'success', input: { path: 'a.txt' } },
+    ];
+    const activity = buildFileActivity(invs, resolvePath);
+    assert.equal(activity.length, 1);
+    assert.equal(activity[0].path, 'a.txt');
+    assert.equal(activity[0].snippet, '+x');
+  });
+});
+
+describe('operationType', () => {
+  it('classifies tools', () => {
+    assert.equal(operationType('Read'), 'read');
+    assert.equal(operationType('Write'), 'edit');
+    assert.equal(operationType('EditFile'), 'edit');
+    assert.equal(operationType('Bash'), 'other');
+  });
+});
+
+describe('buildGraph3D', () => {
+  it('builds skill-tool-file graph', () => {
+    const session: ClientSession = {
+      id: 's1',
+      source: 'kimi',
+      activeSkill: { name: 'engineer', confidence: 'explicit' },
+      lifecycle: 'running',
+      events: [],
+      startTime: 0,
+      lastActivity: 0,
+      toolCounts: {},
+    };
+    const invs = [
+      { id: '1', tool: 'Read', eventType: 'tool_end', startTime: 1000, status: 'success', input: { path: 'a.txt' }, output: {} },
+    ];
+    const graph = buildGraph3D(session, invs);
+    assert.equal(graph.nodes.length, 3);
+    assert.ok(graph.nodes.some((n) => n.id === 'skill:engineer'));
+    assert.ok(graph.nodes.some((n) => n.id === 'tool:Read'));
+    assert.ok(graph.nodes.some((n) => n.id === 'file:a.txt'));
+    assert.equal(graph.links.length, 2);
+  });
+});

package/servers/dashboard/src/tests/shim.test.ts

@@ -2,13 +2,20 @@ import { describe, it } from 'node:test';
 import assert from 'node:assert';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
+import http from 'node:http';
+import type { AddressInfo } from 'node:net';
 import { runShim } from '../adapters/shim';
 
-function runBin(args: string[], input?: string): Promise<{ exitCode: number | null; stderr: string }> {
+function runBin(
+  args: string[],
+  input?: string,
+  env?: Record<string, string>
+): Promise<{ exitCode: number | null; stderr: string }> {
   const binPath = path.join(__dirname, '..', '..', 'bin', 'crewloop-shim.js');
   return new Promise((resolve, reject) => {
     const child = spawn(process.execPath, [binPath, ...args], {
       stdio: ['pipe', 'pipe', 'pipe'],
+      env: env ? { ...process.env, ...env } : process.env,
     });
     let stderr = '';
     child.stderr!.on('data', (chunk) => {
@@ -40,6 +47,107 @@ describe('shim binary', () => {
     const { exitCode, stderr } = await runBin(['unknown']);
     assert.strictEqual(exitCode, 1);
     assert.ok(stderr.includes('unknown source'));
-    assert.ok(stderr.includes('crewloop-shim <kimi|codex>'));
+    assert.ok(stderr.includes('crewloop-shim <kimi|codex|agy>'));
+  });
+
+  it('exits 0 for agy source with empty stdin', async () => {
+    const { exitCode, stderr } = await runBin(['agy']);
+    assert.strictEqual(exitCode, 0);
+    assert.strictEqual(stderr, '');
+  });
+
+  it('delivers a POST /event before exiting', async () => {
+    let receivedBody: string | undefined;
+    const server = http.createServer((req, res) => {
+      if (req.method === 'POST' && req.url === '/event') {
+        let body = '';
+        req.on('data', (chunk) => {
+          body += chunk.toString();
+        });
+        req.on('end', () => {
+          receivedBody = body;
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true }));
+        });
+      }
+    });
+
+    await new Promise<void>((resolve) => server.listen(0, resolve));
+    const { port } = server.address() as AddressInfo;
+
+    const input = JSON.stringify({
+      hook_event_name: 'PostToolUse',
+      session_id: 'test-session',
+      cwd: '/tmp',
+      tool_name: 'TestTool',
+      tool_input: { command: 'echo hello' },
+      tool_output: 'hello\n',
+    });
+
+    try {
+      const { exitCode } = await runBin(
+        ['kimi', '--default-skill', 'orchestrator'],
+        input,
+        { CREWLOOP_DASHBOARD_URL: `http://127.0.0.1:${port}` }
+      );
+
+      assert.strictEqual(exitCode, 0);
+      assert.ok(receivedBody, 'shim should have sent a request body');
+      const parsed = JSON.parse(receivedBody!);
+      assert.strictEqual(parsed.event_type, 'tool_end');
+      assert.strictEqual(parsed.source, 'kimi');
+      assert.strictEqual(parsed.session_id, 'test-session');
+      assert.deepStrictEqual(parsed.input, { command: 'echo hello' });
+      assert.deepStrictEqual(parsed.output, { output: 'hello\n' });
+    } finally {
+      server.close();
+    }
+  });
+
+  it('delivers AGY event with default skill fallback', async () => {
+    let receivedBody: string | undefined;
+    const server = http.createServer((req, res) => {
+      if (req.method === 'POST' && req.url === '/event') {
+        let body = '';
+        req.on('data', (chunk) => {
+          body += chunk.toString();
+        });
+        req.on('end', () => {
+          receivedBody = body;
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true }));
+        });
+      }
+    });
+
+    await new Promise<void>((resolve) => server.listen(0, resolve));
+    const { port } = server.address() as AddressInfo;
+
+    const input = JSON.stringify({
+      hook_event_name: 'PreToolUse',
+      conversationId: 'agy-session',
+      stepIdx: 0,
+      toolCall: {
+        name: 'run_command',
+        args: { CommandLine: 'git status' },
+      },
+    });
+
+    try {
+      const { exitCode } = await runBin(
+        ['agy', '--default-skill', 'orchestrator'],
+        input,
+        { CREWLOOP_DASHBOARD_URL: `http://127.0.0.1:${port}` }
+      );
+
+      assert.strictEqual(exitCode, 0);
+      assert.ok(receivedBody, 'shim should have sent a request body');
+      const parsed = JSON.parse(receivedBody!);
+      assert.strictEqual(parsed.event_type, 'tool_start');
+      assert.strictEqual(parsed.source, 'agy');
+      assert.strictEqual(parsed.skill, 'orchestrator');
+    } finally {
+      server.close();
+    }
   });
 });

package/servers/dashboard/src/types.ts

@@ -1,4 +1,4 @@
-export type AgentSource = 'kimi' | 'codex' | 'opencode' | 'log-watcher';
+export type AgentSource = 'kimi' | 'codex' | 'opencode' | 'log-watcher' | 'agy';
 
 export type EventType =
   | 'session_start'
@@ -20,6 +20,8 @@ export interface DashboardEvent {
   detail?: string;
   status?: EventStatus;
   duration_ms?: number;
+  input?: Record<string, unknown>;
+  output?: Record<string, unknown>;
 }
 
 export interface Session {
@@ -54,6 +56,8 @@ export interface ClientEvent {
   status?: EventStatus;
   duration_ms?: number;
   skill?: string;
+  input?: Record<string, unknown>;
+  output?: Record<string, unknown>;
 }
 
 export interface ClientSession {
@@ -96,8 +100,6 @@ export interface SkillMeta {
   icon: string;
 }
 
-export type ToolToSkillMap = Record<string, string | undefined>;
-
 export interface SkillInferenceResult {
   skill: string | undefined;
   confidence: 'explicit' | 'heuristic' | 'unknown';

package/servers/dashboard/ui/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>CrewLoop Dashboard</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Teko:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet" />
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.tsx"></script>
+</body>
+</html>

package/servers/dashboard/ui/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};