profclaw 0.0.1-beta.1

package/dist/skills/registry.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Skills Registry
+ *
+ * Central registry for managing skills and their snapshots.
+ * Supports MCP server discovery for dynamic capability extension.
+ */
+import type { SkillEntry, SkillSnapshot, SkillsSystemConfig } from './types.js';
+/**
+ * MCP Server capability info
+ */
+export interface MCPServerInfo {
+    name: string;
+    connected: boolean;
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema?: Record<string, unknown>;
+    }>;
+    resources?: Array<{
+        uri: string;
+        name: string;
+        description?: string;
+    }>;
+}
+/**
+ * Skills Registry - manages loaded skills and snapshots
+ */
+export declare class SkillsRegistry {
+    private entries;
+    private snapshot;
+    private snapshotVersion;
+    private config;
+    private workspaceDir;
+    private mcpServers;
+    /**
+     * Initialize the registry with a workspace
+     */
+    initialize(params: {
+        workspaceDir?: string;
+        config?: SkillsSystemConfig;
+    }): Promise<void>;
+    /**
+     * Reload all skills from disk
+     */
+    reload(): Promise<void>;
+    /**
+     * Register an MCP server and its capabilities
+     */
+    registerMCPServer(info: MCPServerInfo): void;
+    /**
+     * Unregister an MCP server
+     */
+    unregisterMCPServer(name: string): void;
+    /**
+     * Generate skill content from MCP server info
+     */
+    private generateMCPSkillContent;
+    /**
+     * Get all entries (raw, unfiltered)
+     */
+    getAllEntries(): SkillEntry[];
+    /**
+     * Get eligible entries based on current context
+     */
+    getEligibleEntries(): SkillEntry[];
+    /**
+     * Get a skill by name
+     */
+    getSkill(name: string): SkillEntry | undefined;
+    /**
+     * Get connected MCP servers
+     */
+    getMCPServers(): MCPServerInfo[];
+    /**
+     * Get or build skills snapshot for the current session
+     */
+    getSnapshot(): Promise<SkillSnapshot>;
+    /**
+     * Get skills prompt for injection into system message
+     */
+    getSkillsPrompt(): Promise<string>;
+    /**
+     * Estimate token cost of current skills
+     */
+    estimateTokenCost(): Promise<number>;
+    /**
+     * Update configuration
+     */
+    setConfig(config: SkillsSystemConfig): void;
+    /**
+     * Get list of loaded skill names
+     */
+    getLoadedSkillNames(): string[];
+    /**
+     * Get registry stats
+     */
+    getStats(): {
+        totalSkills: number;
+        bySource: Record<string, number>;
+        mcpServers: number;
+        estimatedTokens: number;
+    };
+}
+/**
+ * Get the global skills registry instance
+ */
+export declare function getSkillsRegistry(): SkillsRegistry;
+/**
+ * Initialize the global skills registry
+ */
+export declare function initializeSkillsRegistry(params: {
+    workspaceDir?: string;
+    config?: SkillsSystemConfig;
+}): Promise<SkillsRegistry>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/skills/registry.js

@@ -0,0 +1,225 @@
+/**
+ * Skills Registry
+ *
+ * Central registry for managing skills and their snapshots.
+ * Supports MCP server discovery for dynamic capability extension.
+ */
+import { loadAllSkills, filterSkills } from './loader.js';
+import { buildSkillSnapshot, estimateSkillsTokenCost } from './prompt-builder.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Skills Registry - manages loaded skills and snapshots
+ */
+export class SkillsRegistry {
+    entries = new Map();
+    snapshot = null;
+    snapshotVersion = 0;
+    config;
+    workspaceDir = null;
+    mcpServers = new Map();
+    /**
+     * Initialize the registry with a workspace
+     */
+    async initialize(params) {
+        this.workspaceDir = params.workspaceDir || null;
+        this.config = params.config;
+        await this.reload();
+    }
+    /**
+     * Reload all skills from disk
+     */
+    async reload() {
+        const allEntries = await loadAllSkills({
+            workspaceDir: this.workspaceDir || undefined,
+            extraDirs: this.config?.load?.extraDirs,
+        });
+        this.entries.clear();
+        for (const entry of allEntries) {
+            this.entries.set(entry.name, entry);
+        }
+        // Invalidate snapshot
+        this.snapshotVersion++;
+        this.snapshot = null;
+        logger.info(`[SkillsRegistry] Loaded ${this.entries.size} skills`);
+    }
+    /**
+     * Register an MCP server and its capabilities
+     */
+    registerMCPServer(info) {
+        this.mcpServers.set(info.name, info);
+        // Create a dynamic skill for this MCP server
+        const mcpSkill = {
+            name: `mcp-${info.name}`,
+            description: `MCP server: ${info.name} - ${info.tools.length} tools available`,
+            source: 'plugin', // MCP skills are treated as plugins
+            dirPath: `mcp://${info.name}`,
+            skillMdPath: `mcp://${info.name}/SKILL.md`,
+            frontmatter: {
+                name: `mcp-${info.name}`,
+                description: `MCP server capabilities for ${info.name}`,
+            },
+            metadata: {
+                toolCategories: info.tools.map((t) => t.name),
+            },
+            instructions: this.generateMCPSkillContent(info),
+            invocation: {
+                userInvocable: true,
+                modelInvocable: true,
+            },
+            eligible: true,
+            eligibilityErrors: [],
+            enabled: true,
+        };
+        this.entries.set(mcpSkill.name, mcpSkill);
+        // Invalidate snapshot
+        this.snapshotVersion++;
+        this.snapshot = null;
+        logger.info(`[SkillsRegistry] Registered MCP server: ${info.name} with ${info.tools.length} tools`);
+    }
+    /**
+     * Unregister an MCP server
+     */
+    unregisterMCPServer(name) {
+        this.mcpServers.delete(name);
+        this.entries.delete(`mcp-${name}`);
+        // Invalidate snapshot
+        this.snapshotVersion++;
+        this.snapshot = null;
+    }
+    /**
+     * Generate skill content from MCP server info
+     */
+    generateMCPSkillContent(info) {
+        const toolDocs = info.tools.map((tool) => {
+            const params = tool.inputSchema
+                ? `\nParameters: ${JSON.stringify(tool.inputSchema, null, 2)}`
+                : '';
+            return `### ${tool.name}\n${tool.description}${params}`;
+        }).join('\n\n');
+        const resourceDocs = info.resources && info.resources.length > 0
+            ? `\n## Resources\n\n${info.resources.map((r) => `- **${r.name}** (${r.uri}): ${r.description || 'No description'}`).join('\n')}`
+            : '';
+        return `# MCP Server: ${info.name}
+
+This server provides the following capabilities via MCP (Model Context Protocol).
+
+## Available Tools
+
+${toolDocs}
+${resourceDocs}
+
+## Usage
+
+Call these tools using the MCP protocol. The tools will be executed by the MCP server.
+`;
+    }
+    /**
+     * Get all entries (raw, unfiltered)
+     */
+    getAllEntries() {
+        return Array.from(this.entries.values());
+    }
+    /**
+     * Get eligible entries based on current context
+     */
+    getEligibleEntries() {
+        return filterSkills(this.getAllEntries(), this.config);
+    }
+    /**
+     * Get a skill by name
+     */
+    getSkill(name) {
+        return this.entries.get(name);
+    }
+    /**
+     * Get connected MCP servers
+     */
+    getMCPServers() {
+        return Array.from(this.mcpServers.values());
+    }
+    /**
+     * Get or build skills snapshot for the current session
+     */
+    async getSnapshot() {
+        // Return cached snapshot if still valid
+        if (this.snapshot && this.snapshot.version === this.snapshotVersion) {
+            return this.snapshot;
+        }
+        // Build fresh snapshot
+        this.snapshot = await buildSkillSnapshot({
+            workspaceDir: this.workspaceDir || undefined,
+            config: this.config,
+            entries: this.getAllEntries(),
+            version: this.snapshotVersion,
+        });
+        return this.snapshot;
+    }
+    /**
+     * Get skills prompt for injection into system message
+     */
+    async getSkillsPrompt() {
+        const snapshot = await this.getSnapshot();
+        return snapshot.prompt;
+    }
+    /**
+     * Estimate token cost of current skills
+     */
+    async estimateTokenCost() {
+        const eligible = this.getEligibleEntries();
+        const promptEntries = eligible.filter((e) => e.invocation.modelInvocable);
+        return estimateSkillsTokenCost(promptEntries);
+    }
+    /**
+     * Update configuration
+     */
+    setConfig(config) {
+        this.config = config;
+        // Invalidate snapshot on config change
+        this.snapshotVersion++;
+        this.snapshot = null;
+    }
+    /**
+     * Get list of loaded skill names
+     */
+    getLoadedSkillNames() {
+        return Array.from(this.entries.keys());
+    }
+    /**
+     * Get registry stats
+     */
+    getStats() {
+        const bySource = {};
+        for (const entry of this.entries.values()) {
+            const source = entry.source;
+            bySource[source] = (bySource[source] || 0) + 1;
+        }
+        const eligible = this.getEligibleEntries();
+        const promptEntries = eligible.filter((e) => e.invocation.modelInvocable);
+        return {
+            totalSkills: this.entries.size,
+            bySource,
+            mcpServers: this.mcpServers.size,
+            estimatedTokens: estimateSkillsTokenCost(promptEntries),
+        };
+    }
+}
+// Singleton instance
+let registryInstance = null;
+/**
+ * Get the global skills registry instance
+ */
+export function getSkillsRegistry() {
+    if (!registryInstance) {
+        registryInstance = new SkillsRegistry();
+    }
+    return registryInstance;
+}
+/**
+ * Initialize the global skills registry
+ */
+export async function initializeSkillsRegistry(params) {
+    const registry = getSkillsRegistry();
+    await registry.initialize(params);
+    return registry;
+}
+//# sourceMappingURL=registry.js.map

package/dist/skills/types.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Skills System - Core Types
+ *
+ * Modular capability system inspired by OpenClaw's SKILL.md format
+ * and the Agent Skills open specification.
+ *
+ * Skills are discoverable instruction packages that extend agent capabilities
+ * via progressive disclosure: metadata loads early, full instructions on demand.
+ */
+/** Parsed SKILL.md frontmatter (YAML header) */
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+    /** Whether users can invoke this skill via /command */
+    'user-invocable'?: boolean;
+    /** Whether AI models can auto-invoke this skill */
+    'disable-model-invocation'?: boolean;
+    /** Command dispatch to a tool */
+    'command-dispatch'?: 'tool';
+    'command-tool'?: string;
+    'command-arg-mode'?: 'raw' | 'parsed';
+    /** Extended metadata */
+    metadata?: string;
+}
+/** Extended metadata (parsed from frontmatter.metadata JSON) */
+export interface SkillMetadata {
+    /** Always enable this skill regardless of requirements */
+    always?: boolean;
+    /** Override skill key (for config lookups) */
+    skillKey?: string;
+    /** Primary environment variable (API key) */
+    primaryEnv?: string;
+    /** Visual identifier */
+    emoji?: string;
+    /** Documentation URL */
+    homepage?: string;
+    /** Supported platforms */
+    os?: ('darwin' | 'linux' | 'win32')[];
+    /** Required dependencies */
+    requires?: {
+        /** All of these binaries must be available */
+        bins?: string[];
+        /** At least one of these binaries must be available */
+        anyBins?: string[];
+        /** All of these env vars must be set */
+        env?: string[];
+        /** All of these config paths must be truthy */
+        config?: string[];
+    };
+    /** Installation instructions for dependencies */
+    install?: SkillInstallSpec[];
+    /** Tool categories this skill provides */
+    toolCategories?: string[];
+}
+/** How to install a missing dependency */
+export interface SkillInstallSpec {
+    kind: 'brew' | 'npm' | 'pnpm' | 'go' | 'pip' | 'download';
+    id?: string;
+    label?: string;
+    bins?: string[];
+    os?: string[];
+    formula?: string;
+    package?: string;
+    module?: string;
+    url?: string;
+    archive?: string;
+    extract?: boolean;
+    targetDir?: string;
+}
+/** Source of a skill */
+export type SkillSource = 'bundled' | 'managed' | 'workspace' | 'plugin';
+/** A loaded skill entry */
+export interface SkillEntry {
+    /** Unique skill name */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Source where this skill was loaded from */
+    source: SkillSource;
+    /** Directory path containing the skill */
+    dirPath: string;
+    /** SKILL.md file path */
+    skillMdPath: string;
+    /** Parsed frontmatter */
+    frontmatter: SkillFrontmatter;
+    /** Parsed extended metadata */
+    metadata?: SkillMetadata;
+    /** Full instructions (body of SKILL.md after frontmatter) */
+    instructions: string;
+    /** Invocation policy */
+    invocation: SkillInvocationPolicy;
+    /** Whether this skill is eligible (requirements met) */
+    eligible: boolean;
+    /** Reasons skill is ineligible (missing bins, env, etc.) */
+    eligibilityErrors: string[];
+    /** Whether this skill is enabled in config */
+    enabled: boolean;
+    /** Chat command spec (if user-invocable) */
+    command?: SkillCommandSpec;
+}
+/** Controls how the skill can be invoked */
+export interface SkillInvocationPolicy {
+    /** Users can invoke via /command */
+    userInvocable: boolean;
+    /** AI models can auto-invoke */
+    modelInvocable: boolean;
+}
+/** Chat command mapping */
+export interface SkillCommandSpec {
+    /** Command name (e.g., "python") for /python */
+    name: string;
+    /** Skill it maps to */
+    skillName: string;
+    /** Description (max 100 chars) */
+    description: string;
+    /** Optional: dispatch to a specific tool */
+    dispatch?: {
+        kind: 'tool';
+        toolName: string;
+        argMode?: 'raw' | 'parsed';
+    };
+}
+/** Snapshot of skill state for prompt injection */
+export interface SkillSnapshot {
+    /** Formatted skills prompt for AI model */
+    prompt: string;
+    /** Summary of available skills */
+    skills: Array<{
+        name: string;
+        description: string;
+        primaryEnv?: string;
+        source: SkillSource;
+    }>;
+    /** Resolved skill entries */
+    entries: SkillEntry[];
+    /** Change tracking version */
+    version: number;
+    /** When this snapshot was built */
+    builtAt: number;
+}
+/** Per-skill config (from settings) */
+export interface SkillConfig {
+    enabled?: boolean;
+    apiKey?: string;
+    env?: Record<string, string>;
+    config?: Record<string, unknown>;
+}
+/** Skills system configuration */
+export interface SkillsSystemConfig {
+    /** Directories to load skills from */
+    load: {
+        /** Additional skill directories */
+        extraDirs: string[];
+        /** Watch for file changes */
+        watch: boolean;
+        /** Debounce delay for file watcher */
+        watchDebounceMs: number;
+    };
+    /** Installation preferences */
+    install: {
+        /** Prefer brew over other package managers */
+        preferBrew: boolean;
+        /** Node package manager */
+        nodeManager: 'npm' | 'pnpm' | 'yarn';
+    };
+    /** Per-skill configuration overrides */
+    entries: Record<string, SkillConfig>;
+    /** Bundled skills allowlist (empty = all allowed) */
+    allowBundled: string[];
+}
+/** Default configuration */
+export declare const DEFAULT_SKILLS_CONFIG: SkillsSystemConfig;
+/** Detailed status for a single skill */
+export interface SkillStatus {
+    name: string;
+    source: SkillSource;
+    enabled: boolean;
+    eligible: boolean;
+    errors: string[];
+    missing: {
+        bins: string[];
+        env: string[];
+        config: string[];
+    };
+    installOptions: SkillInstallSpec[];
+    metadata?: SkillMetadata;
+}
+/** Overall skills system status */
+export interface SkillsStatus {
+    totalLoaded: number;
+    totalEligible: number;
+    totalEnabled: number;
+    skills: SkillStatus[];
+    sources: {
+        bundled: number;
+        managed: number;
+        workspace: number;
+        plugin: number;
+    };
+    version: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/skills/types.js

@@ -0,0 +1,24 @@
+/**
+ * Skills System - Core Types
+ *
+ * Modular capability system inspired by OpenClaw's SKILL.md format
+ * and the Agent Skills open specification.
+ *
+ * Skills are discoverable instruction packages that extend agent capabilities
+ * via progressive disclosure: metadata loads early, full instructions on demand.
+ */
+/** Default configuration */
+export const DEFAULT_SKILLS_CONFIG = {
+    load: {
+        extraDirs: [],
+        watch: true,
+        watchDebounceMs: 250,
+    },
+    install: {
+        preferBrew: true,
+        nodeManager: 'pnpm',
+    },
+    entries: {},
+    allowBundled: [],
+};
+//# sourceMappingURL=types.js.map

package/dist/states/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * States Service
+ *
+ * Manages customizable workflow states for projects.
+ * Maps custom states to core StateGroups (backlog, unstarted, started, completed, cancelled).
+ */
+import type { StateGroup } from '../tickets/types.js';
+export interface State {
+    id: string;
+    projectId: string | null;
+    name: string;
+    slug: string;
+    color: string;
+    description: string | null;
+    stateGroup: StateGroup;
+    isDefault: boolean;
+    sequence: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface CreateStateInput {
+    projectId?: string;
+    name: string;
+    slug?: string;
+    color?: string;
+    description?: string;
+    stateGroup: StateGroup;
+    isDefault?: boolean;
+    sequence?: number;
+}
+export interface UpdateStateInput {
+    name?: string;
+    slug?: string;
+    color?: string;
+    description?: string;
+    statusGroup?: StateGroup;
+    isDefault?: boolean;
+    sequence?: number;
+}
+/**
+ * Create a new state
+ */
+export declare function createState(input: CreateStateInput): Promise<State>;
+/**
+ * Get a state by ID
+ */
+export declare function getState(id: string): Promise<State | null>;
+/**
+ * List states for a project
+ */
+export declare function listStates(projectId?: string): Promise<State[]>;
+/**
+ * Update a state
+ */
+export declare function updateState(id: string, input: UpdateStateInput): Promise<State>;
+/**
+ * Delete a state
+ */
+export declare function deleteState(id: string): Promise<void>;
+/**
+ * Initialize default states for a new project
+ */
+export declare function initializeProjectStates(projectId: string): Promise<State[]>;
+//# sourceMappingURL=index.d.ts.map