@bluefly/openstandardagents 0.4.4 → 0.4.6

package/dist/adapters/cursor/adapter.js

@@ -0,0 +1,478 @@
+/**
+ * Cursor Cloud Agent Platform Adapter
+ * Exports OSSA agent manifests to Cursor Cloud Agent format
+ *
+ * Cursor Cloud Agents are AI agents that run in the Cursor IDE
+ * https://cursor.com/docs/cloud-agent
+ *
+ * SOLID: Single Responsibility - Cursor agent generation only
+ * DRY: Extends BaseExporter for orchestration, validation, and common files
+ */
+import { BaseExporter } from '../base/base-exporter.js';
+export class CursorAdapter extends BaseExporter {
+    platform = 'cursor';
+    displayName = 'Cursor Cloud Agent';
+    description = 'Cursor Cloud Agent for AI-powered coding assistance in Cursor IDE';
+    status = 'beta';
+    supportedVersions = ['v{{VERSION}}'];
+    /**
+     * Platform-specific validation for Cursor compatibility
+     */
+    platformValidate(manifest) {
+        const errors = [];
+        const warnings = [];
+        const spec = manifest.spec;
+        // Check for role/system prompt
+        if (!spec?.role) {
+            errors.push({
+                message: 'spec.role is required for Cursor agents (system prompt)',
+                path: 'spec.role',
+                code: 'MISSING_REQUIRED_FIELD',
+            });
+        }
+        // Check for tools
+        if (!spec?.tools || !Array.isArray(spec.tools) || spec.tools.length === 0) {
+            warnings.push({
+                message: 'No tools defined, agent will have limited capabilities',
+                path: 'spec.tools',
+                suggestion: 'Add spec.tools array with tool definitions',
+            });
+        }
+        return { errors, warnings };
+    }
+    /**
+     * Generate Cursor-specific files
+     */
+    async generateFiles(manifest, options) {
+        const agentName = this.getAgentName(manifest, 'cursor-agent');
+        const prefix = `cursor/${agentName}`;
+        const files = [];
+        // Generate cursor-agent.json - Cursor agent configuration
+        const cursorAgent = this.convertToCursorAgent(manifest);
+        const config = {
+            version: '1.0',
+            agent: cursorAgent,
+        };
+        files.push(this.createFile(`${prefix}/cursor-agent.json`, JSON.stringify(config, null, 2), 'config', 'json'));
+        // Generate tool implementations
+        cursorAgent.tools.forEach((tool) => {
+            if (tool.implementationType === 'code') {
+                files.push(this.createFile(`${prefix}/tools/${tool.name}.ts`, this.generateToolImplementation(tool, manifest), 'code', 'typescript'));
+            }
+        });
+        // Generate agent.ts - Main agent entry point
+        files.push(this.createFile(`${prefix}/agent.ts`, this.generateAgentCode(manifest, cursorAgent), 'code', 'typescript'));
+        // Use shared generators for common files
+        files.push(this.generatePackageJsonFile(manifest, prefix, {
+            main: 'agent.js',
+            scripts: {
+                build: 'tsc',
+                dev: 'tsx agent.ts',
+                watch: 'tsx watch agent.ts',
+            },
+            devDependencies: {
+                '@types/node': '^20.0.0',
+                typescript: '^5.0.0',
+                tsx: '^4.0.0',
+            },
+            extraKeywords: ['cursor', 'cloud-agent', 'coding-assistant'],
+        }));
+        files.push(this.generateTsConfigFile(prefix, { include: ['**/*.ts'] }));
+        const toolsDesc = cursorAgent.tools
+            .map((t) => `- **${t.name}**: ${t.description}`)
+            .join('\n');
+        files.push(this.generateReadmeFile(manifest, prefix, {
+            installation: 'npm install\nnpm run build',
+            usage: `Configure in Cursor Settings > Cloud Agents:\n\n\`\`\`json\n{\n  "cloudAgents": [\n    {\n      "name": "${agentName}",\n      "path": "./cursor/${agentName}/agent.js"\n    }\n  ]\n}\`\`\``,
+            additional: toolsDesc
+                ? [
+                    {
+                        title: 'Capabilities',
+                        content: cursorAgent.capabilities
+                            .map((c) => `- ${c.type}`)
+                            .join('\n'),
+                    },
+                    { title: 'Available Tools', content: toolsDesc },
+                ]
+                : undefined,
+        }));
+        return files;
+    }
+    /**
+     * Get example Cursor-optimized manifest
+     */
+    getExample() {
+        return {
+            apiVersion: 'ossa/v{{VERSION}}',
+            kind: 'Agent',
+            metadata: {
+                name: 'cursor-coding-assistant',
+                version: '1.0.0',
+                description: 'AI coding assistant for Cursor IDE',
+            },
+            spec: {
+                role: 'You are an expert coding assistant that helps developers write clean, efficient code. You specialize in code generation, refactoring, and providing best practices guidance.',
+                capabilities: [
+                    'code-generation',
+                    'code-review',
+                    'refactoring',
+                    'testing',
+                ],
+                tools: [
+                    {
+                        type: 'function',
+                        name: 'generate_code',
+                        description: 'Generate code based on natural language description',
+                    },
+                    {
+                        type: 'function',
+                        name: 'refactor_code',
+                        description: 'Refactor existing code for better quality',
+                    },
+                ],
+            },
+        };
+    }
+    /**
+     * Convert OSSA manifest to Cursor Cloud Agent
+     */
+    convertToCursorAgent(manifest) {
+        const name = manifest.metadata?.name || 'cursor-agent';
+        const description = manifest.metadata?.description || 'Cursor Cloud Agent';
+        const prompt = manifest.spec?.role || 'AI coding assistant';
+        const capabilities = this.extractCapabilities(manifest);
+        const tools = this.convertTools(manifest);
+        const context = {
+            workspace: {
+                includeFiles: true,
+                includePatterns: ['**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx'],
+                excludePatterns: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+                maxFileSize: 1024 * 1024,
+            },
+            indexing: { enabled: true, depth: 3 },
+            memory: { enabled: true, maxEntries: 100 },
+            integrations: { git: true, lsp: true, terminal: true },
+        };
+        return {
+            name,
+            description,
+            prompt,
+            capabilities,
+            tools,
+            context,
+            metadata: {
+                version: manifest.metadata?.version,
+                author: manifest.metadata?.author,
+                tags: manifest.metadata?.tags,
+            },
+        };
+    }
+    /**
+     * Extract capabilities from manifest
+     */
+    extractCapabilities(manifest) {
+        const capabilities = [];
+        const capabilityMap = {
+            'code-generation': 'code-generation',
+            'code-review': 'code-review',
+            refactoring: 'refactoring',
+            testing: 'testing',
+            documentation: 'documentation',
+            debugging: 'debugging',
+            terminal: 'terminal',
+        };
+        const ossaCaps = this.getCapabilities(manifest);
+        ossaCaps.forEach((cap) => {
+            const type = capabilityMap[cap] || 'custom';
+            capabilities.push({ type });
+        });
+        if (capabilities.length === 0) {
+            capabilities.push({ type: 'code-generation' });
+        }
+        return capabilities;
+    }
+    /**
+     * Convert OSSA tools to Cursor tools
+     */
+    convertTools(manifest) {
+        const tools = [];
+        const ossaTools = this.getTools(manifest);
+        ossaTools.forEach((tool) => {
+            const name = tool.name || 'unknown';
+            const description = tool.description || `Tool: ${name}`;
+            const schema = (tool.inputSchema ||
+                tool.schema || { type: 'object' });
+            tools.push({
+                name,
+                description,
+                parameters: schema,
+                implementation: `/** Customize: call your tool runner or MCP here. */\nexport async function ${name}(params: any) {\n  return { success: true, data: params };\n}`,
+                implementationType: 'code',
+            });
+        });
+        return tools;
+    }
+    /**
+     * Generate tool implementation
+     */
+    generateToolImplementation(tool, manifest) {
+        const paramType = this.generateParamType(tool.parameters);
+        return `/**
+ * Tool Implementation: ${tool.name}
+ * ${tool.description}
+ * Generated from OSSA manifest
+ */
+
+${paramType}
+
+/**
+ * ${tool.description}
+ * Customize: call your tool runner or MCP here.
+ */
+export async function ${tool.name}(params: ${tool.name}Params): Promise<${tool.name}Result> {
+  return { success: true, data: params };
+}
+
+/**
+ * Tool result type
+ */
+export interface ${tool.name}Result {
+  success: boolean;
+  data?: unknown;
+  error?: string;
+}
+`;
+    }
+    /**
+     * Generate TypeScript parameter type from JSON Schema
+     */
+    generateParamType(schema) {
+        if (!schema.properties) {
+            return `export interface Params {\n  [key: string]: unknown;\n}`;
+        }
+        const props = Object.entries(schema.properties)
+            .map(([key, prop]) => {
+            const required = schema.required?.includes(key);
+            const type = this.jsonSchemaTypeToTS(prop.type);
+            return `  ${key}${required ? '' : '?'}: ${type};${prop.description ? ` // ${prop.description}` : ''}`;
+        })
+            .join('\n');
+        return `/**
+ * Tool parameters
+ */
+export interface ${schema.title || 'Tool'}Params {
+${props}
+}`;
+    }
+    /**
+     * Convert JSON Schema type to TypeScript type
+     */
+    jsonSchemaTypeToTS(type) {
+        const typeMap = {
+            string: 'string',
+            number: 'number',
+            integer: 'number',
+            boolean: 'boolean',
+            array: 'unknown[]',
+            object: 'Record<string, unknown>',
+        };
+        return typeMap[type] || 'unknown';
+    }
+    /**
+     * Generate agent.ts - Main entry point
+     */
+    generateAgentCode(manifest, agent) {
+        const imports = agent.tools
+            .filter((t) => t.implementationType === 'code')
+            .map((t) => `import { ${t.name} } from './tools/${t.name}.js';`)
+            .join('\n');
+        const toolRegistry = agent.tools
+            .map((t) => `  '${t.name}': ${t.implementationType === 'code' ? t.name : `async (params: unknown) => ({ success: true, data: params })`},`)
+            .join('\n');
+        return `/**
+ * Cursor Cloud Agent: ${agent.name}
+ * ${agent.description}
+ * Generated from OSSA manifest
+ */
+
+${imports}
+
+/**
+ * Agent configuration
+ */
+export const agentConfig = {
+  name: '${agent.name}',
+  description: '${agent.description}',
+  prompt: \`${agent.prompt}\`,
+  capabilities: ${JSON.stringify(agent.capabilities, null, 2)},
+  context: ${JSON.stringify(agent.context, null, 2)},
+};
+
+/**
+ * Tool registry
+ */
+export const tools = {
+${toolRegistry}
+};
+
+/**
+ * Execute agent tool
+ */
+export async function executeTool(name: string, params: any): Promise<any> {
+  const tool = tools[name as keyof typeof tools];
+  if (!tool) {
+    throw new Error(\`Unknown tool: \${name}\`);
+  }
+  return await tool(params);
+}
+
+/**
+ * Agent initialization
+ */
+export async function initialize(): Promise<void> {
+  console.log('Cursor agent initialized:', agentConfig.name);
+}
+`;
+    }
+    /**
+     * Generate package.json
+     */
+    generatePackageJson(manifest) {
+        const pkg = {
+            name: manifest.metadata?.name || 'cursor-agent',
+            version: manifest.metadata?.version || '1.0.0',
+            description: manifest.metadata?.description ||
+                'Cursor Cloud Agent generated from OSSA',
+            type: 'module',
+            main: 'agent.js',
+            scripts: {
+                build: 'tsc',
+                dev: 'tsx agent.ts',
+                watch: 'tsx watch agent.ts',
+            },
+            dependencies: {},
+            devDependencies: {
+                '@types/node': '^20.0.0',
+                typescript: '^5.0.0',
+                tsx: '^4.0.0',
+            },
+            keywords: ['cursor', 'cloud-agent', 'ai', 'ossa', 'coding-assistant'],
+            license: manifest.metadata?.license || 'MIT',
+        };
+        return JSON.stringify(pkg, null, 2);
+    }
+    /**
+     * Generate tsconfig.json
+     */
+    generateTsConfig() {
+        const config = {
+            compilerOptions: {
+                target: 'ES2022',
+                module: 'Node16',
+                moduleResolution: 'Node16',
+                outDir: '.',
+                rootDir: '.',
+                strict: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                resolveJsonModule: true,
+                declaration: true,
+            },
+            include: ['**/*.ts'],
+            exclude: ['node_modules', '**/*.js'],
+        };
+        return JSON.stringify(config, null, 2);
+    }
+    /**
+     * Generate README.md
+     */
+    generateReadme(manifest, agent) {
+        const agentName = manifest.metadata?.name || 'cursor-agent';
+        return `# ${agentName}
+
+${agent.description}
+
+## Cursor Cloud Agent
+
+This agent is designed for use with [Cursor IDE](https://cursor.com/), providing AI-powered coding assistance.
+
+## Installation
+
+1. **Install dependencies:**
+
+\`\`\`bash
+npm install
+\`\`\`
+
+2. **Build the agent:**
+
+\`\`\`bash
+npm run build
+\`\`\`
+
+3. **Configure in Cursor:**
+
+Add to your Cursor settings (\`Settings > Cloud Agents\`):
+
+\`\`\`json
+{
+  "cloudAgents": [
+    {
+      "name": "${agentName}",
+      "path": "${process.cwd()}/cursor/${agentName}/agent.js"
+    }
+  ]
+}
+\`\`\`
+
+## Agent Configuration
+
+**System Prompt:**
+
+\`\`\`
+${agent.prompt}
+\`\`\`
+
+**Capabilities:**
+
+${agent.capabilities.map((c) => `- ${c.type}`).join('\n')}
+
+## Available Tools
+
+${agent.tools
+            .map((t) => `### ${t.name}
+
+${t.description}
+
+**Parameters:**
+
+\`\`\`typescript
+${this.generateParamType(t.parameters)}
+\`\`\`
+`)
+            .join('\n')}
+
+## Development
+
+\`\`\`bash
+# Watch mode
+npm run dev
+
+# Build
+npm run build
+\`\`\`
+
+## Generated from OSSA
+
+This agent was generated from an OSSA v${manifest.apiVersion?.split('/')[1] || '{{VERSION}}'} manifest.
+
+Original manifest: \`agent.ossa.yaml\`
+
+## License
+
+${manifest.metadata?.license || 'MIT'}
+`;
+    }
+}
+//# sourceMappingURL=adapter.js.map

package/dist/adapters/cursor/types.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Cursor Cloud Agent Type Definitions
+ * https://cursor.com/docs/cloud-agent
+ */
+/**
+ * Cursor Cloud Agent Definition
+ */
+export interface CursorCloudAgent {
+    /**
+     * Agent name
+     */
+    name: string;
+    /**
+     * Agent description
+     */
+    description: string;
+    /**
+     * System prompt for agent behavior
+     */
+    prompt: string;
+    /**
+     * Agent capabilities
+     */
+    capabilities: CursorCapability[];
+    /**
+     * Agent tools
+     */
+    tools: CursorTool[];
+    /**
+     * Agent context configuration
+     */
+    context: CursorContext;
+    /**
+     * Agent metadata
+     */
+    metadata?: {
+        version?: string;
+        author?: string;
+        tags?: string[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Cursor Agent Capability
+ */
+export interface CursorCapability {
+    /**
+     * Capability type
+     */
+    type: 'code-generation' | 'code-review' | 'refactoring' | 'testing' | 'documentation' | 'debugging' | 'terminal' | 'custom';
+    /**
+     * Capability configuration
+     */
+    config?: {
+        /**
+         * Programming languages supported
+         */
+        languages?: string[];
+        /**
+         * Frameworks supported
+         */
+        frameworks?: string[];
+        /**
+         * Additional configuration
+         */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Cursor Agent Tool
+ */
+export interface CursorTool {
+    /**
+     * Tool name
+     */
+    name: string;
+    /**
+     * Tool description
+     */
+    description: string;
+    /**
+     * Tool parameters (JSON Schema)
+     */
+    parameters: JSONSchema;
+    /**
+     * Tool implementation
+     * - Code string (JavaScript/TypeScript)
+     * - API endpoint URL
+     * - Shell command
+     */
+    implementation: string;
+    /**
+     * Implementation type
+     */
+    implementationType?: 'code' | 'api' | 'shell';
+    /**
+     * Tool examples
+     */
+    examples?: CursorToolExample[];
+}
+/**
+ * Tool example
+ */
+export interface CursorToolExample {
+    /**
+     * Example input
+     */
+    input: Record<string, unknown>;
+    /**
+     * Expected output
+     */
+    output: unknown;
+    /**
+     * Example description
+     */
+    description?: string;
+}
+/**
+ * Cursor Agent Context Configuration
+ */
+export interface CursorContext {
+    /**
+     * Workspace configuration
+     */
+    workspace?: {
+        /**
+         * Include workspace files in context
+         */
+        includeFiles?: boolean;
+        /**
+         * File patterns to include
+         */
+        includePatterns?: string[];
+        /**
+         * File patterns to exclude
+         */
+        excludePatterns?: string[];
+        /**
+         * Maximum file size (bytes)
+         */
+        maxFileSize?: number;
+    };
+    /**
+     * Codebase indexing
+     */
+    indexing?: {
+        /**
+         * Enable semantic code search
+         */
+        enabled?: boolean;
+        /**
+         * Indexing depth
+         */
+        depth?: number;
+    };
+    /**
+     * Memory configuration
+     */
+    memory?: {
+        /**
+         * Enable conversation memory
+         */
+        enabled?: boolean;
+        /**
+         * Maximum memory entries
+         */
+        maxEntries?: number;
+    };
+    /**
+     * External integrations
+     */
+    integrations?: {
+        /**
+         * Git integration
+         */
+        git?: boolean;
+        /**
+         * LSP integration
+         */
+        lsp?: boolean;
+        /**
+         * Terminal integration
+         */
+        terminal?: boolean;
+    };
+}
+/**
+ * JSON Schema type
+ */
+export interface JSONSchema {
+    type: string;
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+    additionalProperties?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * JSON Schema Property
+ */
+export interface JSONSchemaProperty {
+    type: string;
+    description?: string;
+    default?: unknown;
+    enum?: unknown[];
+    items?: JSONSchemaProperty;
+    [key: string]: unknown;
+}
+/**
+ * Cursor Agent Configuration File
+ */
+export interface CursorAgentConfig {
+    /**
+     * Config file version
+     */
+    version: '1.0';
+    /**
+     * Agent definition
+     */
+    agent: CursorCloudAgent;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/adapters/cursor/types.js

@@ -0,0 +1,6 @@
+/**
+ * Cursor Cloud Agent Type Definitions
+ * https://cursor.com/docs/cloud-agent
+ */
+export {};
+//# sourceMappingURL=types.js.map