runwork 0.5.0 → 0.6.0

package/dist/agents/__tests__/intro-skill.test.js

@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest';
+import { generateIntroSkill, generateInstructionHint } from '../intro-skill.js';
+function makeContext(overrides = {}) {
+    return {
+        workspaceName: 'Test Workspace',
+        workspaceId: 'ws-123',
+        registries: null,
+        connectedIntegrations: [],
+        mcpServerCount: 0,
+        skillCount: 0,
+        ...overrides,
+    };
+}
+describe('generateIntroSkill', () => {
+    it('generates a skill with workspace name', () => {
+        const skill = generateIntroSkill(makeContext());
+        expect(skill.name).toBe('runwork');
+        expect(skill.content).toContain('Test Workspace');
+        expect(skill.content).toContain('Runwork');
+        expect(skill.description).toContain('infrastructure platform');
+    });
+    it('includes entity names from registries', () => {
+        const skill = generateIntroSkill(makeContext({
+            registries: {
+                entities: [
+                    { entityName: 'Customer', appName: 'crm', appId: 'a1' },
+                    { entityName: 'Order', appName: 'shop', appId: 'a2' },
+                ],
+                workflows: [],
+                schedules: [],
+                agents: [],
+                endpoints: [],
+                components: [],
+                fileStorages: [],
+            },
+        }));
+        expect(skill.content).toContain('Customer (crm)');
+        expect(skill.content).toContain('Order (shop)');
+    });
+    it('includes workflow names', () => {
+        const skill = generateIntroSkill(makeContext({
+            registries: {
+                entities: [],
+                workflows: [{ name: 'onboard-user', appName: 'auth', appId: 'a1' }],
+                schedules: [],
+                agents: [],
+                endpoints: [],
+                components: [],
+                fileStorages: [],
+            },
+        }));
+        expect(skill.content).toContain('onboard-user');
+    });
+    it('includes connected integrations', () => {
+        const skill = generateIntroSkill(makeContext({
+            connectedIntegrations: ['github', 'slack', 'hubspot'],
+        }));
+        expect(skill.content).toContain('github, slack, hubspot');
+    });
+    it('includes MCP and skill counts', () => {
+        const skill = generateIntroSkill(makeContext({
+            mcpServerCount: 3,
+            skillCount: 5,
+        }));
+        expect(skill.content).toContain('3 MCP servers');
+        expect(skill.content).toContain('5 skills');
+    });
+    it('includes CLI commands section', () => {
+        const skill = generateIntroSkill(makeContext());
+        expect(skill.content).toContain('runwork info --json');
+        expect(skill.content).toContain('runwork dev');
+        expect(skill.content).toContain('runwork doctor');
+    });
+    it('includes references section', () => {
+        const skill = generateIntroSkill(makeContext());
+        expect(skill.content).toContain('https://www.runwork.ai');
+        expect(skill.content).toContain('changelog');
+    });
+    it('includes routing guidance', () => {
+        const skill = generateIntroSkill(makeContext());
+        expect(skill.content).toContain('workspace platform');
+        expect(skill.content).toContain('infrastructure');
+    });
+    it('deduplicates app names across registries', () => {
+        const skill = generateIntroSkill(makeContext({
+            registries: {
+                entities: [{ entityName: 'Task', appName: 'project-mgmt', appId: 'a1' }],
+                workflows: [{ name: 'notify', appName: 'project-mgmt', appId: 'a1' }],
+                schedules: [],
+                agents: [],
+                endpoints: [],
+                components: [],
+                fileStorages: [],
+            },
+        }));
+        // "project-mgmt" should appear in Apps section only once
+        const appsSection = skill.content.split('### Apps')[1]?.split('###')[0] || '';
+        const matches = appsSection.match(/project-mgmt/g);
+        expect(matches?.length).toBe(1);
+    });
+});
+describe('generateInstructionHint', () => {
+    const baseCtx = {
+        workspaceName: 'Test',
+        workspaceId: 'ws-test-123',
+        registries: null,
+        connectedIntegrations: [],
+        appCount: 0,
+        skillCount: 0,
+        mcpServerCount: 0,
+    };
+    it('includes workspace name', () => {
+        const hint = generateInstructionHint({ ...baseCtx, workspaceName: 'Acme Corp' });
+        expect(hint).toContain('Acme Corp');
+    });
+    it('includes runwork markers', () => {
+        const hint = generateInstructionHint(baseCtx);
+        expect(hint).toContain('<!-- runwork:start -->');
+        expect(hint).toContain('<!-- runwork:end -->');
+    });
+    it('mentions the runwork skill', () => {
+        const hint = generateInstructionHint(baseCtx);
+        expect(hint).toContain('runwork');
+        expect(hint).toContain('skill');
+    });
+    it('includes routing directive', () => {
+        const hint = generateInstructionHint(baseCtx);
+        expect(hint).toContain('Routing:');
+    });
+    it('includes inventory line', () => {
+        const hint = generateInstructionHint({ ...baseCtx, appCount: 2, skillCount: 3 });
+        expect(hint).toContain('2 apps');
+        expect(hint).toContain('3 skills');
+    });
+});

package/dist/agents/__tests__/schema-validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agents/__tests__/schema-validation.test.js

@@ -0,0 +1,212 @@
+/**
+ * Schema validation tests: run against REAL local agent data.
+ * Skipped in CI (no agents installed).
+ * Run locally with: RUNWORK_TEST_LOCAL_AGENTS=1 bun run test
+ *
+ * These tests catch when an agent update changes file formats
+ * that our readUsageStats() implementations depend on.
+ */
+import { describe, it, expect } from 'vitest';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { homedir, platform } from 'os';
+import { join } from 'path';
+import { querySqlite } from '../../utils/sqlite.js';
+const SKIP = !process.env.RUNWORK_TEST_LOCAL_AGENTS;
+const home = homedir();
+const os = platform();
+// ---------------------------------------------------------------------------
+// Claude Code
+// ---------------------------------------------------------------------------
+describe.skipIf(SKIP)('Schema: Claude Code', () => {
+    const claudeDir = join(home, '.claude');
+    it('stats-cache.json exists and has version + dailyActivity', () => {
+        const statsCachePath = join(claudeDir, 'stats-cache.json');
+        expect.soft(existsSync(statsCachePath)).toBe(true);
+        if (!existsSync(statsCachePath))
+            return;
+        const raw = JSON.parse(readFileSync(statsCachePath, 'utf-8'));
+        expect.soft(raw).toHaveProperty('version');
+        expect.soft(raw).toHaveProperty('dailyActivity');
+        expect.soft(Array.isArray(raw.dailyActivity)).toBe(true);
+    });
+    it('dailyActivity entries have expected shape', () => {
+        const statsCachePath = join(claudeDir, 'stats-cache.json');
+        if (!existsSync(statsCachePath))
+            return;
+        const raw = JSON.parse(readFileSync(statsCachePath, 'utf-8'));
+        if (!Array.isArray(raw.dailyActivity) || raw.dailyActivity.length === 0)
+            return;
+        const entry = raw.dailyActivity[0];
+        expect.soft(typeof entry.date).toBe('string');
+        expect.soft(typeof entry.messageCount).toBe('number');
+        expect.soft(typeof entry.sessionCount).toBe('number');
+        expect.soft(typeof entry.toolCallCount).toBe('number');
+    });
+    it('sessions directory exists and session files have expected fields', () => {
+        const sessionsDir = join(claudeDir, 'sessions');
+        if (!existsSync(sessionsDir))
+            return;
+        const files = readdirSync(sessionsDir).filter(f => f.endsWith('.json'));
+        if (files.length === 0)
+            return;
+        // Check the first file
+        const firstFile = join(sessionsDir, files[0]);
+        const session = JSON.parse(readFileSync(firstFile, 'utf-8'));
+        expect.soft(session).toHaveProperty('pid');
+        expect.soft(session).toHaveProperty('sessionId');
+        expect.soft(session).toHaveProperty('startedAt');
+    });
+});
+// ---------------------------------------------------------------------------
+// Claude Desktop
+// ---------------------------------------------------------------------------
+describe.skipIf(SKIP)('Schema: Claude Desktop', () => {
+    const getSessionsDir = () => {
+        if (os === 'darwin') {
+            return join(home, 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions');
+        }
+        if (os === 'win32') {
+            return join(process.env.APPDATA || join(home, 'AppData', 'Roaming'), 'Claude', 'local-agent-mode-sessions');
+        }
+        return join(home, '.config', 'Claude', 'local-agent-mode-sessions');
+    };
+    it('local-agent-mode-sessions directory exists (if Claude Desktop installed)', () => {
+        const sessionsDir = getSessionsDir();
+        // This test documents whether the directory exists; soft assert so it does not block others
+        expect.soft(existsSync(sessionsDir)).toBe(true);
+    });
+    it('session JSON files have expected shape', () => {
+        const sessionsDir = getSessionsDir();
+        if (!existsSync(sessionsDir))
+            return;
+        // Walk org/user/session structure to find a JSON file
+        const orgDirs = readdirSync(sessionsDir).filter(d => !d.startsWith('.') && d !== 'skills-plugin');
+        for (const orgDir of orgDirs) {
+            const orgPath = join(sessionsDir, orgDir);
+            let userDirs;
+            try {
+                userDirs = readdirSync(orgPath);
+            }
+            catch {
+                continue;
+            }
+            for (const userDir of userDirs) {
+                if (userDir.startsWith('.'))
+                    continue;
+                const userPath = join(orgPath, userDir);
+                let files;
+                try {
+                    files = readdirSync(userPath).filter(f => f.endsWith('.json'));
+                }
+                catch {
+                    continue;
+                }
+                if (files.length === 0)
+                    continue;
+                // Try each JSON file until we find one with session shape
+                for (const file of files) {
+                    try {
+                        const session = JSON.parse(readFileSync(join(userPath, file), 'utf-8'));
+                        // Skip non-session JSONs (must have sessionId to be a session)
+                        if (!session.sessionId)
+                            continue;
+                        expect.soft(session).toHaveProperty('sessionId');
+                        expect.soft(session).toHaveProperty('model');
+                        expect.soft(typeof session.createdAt).toBe('number');
+                        if (session.lastActivityAt !== undefined) {
+                            expect.soft(typeof session.lastActivityAt).toBe('number');
+                        }
+                        return; // Found one valid session, that is enough
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Codex
+// ---------------------------------------------------------------------------
+describe.skipIf(SKIP)('Schema: Codex', () => {
+    const codexDir = join(home, '.codex');
+    it('state_5.sqlite exists and has threads table', () => {
+        const dbPath = join(codexDir, 'state_5.sqlite');
+        if (!existsSync(dbPath))
+            return;
+        const result = querySqlite(dbPath, `SELECT name FROM sqlite_master WHERE type='table' AND name='threads'`);
+        expect.soft(result).toContain('threads');
+    });
+    it('threads table has expected columns', () => {
+        const dbPath = join(codexDir, 'state_5.sqlite');
+        if (!existsSync(dbPath))
+            return;
+        const result = querySqlite(dbPath, `PRAGMA table_info(threads)`);
+        expect.soft(result).toContain('id');
+        expect.soft(result).toContain('created_at');
+        expect.soft(result).toContain('tokens_used');
+        expect.soft(result).toContain('cli_version');
+    });
+    it('history.jsonl exists and lines have expected fields', () => {
+        const historyPath = join(codexDir, 'history.jsonl');
+        if (!existsSync(historyPath))
+            return;
+        const content = readFileSync(historyPath, 'utf-8').trim();
+        if (!content)
+            return;
+        const firstLine = content.split('\n')[0];
+        const entry = JSON.parse(firstLine);
+        expect.soft(entry).toHaveProperty('session_id');
+        expect.soft(entry).toHaveProperty('ts');
+    });
+    it('version.json has latest_version', () => {
+        const versionPath = join(codexDir, 'version.json');
+        if (!existsSync(versionPath))
+            return;
+        const data = JSON.parse(readFileSync(versionPath, 'utf-8'));
+        expect.soft(data).toHaveProperty('latest_version');
+    });
+});
+// ---------------------------------------------------------------------------
+// Cursor
+// ---------------------------------------------------------------------------
+describe.skipIf(SKIP)('Schema: Cursor', () => {
+    const getGlobalDbPath = () => {
+        if (os === 'darwin') {
+            return join(home, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+        }
+        if (os === 'win32') {
+            return join(process.env.APPDATA || join(home, 'AppData', 'Roaming'), 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+        }
+        return join(home, '.config', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+    };
+    it('state.vscdb exists and has cursorDiskKV table', () => {
+        const dbPath = getGlobalDbPath();
+        if (!existsSync(dbPath))
+            return;
+        const result = querySqlite(dbPath, `SELECT name FROM sqlite_master WHERE type='table' AND name='cursorDiskKV'`);
+        expect.soft(result).toContain('cursorDiskKV');
+    });
+    it('composerData entries exist and parse as JSON with expected fields', () => {
+        const dbPath = getGlobalDbPath();
+        if (!existsSync(dbPath))
+            return;
+        const result = querySqlite(dbPath, `SELECT value FROM cursorDiskKV WHERE key LIKE 'composerData-%' LIMIT 1`);
+        if (!result.trim())
+            return;
+        const data = JSON.parse(result.trim().split('\n')[0]);
+        expect.soft(data).toHaveProperty('composerId');
+        expect.soft(data).toHaveProperty('createdAt');
+    });
+    it('ai-code-tracking.db has scored_commits table with AI percentage columns', () => {
+        const trackingDbPath = join(home, '.cursor', 'ai-tracking', 'ai-code-tracking.db');
+        if (!existsSync(trackingDbPath))
+            return;
+        const tableResult = querySqlite(trackingDbPath, `SELECT name FROM sqlite_master WHERE type='table' AND name='scored_commits'`);
+        expect.soft(tableResult).toContain('scored_commits');
+        const columnsResult = querySqlite(trackingDbPath, `PRAGMA table_info(scored_commits)`);
+        expect.soft(columnsResult).toContain('v1AiPercentage');
+        expect.soft(columnsResult).toContain('v2AiPercentage');
+    });
+});

package/dist/agents/claude-code.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, McpServerEntry, SkillFile, SkillUsageEntry } from './types.js';
 export declare class ClaudeCodeAdapter implements AgentAdapter {
     name: string;
     slug: string;
@@ -7,4 +7,19 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     supportsSkills(): boolean;
     writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
     writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
+    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
+    writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
+    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
+    /** Remove the managed marker and all entries after it from a permissions array */
+    private removeAfterMarker;
+    readUsageStats(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
+    readSkillUsage(lastSyncAt: string | null): Promise<SkillUsageEntry[] | null>;
+    readVersion(): Promise<string | null>;
+    private getPluginsBaseDir;
+    private getPluginDir;
+    /** The marketplace root (contains marketplace.json and plugins/) */
+    private getMarketplaceRoot;
+    /** The plugin directory within the marketplace */
+    private getMarketplaceDir;
+    private registerPlugin;
 }