@bluefly/openstandardagents 0.4.5 → 0.4.8

package/dist/adapters/symfony/platform-adapter.js

@@ -0,0 +1,317 @@
+/**
+ * Symfony AI Agent Export Adapter
+ *
+ * Exports OSSA agent manifests to PHP bootstrap for symfony/ai-agent:
+ * Platform + Model + system message + Toolbox from manifest.
+ * See: https://symfony.com/doc/current/ai/components/agent.html
+ *
+ * Generated: composer.json, agent_bootstrap.php, README.md, agent.ossa.yaml.
+ */
+import * as yaml from 'yaml';
+import { BaseAdapter } from '../base/adapter.interface.js';
+function sanitizeName(name) {
+    return (name.replace(/[^a-z0-9_]/gi, '_').replace(/^_+|_+$/g, '') || 'ossa_agent');
+}
+function escapePhpString(s) {
+    return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n');
+}
+export class SymfonyAiPlatformAdapter extends BaseAdapter {
+    platform = 'symfony';
+    displayName = 'Symfony AI Agent';
+    description = 'PHP bootstrap for symfony/ai-agent (Platform + Model + Toolbox from OSSA)';
+    status = 'alpha';
+    supportedVersions = ['v0.4.x'];
+    async export(manifest, options) {
+        const startTime = Date.now();
+        try {
+            if (options?.validate !== false) {
+                const validation = await this.validate(manifest);
+                if (!validation.valid) {
+                    return this.createResult(false, [], `Validation failed: ${validation.errors?.map((e) => e.message).join(', ')}`, {
+                        duration: Date.now() - startTime,
+                        warnings: validation.warnings?.map((w) => w.message),
+                    });
+                }
+            }
+            const name = sanitizeName(manifest.metadata?.name || 'agent');
+            const files = [];
+            files.push(this.createFile(`${name}/composer.json`, this.generateComposerJson(manifest), 'config', 'json'));
+            files.push(this.createFile(`${name}/agent_bootstrap.php`, this.generateBootstrapPhp(manifest), 'code', 'php'));
+            files.push(this.createFile(`${name}/README.md`, this.generateReadme(manifest, name), 'documentation'));
+            files.push(this.createFile(`${name}/agent.ossa.yaml`, yaml.stringify(manifest), 'config', 'yaml'));
+            // Generate #[AsTool] stub classes for each tool
+            const toolStubs = this.generateToolStubs(manifest);
+            files.push(...toolStubs);
+            return this.createResult(true, files, undefined, {
+                duration: Date.now() - startTime,
+                version: '1.0',
+            });
+        }
+        catch (err) {
+            return this.createResult(false, [], err instanceof Error ? err.message : String(err), { duration: Date.now() - startTime });
+        }
+    }
+    generateComposerJson(manifest) {
+        const name = sanitizeName(manifest.metadata?.name || 'agent');
+        return JSON.stringify({
+            name: `ossa/${name}`,
+            description: manifest.metadata?.description || `OSSA agent ${name} (Symfony AI)`,
+            type: 'project',
+            require: {
+                php: '>=8.2',
+                'symfony/ai-agent': '*',
+                'symfony/ai-platform': '*',
+            },
+            autoload: {
+                files: ['agent_bootstrap.php'],
+            },
+        }, null, 2);
+    }
+    generateBootstrapPhp(manifest) {
+        const name = sanitizeName(manifest.metadata?.name || 'agent');
+        const spec = manifest.spec;
+        const prompts = spec?.prompts;
+        const role = manifest.spec?.role ||
+            (prompts?.system ? String(prompts.system) : undefined) ||
+            'You are a helpful assistant.';
+        const systemMessage = escapePhpString(role);
+        const llm = manifest.spec?.llm;
+        const provider = llm?.provider || 'openai';
+        const model = llm?.model || 'gpt-4o-mini';
+        const temperature = llm?.temperature ?? 0.7;
+        const maxTokens = llm?.maxTokens ?? 4096;
+        const tools = manifest.spec?.tools || [];
+        const toolNames = tools
+            .map((t) => t.name || 'unknown')
+            .filter((n) => n !== 'unknown');
+        return `<?php
+
+declare(strict_types=1);
+
+/**
+ * OSSA Agent bootstrap for Symfony AI Agent
+ * Generated from manifest: ${manifest.metadata?.name || name} v${manifest.metadata?.version || '1.0.0'}
+ *
+ * Requires: composer require symfony/ai-agent symfony/ai-platform
+ * Usage: see README.md
+ */
+
+use Symfony\\Component\\Ai\\Agent\\Agent;
+use Symfony\\Component\\Ai\\Agent\\Toolbox;
+use Symfony\\Component\\Ai\\Agent\\InputProcessor\\AgentProcessor;
+use Symfony\\Component\\Ai\\Platform\\PlatformFactory;
+use Symfony\\Component\\Ai\\Platform\\Model\\Model;
+use Symfony\\Component\\Ai\\Message\\MessageBag;
+use Symfony\\Component\\Ai\\Message\\Message;
+
+(function () {
+    $platform = PlatformFactory::create('${escapePhpString(provider)}');
+    $model = new Model('${escapePhpString(model)}', options: [
+        'temperature' => ${temperature},
+        'max_tokens' => ${maxTokens},
+    ]);
+
+    $systemMessage = '${systemMessage}';
+    $messageBag = new MessageBag();
+    $messageBag->add(Message::forSystem($systemMessage));
+
+    ${toolNames.length
+            ? `$toolbox = new Toolbox([
+        ${toolNames
+                .map((n) => {
+                const cls = n
+                    .split(/[-_ ]+/)
+                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+                    .join('') + 'Tool';
+                return `new \\App\\Agent\\Tool\\${cls}(),`;
+            })
+                .join('\n        ')}
+    ]);`
+            : `$toolbox = new Toolbox([]);
+    // Add your #[AsTool] classes: $toolbox = new Toolbox([new MyTool(), ...]);`}
+
+    $agent = new Agent(
+        platform: $platform,
+        model: $model,
+        inputProcessors: [new AgentProcessor($toolbox)],
+        outputProcessors: [],
+        messageBag: $messageBag
+    );
+
+    return $agent;
+})();
+`;
+    }
+    generateReadme(manifest, name) {
+        const desc = manifest.metadata?.description || 'OSSA agent exported for Symfony AI';
+        return `# ${name}
+
+${desc}
+
+Generated from OSSA manifest (agent.ossa.yaml). Runs with Symfony AI Agent.
+
+## Requirements
+
+- PHP 8.2+
+- Composer
+- API key for the LLM provider (e.g. OPENAI_API_KEY, ANTHROPIC_API_KEY)
+
+## Install
+
+\`\`\`bash
+composer install
+\`\`\`
+
+Set your provider API key in the environment before running.
+
+## Run
+
+Bootstrap returns an Agent instance. Use it in your Symfony app or a small runner:
+
+\`\`\`php
+$agent = require 'agent_bootstrap.php';
+$response = $agent->run('Hello');
+\`\`\`
+
+## Customize
+
+- Edit \`agent_bootstrap.php\` to add tools (Toolbox with #[AsTool] classes).
+- Re-export from OSSA with: \`ossa export manifest.ossa.yaml --platform symfony -o .\`
+
+## Docs
+
+- [Symfony AI Agent](https://symfony.com/doc/current/ai/components/agent.html)
+- [OSSA](https://openstandardagents.org)
+`;
+    }
+    async validate(manifest) {
+        const base = await super.validate(manifest);
+        if (!base.valid)
+            return base;
+        const errors = [...(base.errors ?? [])];
+        const warnings = [...(base.warnings ?? [])];
+        if (!manifest.spec?.role &&
+            !manifest.spec?.prompts) {
+            warnings.push({
+                message: 'spec.role or spec.prompts.system recommended for Symfony system message',
+                path: 'spec.role',
+                suggestion: 'Add a system prompt',
+                code: 'SYMFONY_PROMPT_RECOMMENDED',
+            });
+        }
+        const llm = manifest.spec?.llm;
+        const provider = llm?.provider;
+        const supportedProviders = [
+            'openai',
+            'anthropic',
+            'google',
+            'mistral',
+            'ollama',
+        ];
+        if (provider && !supportedProviders.includes(provider)) {
+            warnings.push({
+                message: `LLM provider "${provider}" may not be supported by Symfony AI`,
+                path: 'spec.llm.provider',
+                suggestion: `Use one of: ${supportedProviders.join(', ')}`,
+                code: 'SYMFONY_UNSUPPORTED_PROVIDER',
+            });
+        }
+        const tools = manifest.spec?.tools || [];
+        for (let i = 0; i < tools.length; i++) {
+            if (!tools[i].description) {
+                warnings.push({
+                    message: `Tool "${tools[i].name}" missing description (used for #[AsTool] attribute)`,
+                    path: `spec.tools[${i}].description`,
+                    suggestion: 'Add a description for better Symfony AI tool documentation',
+                    code: 'SYMFONY_TOOL_DESCRIPTION',
+                });
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    async toConfig(manifest) {
+        const llm = manifest.spec?.llm;
+        const tools = manifest.spec?.tools || [];
+        return {
+            config: {
+                platform: llm?.provider || 'openai',
+                model: llm?.model || 'gpt-4o-mini',
+                temperature: llm?.temperature ?? 0.7,
+                max_tokens: llm?.maxTokens ?? 4096,
+                system_message: manifest.spec?.role || '',
+                tools: tools.map((t) => ({ name: t.name, description: t.description })),
+                metadata: {
+                    ossa_name: manifest.metadata?.name,
+                    ossa_version: manifest.metadata?.version,
+                    api_version: manifest.apiVersion,
+                },
+            },
+            filename: `${sanitizeName(manifest.metadata?.name || 'agent')}.symfony.json`,
+        };
+    }
+    /**
+     * Generate PHP stub classes for each tool in spec.tools.
+     * Each stub uses the Symfony #[AsTool] attribute.
+     */
+    generateToolStubs(manifest) {
+        const tools = manifest.spec?.tools || [];
+        const name = sanitizeName(manifest.metadata?.name || 'agent');
+        return tools
+            .filter((t) => t.name)
+            .map((tool) => {
+            const className = tool
+                .name.split(/[-_ ]+/)
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+                .join('') + 'Tool';
+            const desc = escapePhpString(tool.description || tool.name || '');
+            const content = `<?php
+
+declare(strict_types=1);
+
+namespace App\\Agent\\Tool;
+
+use Symfony\\Component\\Ai\\Agent\\Toolbox\\Attribute\\AsTool;
+
+#[AsTool(name: '${escapePhpString(tool.name)}', description: '${desc}')]
+final class ${className}
+{
+    /**
+     * @param string $input The input for this tool
+     * @return string The tool result
+     */
+    public function __invoke(string $input): string
+    {
+        // TODO: Implement ${tool.name} tool logic
+        return '';
+    }
+}
+`;
+            return this.createFile(`${name}/src/Tool/${className}.php`, content, 'code', 'php');
+        });
+    }
+    getExample() {
+        return {
+            apiVersion: 'ossa/v0.4',
+            kind: 'Agent',
+            metadata: {
+                name: 'example-symfony-agent',
+                version: '1.0.0',
+                description: 'Example agent for Symfony AI',
+            },
+            spec: {
+                role: 'You are a helpful PHP assistant.',
+                llm: {
+                    provider: 'openai',
+                    model: 'gpt-4o-mini',
+                    temperature: 0.7,
+                    maxTokens: 4096,
+                },
+            },
+        };
+    }
+}
+//# sourceMappingURL=platform-adapter.js.map

package/dist/adapters/warp/adapter.js

@@ -49,7 +49,7 @@ export class WarpAdapter extends BaseAdapter {
             // Include source OSSA manifest for provenance
             files.push(this.createManifestFile(manifest));
             // Perfect Agent files
-            files.push(...await this.generatePerfectAgentFiles(manifest, options));
+            files.push(...(await this.generatePerfectAgentFiles(manifest, options)));
             return this.createResult(true, files, undefined, {
                 duration: Date.now() - startTime,
                 version: '1.0.0',
@@ -290,13 +290,16 @@ ${Object.entries(params)
 fi`)
             .join('\n')}
 
-# TODO: Implement ${cmd.name} logic here
-echo "Executing ${cmd.name} command..."
-${paramList ? `echo "Parameters: ${paramList}"` : ''}
+# Delegate to OSSA CLI when available (set OSSA_MANIFEST to manifest path)
+if command -v ossa >/dev/null 2>&1 && [[ -n "\${OSSA_MANIFEST:-}" ]]; then
+  ossa run "\${OSSA_MANIFEST}" --tool ${cmd.name} -- "\$@"
+  exit \$?
+fi
 
-# Example implementation:
-# Replace this with actual command logic
-echo "Command ${cmd.name} not yet implemented"
+# Fallback: output structured result for callers
+echo "{\"tool\": \"${cmd.name}\", \"params\": {${Object.keys(params)
+            .map((k) => `\"${k}\": \"\$${k.toUpperCase()}\"`)
+            .join(', ')}}}"
 exit 0
 `;
     }

package/dist/api/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * OSSA REST API — Express app factory
+ *
+ * Three consumers, one service layer:
+ *   CLI (inquirer) → Service Layer ← REST API (Express) ← MCP Server (stdio)
+ */
+import express from 'express';
+import 'reflect-metadata';
+export interface CreateAppOptions {
+    corsOrigin?: string;
+}
+export declare function createApp(opts?: CreateAppOptions): express.Application;
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.js

@@ -0,0 +1,44 @@
+/**
+ * OSSA REST API — Express app factory
+ *
+ * Three consumers, one service layer:
+ *   CLI (inquirer) → Service Layer ← REST API (Express) ← MCP Server (stdio)
+ */
+import express from 'express';
+import 'reflect-metadata';
+import { corsMiddleware } from './middleware/cors.js';
+import { errorHandler } from './middleware/error-handler.js';
+import { requestId } from './middleware/request-id.js';
+import { convertRouter } from './routes/convert.router.js';
+import { exportRouter } from './routes/export.router.js';
+import { healthRouter } from './routes/health.router.js';
+import { manifestsRouter } from './routes/manifests.router.js';
+import { mcpRouter } from './routes/mcp.router.js';
+import { skillsRouter } from './routes/skills.router.js';
+import { validateRouter } from './routes/validate.router.js';
+import { versionRouter } from './routes/version.router.js';
+import { wizardRouter } from './routes/wizard.router.js';
+import { workspaceRouter } from './routes/workspace.router.js';
+export function createApp(opts) {
+    const app = express();
+    // Body parsing
+    app.use(express.json({ limit: '10mb' }));
+    // Middleware
+    app.use(requestId());
+    app.use(corsMiddleware(opts?.corsOrigin));
+    // Routes
+    app.use('/', healthRouter());
+    app.use('/api/v1/manifests', manifestsRouter());
+    app.use('/api/v1/wizard', wizardRouter());
+    app.use('/api/v1/export', exportRouter());
+    app.use('/api/v1/convert', convertRouter());
+    app.use('/api/v1/skills', skillsRouter());
+    app.use('/api/v1/workspace', workspaceRouter());
+    app.use('/api/v1/mcp', mcpRouter());
+    app.use('/api/v1/version', versionRouter());
+    app.use('/api/v1/validate', validateRouter());
+    // Error handler (must be last)
+    app.use(errorHandler());
+    return app;
+}
+//# sourceMappingURL=index.js.map

package/dist/api/middleware/cors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CORS middleware for ossa-ui and other consumers
+ */
+import type { Request, Response, NextFunction } from 'express';
+export declare function corsMiddleware(origin?: string): (_req: Request, res: Response, next: NextFunction) => void;
+//# sourceMappingURL=cors.d.ts.map

package/dist/api/middleware/cors.js

@@ -0,0 +1,17 @@
+/**
+ * CORS middleware for ossa-ui and other consumers
+ */
+export function corsMiddleware(origin) {
+    return (_req, res, next) => {
+        res.setHeader('Access-Control-Allow-Origin', origin || '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Request-Id');
+        res.setHeader('Access-Control-Max-Age', '86400');
+        if (_req.method === 'OPTIONS') {
+            res.status(204).end();
+            return;
+        }
+        next();
+    };
+}
+//# sourceMappingURL=cors.js.map

package/dist/api/middleware/error-handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Global error handler middleware
+ */
+import type { Request, Response, NextFunction } from 'express';
+export declare function errorHandler(): (err: Error, _req: Request, res: Response, _next: NextFunction) => void;
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/api/middleware/error-handler.js

@@ -0,0 +1,32 @@
+/**
+ * Global error handler middleware
+ */
+import { ZodError } from 'zod';
+export function errorHandler() {
+    return (err, _req, res, _next) => {
+        if (err instanceof ZodError) {
+            res.status(400).json({
+                error: 'Validation error',
+                details: err.issues.map((i) => ({
+                    path: i.path.join('.'),
+                    message: i.message,
+                })),
+            });
+            return;
+        }
+        // Known OSSA errors
+        if (err.message?.includes('not found') ||
+            err.message?.includes('No such file')) {
+            res.status(404).json({ error: err.message });
+            return;
+        }
+        if (err.message?.includes('already exists')) {
+            res.status(409).json({ error: err.message });
+            return;
+        }
+        // Unknown errors
+        console.error('Unhandled error:', err);
+        res.status(500).json({ error: 'Internal server error' });
+    };
+}
+//# sourceMappingURL=error-handler.js.map

package/dist/api/middleware/request-id.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Request ID middleware — adds X-Request-Id header
+ */
+import type { Request, Response, NextFunction } from 'express';
+export declare function requestId(): (req: Request, res: Response, next: NextFunction) => void;
+//# sourceMappingURL=request-id.d.ts.map

package/dist/api/middleware/request-id.js

@@ -0,0 +1,12 @@
+/**
+ * Request ID middleware — adds X-Request-Id header
+ */
+import { v4 as uuidv4 } from 'uuid';
+export function requestId() {
+    return (req, res, next) => {
+        const id = req.headers['x-request-id'] || uuidv4();
+        res.setHeader('X-Request-Id', id);
+        next();
+    };
+}
+//# sourceMappingURL=request-id.js.map

package/dist/api/middleware/validate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Zod validation middleware for Express request body/query
+ */
+import type { Request, Response, NextFunction } from 'express';
+import { z } from 'zod';
+export declare function validateBody(schema: z.ZodSchema): (req: Request, res: Response, next: NextFunction) => void;
+export declare function validateQuery(schema: z.ZodSchema): (req: Request, res: Response, next: NextFunction) => void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/api/middleware/validate.js

@@ -0,0 +1,38 @@
+/**
+ * Zod validation middleware for Express request body/query
+ */
+export function validateBody(schema) {
+    return (req, res, next) => {
+        const result = schema.safeParse(req.body);
+        if (!result.success) {
+            res.status(400).json({
+                error: 'Validation error',
+                details: result.error.issues.map((i) => ({
+                    path: i.path.join('.'),
+                    message: i.message,
+                })),
+            });
+            return;
+        }
+        req.body = result.data;
+        next();
+    };
+}
+export function validateQuery(schema) {
+    return (req, res, next) => {
+        const result = schema.safeParse(req.query);
+        if (!result.success) {
+            res.status(400).json({
+                error: 'Validation error',
+                details: result.error.issues.map((i) => ({
+                    path: i.path.join('.'),
+                    message: i.message,
+                })),
+            });
+            return;
+        }
+        req.query = result.data;
+        next();
+    };
+}
+//# sourceMappingURL=validate.js.map

package/dist/api/routes/agents-md.router.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AGENTS.md API routes — discover, maintain, get/put/delete per agent.
+ * Base dir from query `dir` or env OSSA_AGENTS_MD_BASE_DIR (default process.cwd()).
+ */
+import { Router } from 'express';
+export declare function agentsMdRouter(): Router;
+//# sourceMappingURL=agents-md.router.d.ts.map

package/dist/api/routes/agents-md.router.js

@@ -0,0 +1,93 @@
+/**
+ * AGENTS.md API routes — discover, maintain, get/put/delete per agent.
+ * Base dir from query `dir` or env OSSA_AGENTS_MD_BASE_DIR (default process.cwd()).
+ */
+import { Router } from 'express';
+import { container } from '../../di-container.js';
+import { AgentsMdApiService } from '../../services/agents-md/agents-md-api.service.js';
+function getBaseDir(queryDir) {
+    const dir = queryDir ?? process.env.OSSA_AGENTS_MD_BASE_DIR ?? process.cwd();
+    return dir;
+}
+export function agentsMdRouter() {
+    const router = Router();
+    const api = container.get(AgentsMdApiService);
+    router.get('/discover', async (req, res, next) => {
+        try {
+            const baseDir = getBaseDir(req.query.dir);
+            const configDir = req.query.configDir ?? process.env.CONFIG_DIR;
+            const wikiRoot = req.query.wikiRoot ?? process.env.WIKI_ROOT;
+            const discovered = await api.discover(baseDir);
+            res.json({
+                dir: baseDir,
+                configDir: configDir ?? undefined,
+                wikiRoot: wikiRoot ?? undefined,
+                count: discovered.length,
+                discovered,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.post('/maintain', async (req, res, next) => {
+        try {
+            const body = req.body;
+            const baseDir = getBaseDir(body.dir ?? req.query.dir);
+            const result = await api.maintain(baseDir, {
+                regenerate: body.regenerate ?? false,
+                dryRun: body.dryRun ?? false,
+            });
+            res.json({
+                dir: baseDir,
+                configDir: body.configDir ?? process.env.CONFIG_DIR ?? undefined,
+                wikiRoot: body.wikiRoot ?? process.env.WIKI_ROOT ?? undefined,
+                ...result,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/agents/:name/agents-md', async (req, res, next) => {
+        try {
+            const baseDir = getBaseDir(req.query.dir);
+            const generate = req.query.generate === 'true';
+            const out = await api.getAgentsMd(req.params.name, baseDir, { generate });
+            if (!out) {
+                res.status(404).json({ error: 'Not found' });
+                return;
+            }
+            res.json(out);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.put('/agents/:name/agents-md', async (req, res, next) => {
+        try {
+            const baseDir = getBaseDir(req.query.dir);
+            const out = await api.putAgentsMd(req.params.name, baseDir, req.body);
+            res.json(out);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.delete('/agents/:name/agents-md', async (req, res, next) => {
+        try {
+            const baseDir = getBaseDir(req.query.dir);
+            const ok = await api.deleteAgentsMd(req.params.name, baseDir);
+            if (!ok) {
+                res.status(404).json({ deleted: false });
+                return;
+            }
+            res.json({ deleted: true });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=agents-md.router.js.map

package/dist/api/routes/convert.router.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert routes
+ */
+import { Router } from 'express';
+export declare function convertRouter(): Router;
+//# sourceMappingURL=convert.router.d.ts.map