runwork 0.15.1 → 0.16.0

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

@@ -1,193 +0,0 @@
-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('MCP Servers');
-        expect(skill.content).toContain('3 servers configured');
-        expect(skill.content).toContain('5 skills configured');
-    });
-    it('includes MCP and skill names when provided', () => {
-        const skill = generateIntroSkill(makeContext({
-            mcpServerCount: 2,
-            skillCount: 2,
-            mcpServerNames: ['Runwork', 'aTars MCP'],
-            skillNames: ['Developer Tools', 'Writing Plans'],
-        }));
-        expect(skill.content).toContain('MCP Servers (2)');
-        expect(skill.content).toContain('Runwork');
-        expect(skill.content).toContain('Skills (2)');
-        expect(skill.content).toContain('Developer Tools');
-    });
-    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('uses canonical install commands and does not reference the old @runworkai/cli package', () => {
-        const skill = generateIntroSkill(makeContext());
-        expect(skill.content).toContain('curl -fsSL https://runwork.ai/install.sh | sh');
-        expect(skill.content).toContain('brew install runwork-ai/tap/runwork');
-        expect(skill.content).toContain('npx runwork@latest');
-        expect(skill.content).toContain('bunx runwork@latest');
-        expect(skill.content).not.toContain('@runworkai/cli');
-        expect(skill.content).not.toContain('npm install -g runwork');
-    });
-    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 the default-to-Runwork routing directive', () => {
-        // The earlier hint format used a "Routing:" header; the current format
-        // expresses the same idea as a "Default to Runwork" rule plus an explicit
-        // routing table. Either of those two anchors is sufficient guidance.
-        const hint = generateInstructionHint(baseCtx);
-        expect(hint).toContain('Default to Runwork');
-        expect(hint).toContain('| User asks for | Use Runwork | Don\'t |');
-    });
-    it('includes inventory line', () => {
-        const hint = generateInstructionHint({ ...baseCtx, appCount: 2, skillCount: 3 });
-        expect(hint).toContain('2 apps');
-        expect(hint).toContain('3 skills');
-    });
-    it('omits the persona block when no persona is provided', () => {
-        const hint = generateInstructionHint(baseCtx);
-        expect(hint).not.toContain('Communicating with this user');
-    });
-    it('omits the persona block for engineers (level 3)', () => {
-        const hint = generateInstructionHint({ ...baseCtx, persona: { level: 3, label: 'engineer' } });
-        expect(hint).not.toContain('Communicating with this user');
-    });
-    it('adds an everyday persona block (level 1) telling agents to avoid dev tooling', () => {
-        const hint = generateInstructionHint({ ...baseCtx, persona: { level: 1, label: 'everyday' } });
-        expect(hint).toContain('Communicating with this user');
-        expect(hint).toContain('not a software developer');
-        expect(hint).toContain('npm, bun, node');
-        // The persona block must stay inside the replaceable runwork markers.
-        const start = hint.indexOf('<!-- runwork:start -->');
-        const end = hint.indexOf('<!-- runwork:end -->');
-        expect(hint.indexOf('Communicating with this user')).toBeGreaterThan(start);
-        expect(hint.indexOf('Communicating with this user')).toBeLessThan(end);
-    });
-    it('adds a curious persona block (level 2)', () => {
-        const hint = generateInstructionHint({ ...baseCtx, persona: { level: 2, label: 'curious' } });
-        expect(hint).toContain('Communicating with this user');
-        expect(hint).toContain('some familiarity with AI tools');
-    });
-});
-describe('generateIntroSkill — environment variables', () => {
-    it('documents that apps have no custom env var system', () => {
-        const skill = generateIntroSkill(makeContext());
-        expect(skill.content).toContain('Environment variables and secrets');
-        expect(skill.content).toContain('do NOT have a custom environment variable');
-        expect(skill.content).toContain('.env');
-    });
-});

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

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

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

@@ -1,212 +0,0 @@
-/**
- * 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/__tests__/skill-slug.test.d.ts

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

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

@@ -1,77 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toSlug, buildSkillMd } from '../types.js';
-describe('toSlug', () => {
-    it('converts spaces to hyphens', () => {
-        expect(toSlug('Write Cold Email')).toBe('write-cold-email');
-    });
-    it('lowercases', () => {
-        expect(toSlug('Developer Tools')).toBe('developer-tools');
-    });
-    it('collapses multiple non-alphanumeric chars', () => {
-        expect(toSlug('Link generate - quote payment')).toBe('link-generate-quote-payment');
-    });
-    it('strips leading and trailing hyphens', () => {
-        expect(toSlug('--test--')).toBe('test');
-        expect(toSlug('  hello  ')).toBe('hello');
-    });
-    it('preserves already-slugified names', () => {
-        expect(toSlug('my-skill')).toBe('my-skill');
-        expect(toSlug('runwork')).toBe('runwork');
-    });
-    it('handles special characters', () => {
-        expect(toSlug('Y Combinator slide maker')).toBe('y-combinator-slide-maker');
-        expect(toSlug("my test skill 1")).toBe('my-test-skill-1');
-    });
-});
-describe('buildSkillMd', () => {
-    function makeSkill(overrides = {}) {
-        return {
-            name: 'Write Cold Email',
-            filename: 'write-cold-email',
-            content: 'Some skill content',
-            description: 'A skill for writing emails',
-            ...overrides,
-        };
-    }
-    it('generates frontmatter with slugified name when no frontmatter exists', () => {
-        const result = buildSkillMd(makeSkill());
-        expect(result).toContain('name: write-cold-email');
-        expect(result).not.toContain('name: Write Cold Email');
-        expect(result).toContain('description: A skill for writing emails');
-        expect(result).toContain('Some skill content');
-    });
-    it('normalizes name in existing frontmatter', () => {
-        const result = buildSkillMd(makeSkill({
-            content: '---\nname: Write Cold Email\ndescription: existing desc\n---\n\nBody',
-        }));
-        expect(result).toContain('name: write-cold-email');
-        expect(result).not.toContain('name: Write Cold Email');
-        expect(result).toContain('description: existing desc');
-    });
-    it('normalizes quoted name in existing frontmatter', () => {
-        const result = buildSkillMd(makeSkill({
-            content: '---\nname: "Developer Tools"\ndescription: dev tools\n---\n\nBody',
-            name: 'Developer Tools',
-            filename: 'developer-tools',
-        }));
-        expect(result).toContain('name: developer-tools');
-        expect(result).not.toContain('Developer Tools');
-    });
-    it('preserves already-slugified name in existing frontmatter', () => {
-        const result = buildSkillMd(makeSkill({
-            content: '---\nname: write-cold-email\ndescription: desc\n---\n\nBody',
-        }));
-        expect(result).toContain('name: write-cold-email');
-    });
-    it('injects description when frontmatter exists without one', () => {
-        const result = buildSkillMd(makeSkill({
-            content: '---\nsome-key: value\n---\n\nBody',
-        }));
-        expect(result).toContain('name: write-cold-email');
-        expect(result).toContain('description: A skill for writing emails');
-    });
-    it('uses default description when none provided', () => {
-        const result = buildSkillMd(makeSkill({ description: '' }));
-        expect(result).toContain('description: Write Cold Email skill');
-    });
-});

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

@@ -1,59 +0,0 @@
-import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile, SkillUsageEntry } from './types.js';
-export declare class ClaudeCodeAdapter implements AgentAdapter {
-    name: string;
-    slug: string;
-    mcpProvidesSkills: boolean;
-    detect(): Promise<boolean>;
-    supportsMcpScope(_scope: 'project' | 'user'): boolean;
-    supportsSkills(): boolean;
-    writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
-    /**
-     * Install the Runwork SessionStart hook into the plugin tree (user scope).
-     * The hook writes ~/.runwork/sessions/<sessionId>.json with the active
-     * conversation's transcript path + metadata, used by `runwork share-convo`
-     * for high-fidelity capture and by `runwork resume` for placement.
-     *
-     * Called as part of user-scope writeSkills() to keep sync flow consistent.
-     * Emits a one-line confirmation matching the format other adapter steps
-     * use (`  [Claude Code] Installed ... (user)`) so `runwork sync` output
-     * shows whether the hook actually landed.
-     */
-    private installSessionStartHook;
-    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
-    /**
-     * Install the runwork SessionStart hook for Claude Code (user scope only).
-     * Called once per sync by the main sync loop AFTER writeSkills has
-     * populated the plugin directories. Kept separate from writeSkills because
-     * writeSkills is also invoked per-skill by the diff executor during
-     * push/pull, and the hook install + log line must not repeat for every
-     * skill change.
-     */
-    writeBuiltInHooks(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', baseline?: {
-        allow?: string[];
-        deny?: string[];
-    }): Promise<void>;
-    /**
-     * Markerless adapter: removal detection relies on the `baseline`
-     * (state.lastInjected) passed to writeAgentConfig, exactly like Cursor, since
-     * the adapter no longer writes an on-disk sentinel to delimit its entries.
-     * Returning undefined tells the sync loop to skip on-disk removal detection.
-     */
-    readManagedBlock(_scope: 'project' | 'user'): Promise<{
-        allow?: string[];
-        deny?: string[];
-    } | undefined>;
-    cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
-    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;
-}