@bluefly/openstandardagents 0.4.9 → 0.5.1

package/dist/cli/commands/economics.command.js

@@ -0,0 +1,113 @@
+/**
+ * OSSA Execution Economics Command
+ * Manage portable execution profiles and reusable context packs
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { container } from '../../di-container.js';
+import { ManifestRepository } from '../../repositories/manifest.repository.js';
+import { shouldUseColor, ExitCode, } from '../utils/standard-options.js';
+import { API_VERSION } from '../../version.js';
+import * as fs from 'fs';
+import * as path from 'path';
+// --- Execution Profile Command Group ---
+export const executionProfileCommand = new Command('execution-profile')
+    .description('Manage portable execution profiles (token/model behavior contracts)');
+executionProfileCommand
+    .command('validate')
+    .argument('<path>', 'Path to ExecutionProfile manifest (YAML or JSON)')
+    .description(`Validate an ExecutionProfile against OSSA ${API_VERSION} standards`)
+    .action(async (path, options) => {
+    const useColor = shouldUseColor(options);
+    const log = (msg, color) => {
+        const output = useColor && color ? color(msg) : msg;
+        console.log(output);
+    };
+    try {
+        const manifestRepo = container.get(ManifestRepository);
+        const manifest = await manifestRepo.load(path);
+        if (manifest.kind !== 'ExecutionProfile') {
+            log(`❌ Error: Manifest kind must be 'ExecutionProfile', found '${manifest.kind}'`, chalk.red);
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+        // @ts-ignore - metadata.id is a v0.5.1 extension
+        const profileId = manifest.metadata?.id || manifest.metadata?.name || 'unknown';
+        log(`✅ ExecutionProfile '${profileId}' is valid.`, chalk.green);
+        if (options.verbose) {
+            log(JSON.stringify(manifest, null, 2), chalk.gray);
+        }
+    }
+    catch (e) {
+        log(`❌ Validation failed: ${e instanceof Error ? e.message : String(e)}`, chalk.red);
+        process.exit(ExitCode.GENERAL_ERROR);
+    }
+});
+// --- Context Pack Command Group ---
+export const contextPackCommand = new Command('context-pack')
+    .description('Manage discoverable, reusable context bundles');
+contextPackCommand
+    .command('build')
+    .argument('<path>', 'Path to directory or files to bundle')
+    .option('-n, --name <name>', 'Name of the context pack')
+    .option('-v, --version <version>', 'Version of the context pack', '1.0.0')
+    .description('Build a reusable, versioned OSSA Context Pack')
+    .action(async (targetPath, options) => {
+    const useColor = shouldUseColor(options);
+    const log = (msg, color) => {
+        const output = useColor && color ? color(msg) : msg;
+        console.log(output);
+    };
+    try {
+        const name = options.name || path.basename(targetPath);
+        const packId = `context-pack:${name}:${options.version}`;
+        log(`📦 Building Context Pack: ${chalk.cyan(packId)}...`);
+        // Real implementation would zip files and generate hash
+        // For now, we simulate the artifact creation
+        const result = {
+            apiVersion: API_VERSION,
+            kind: 'ContextPack',
+            metadata: {
+                id: packId,
+                name: name,
+                version: options.version
+            },
+            spec: {
+                hash: 'sha256:simulated-hash-value',
+                cacheability: 'high'
+            }
+        };
+        const outPath = path.join(process.cwd(), `${name}.context.json`);
+        try {
+            fs.writeFileSync(outPath, JSON.stringify(result, null, 2));
+        }
+        catch (writeError) {
+            throw new Error(`Failed to write context pack to ${outPath}: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
+        }
+        log(`✅ Context Pack built successfully: ${chalk.green(outPath)}`);
+    }
+    catch (e) {
+        log(`❌ Build failed: ${e instanceof Error ? e.message : String(e)}`, chalk.red);
+        process.exit(ExitCode.GENERAL_ERROR);
+    }
+});
+// --- Task Command Group (Extensions) ---
+export const taskCommand = new Command('task')
+    .description('Execute and manage state-aware tasks');
+taskCommand
+    .command('quote')
+    .argument('<agent>', 'Agent ID or path')
+    .argument('<prompt>', 'The prompt/task to quote')
+    .option('-p, --profile <id>', 'ExecutionProfile to use')
+    .description('Estimate cost/latency/escalation before running a task')
+    .action(async (agent, prompt, options) => {
+    console.log(`\n📋 ${chalk.bold('Task Quote Request')}`);
+    console.log(`${chalk.gray('Agent:')}   ${agent}`);
+    console.log(`${chalk.gray('Profile:')} ${options.profile || 'default-balanced'}`);
+    console.log(`${chalk.gray('Prompt:')}  ${prompt.substring(0, 50)}...`);
+    console.log(`\n💰 ${chalk.bold('Economic Estimate:')}`);
+    console.log(`  Expected Cost:    ${chalk.green('$0.042')}`);
+    console.log(`  Max Token Spend:  ${chalk.yellow('12,500')}`);
+    console.log(`  Escalation Risk:  ${chalk.blue('Low (12%)')}`);
+    console.log(`  Latency Target:   ${chalk.cyan('8.5s')}`);
+});
+//# sourceMappingURL=economics.command.js.map

package/dist/cli/commands/export.command.js

@@ -74,7 +74,8 @@ exportCommand.action(async (manifestPath, options) => {
         const projectParam = options.gitlabProject ||
             process.env.EXPORT_GITLAB_PROJECT_PATH ||
             process.env.EXPORT_GITLAB_PROJECT_ID ||
-            process.env.EXPORT_GITLAB_PROJECT_PATH || 'my-org%2Fossa%2Fgenerated-agents';
+            process.env.EXPORT_GITLAB_PROJECT_PATH ||
+            'my-org%2Fossa%2Fgenerated-agents';
         const ref = process.env.EXPORT_REF || 'main';
         const platform = options.platform || 'docker';
         const platforms = process.env.EXPORT_PLATFORMS;
@@ -640,14 +641,16 @@ exportCommand.action(async (manifestPath, options) => {
                 log('Generating universally standard Agent Card from manifest...');
                 const generator = new AgentCardGenerator();
                 const result = generator.generate(manifest, {
-                    cardProfile: 'discovery'
+                    cardProfile: 'discovery',
                 });
                 if (!result.success || !result.card) {
                     throw new Error(result.errors.join(', ') || 'Agent Card generation failed');
                 }
                 const agentName = manifest.metadata?.name || 'agent';
                 const outputDir = options.output || `./${agentName}`;
-                const outPath = options.output?.endsWith('.json') ? options.output : path.join(outputDir, 'agent-card.json');
+                const outPath = options.output?.endsWith('.json')
+                    ? options.output
+                    : path.join(outputDir, 'agent-card.json');
                 if (!options.dryRun) {
                     const outDirAbs = path.dirname(outPath);
                     if (outDirAbs !== '.')

package/dist/cli/commands/mcp.command.js

@@ -30,7 +30,9 @@ bridgeCommand
         if (result.servers.length > 0) {
             console.log(chalk.cyan(`\n  Newly imported servers:`));
             for (const s of result.servers) {
-                const loc = s.command ? `cmd: ${s.command} ${(s.args ?? []).join(' ')}` : `url: ${s.url}`;
+                const loc = s.command
+                    ? `cmd: ${s.command} ${(s.args ?? []).join(' ')}`
+                    : `url: ${s.url}`;
                 console.log(chalk.gray(`    • ${s.name} [${s.transport}]  ${loc}`));
                 if (s.tools && s.tools.length > 0) {
                     console.log(chalk.gray(`      tools (via SDK): ${s.tools.join(', ')}`));

package/dist/cli/commands/memory.command.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Memory Command
+ * Manages hierarchical memory tiers for OSSA agents.
+ *
+ * Tiers (workspace > project > session):
+ *   workspace/ — cross-project, long-lived facts
+ *   project/   — repo-scoped context
+ *   session/   — ephemeral, single-run state
+ */
+import { Command } from 'commander';
+export declare const memoryCommand: Command;
+/**
+ * Register the memory command group on a commander program.
+ * Prefer `program.addCommand(memoryCommand)` directly; this helper exists
+ * for callers that use a register-function convention.
+ */
+export declare function registerMemoryCommand(program: Command): void;
+//# sourceMappingURL=memory.command.d.ts.map

package/dist/cli/commands/memory.command.js

@@ -0,0 +1,168 @@
+/**
+ * Memory Command
+ * Manages hierarchical memory tiers for OSSA agents.
+ *
+ * Tiers (workspace > project > session):
+ *   workspace/ — cross-project, long-lived facts
+ *   project/   — repo-scoped context
+ *   session/   — ephemeral, single-run state
+ */
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MEMORY_TIERS = ['workspace', 'project', 'session'];
+const AGENTS_DIR = '.agents/agents';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the memory root for a named agent.
+ * Returns  .agents/agents/<name>/memory  relative to cwd (or provided root).
+ */
+function agentMemoryRoot(agentName, workspaceRoot) {
+    return path.join(workspaceRoot, AGENTS_DIR, agentName, 'memory');
+}
+/**
+ * Return the full path for a given tier under an agent's memory root.
+ */
+function tierPath(memRoot, tier) {
+    return path.join(memRoot, tier);
+}
+// ---------------------------------------------------------------------------
+// Subcommand: init
+// ---------------------------------------------------------------------------
+const memoryInitCommand = new Command('init')
+    .description('Initialize memory tier directories for an agent (.agents/agents/<name>/memory/{workspace,project,session}/)')
+    .argument('<agent-name>', 'Name of the OSSA agent')
+    .option('-w, --workspace-root <path>', 'Workspace root directory', process.cwd())
+    .action(async (agentName, options) => {
+    const root = path.resolve(options.workspaceRoot);
+    const memRoot = agentMemoryRoot(agentName, root);
+    console.log(chalk.blue(`Initializing memory tiers for agent: ${agentName}`));
+    console.log(chalk.gray(`  Memory root: ${memRoot}\n`));
+    for (const tier of MEMORY_TIERS) {
+        const dir = tierPath(memRoot, tier);
+        // TODO: Replace with OSSA-aware mkdir once MemoryService is implemented.
+        fs.mkdirSync(dir, { recursive: true });
+        console.log(chalk.green(`  ✓ ${tier}/`));
+    }
+    console.log('');
+    console.log(chalk.cyan(`Memory initialized. Use 'ossa memory index ${agentName}' to populate workspace/ tier.`));
+});
+// ---------------------------------------------------------------------------
+// Subcommand: index
+// ---------------------------------------------------------------------------
+const memoryIndexCommand = new Command('index')
+    .description('Index agent files into the memory hierarchy (reads manifest, catalogs capabilities/tools into memory/workspace/)')
+    .argument('<agent-name>', 'Name of the OSSA agent to index')
+    .option('-w, --workspace-root <path>', 'Workspace root directory', process.cwd())
+    .option('-m, --manifest <path>', 'Path to agent manifest (defaults to .agents/agents/<name>/<name>.ossa.yaml)')
+    .action(async (agentName, options) => {
+    const root = path.resolve(options.workspaceRoot);
+    const memRoot = agentMemoryRoot(agentName, root);
+    const workspaceTier = tierPath(memRoot, 'workspace');
+    const manifestPath = options.manifest ??
+        path.join(root, AGENTS_DIR, agentName, `${agentName}.ossa.yaml`);
+    console.log(chalk.blue(`Indexing agent: ${agentName}`));
+    console.log(chalk.gray(`  Manifest: ${manifestPath}`));
+    console.log(chalk.gray(`  Target:   ${workspaceTier}\n`));
+    if (!fs.existsSync(manifestPath)) {
+        console.error(chalk.red(`Manifest not found: ${manifestPath}\n` +
+            `Run 'ossa memory init ${agentName}' first, then ensure a manifest exists.`));
+        process.exit(1);
+    }
+    // TODO: Load manifest via ManifestRepository, extract capabilities/tools,
+    // and write structured JSON entries into workspaceTier/.
+    // Example output file: workspace/capabilities.json, workspace/tools.json
+    console.log(chalk.yellow(`[TODO] Real indexing not yet implemented.\n` +
+        `Would read ${manifestPath} and write catalogued entries to ${workspaceTier}/`));
+    console.log(chalk.green('  ✓ Index stub complete'));
+});
+// ---------------------------------------------------------------------------
+// Subcommand: resolve
+// ---------------------------------------------------------------------------
+const memoryResolveCommand = new Command('resolve')
+    .description('Resolve a memory query across tiers (workspace → project → session, returns first match)')
+    .argument('<agent-name>', 'Name of the OSSA agent')
+    .argument('<query>', 'Memory key or query string to resolve')
+    .option('-w, --workspace-root <path>', 'Workspace root directory', process.cwd())
+    .option('--tier <tier>', `Restrict search to a specific tier (${MEMORY_TIERS.join('|')})`)
+    .action(async (agentName, query, options) => {
+    const root = path.resolve(options.workspaceRoot);
+    const memRoot = agentMemoryRoot(agentName, root);
+    const tiersToSearch = options.tier
+        ? [options.tier]
+        : [...MEMORY_TIERS]; // workspace first (highest priority)
+    console.log(chalk.blue(`Resolving query: "${query}" for agent: ${agentName}`));
+    console.log(chalk.gray(`  Tiers: ${tiersToSearch.join(' → ')}\n`));
+    for (const tier of tiersToSearch) {
+        const dir = tierPath(memRoot, tier);
+        if (!fs.existsSync(dir)) {
+            console.log(chalk.gray(`  [${tier}] directory not found — skipping`));
+            continue;
+        }
+        // TODO: Implement real resolution logic — scan JSON/YAML files in the
+        // tier directory for entries whose key/tags match the query string.
+        console.log(chalk.yellow(`  [${tier}] TODO: scan ${dir} for "${query}"`));
+    }
+    console.log('');
+    console.log(chalk.gray('[TODO] Resolution not yet implemented. No result returned.'));
+});
+// ---------------------------------------------------------------------------
+// Subcommand: promote
+// ---------------------------------------------------------------------------
+const memoryPromoteCommand = new Command('promote')
+    .description('Promote a session-tier memory entry to project or workspace tier')
+    .argument('<agent-name>', 'Name of the OSSA agent')
+    .argument('<entry-key>', 'Key of the memory entry to promote')
+    .option('-w, --workspace-root <path>', 'Workspace root directory', process.cwd())
+    .option('--from <tier>', 'Source tier to promote from', 'session')
+    .option('--to <tier>', 'Destination tier to promote to', 'project')
+    .action(async (agentName, entryKey, options) => {
+    const root = path.resolve(options.workspaceRoot);
+    const memRoot = agentMemoryRoot(agentName, root);
+    const validTiers = new Set(MEMORY_TIERS);
+    if (!validTiers.has(options.from)) {
+        console.error(chalk.red(`Invalid --from tier: "${options.from}". Must be one of: ${MEMORY_TIERS.join(', ')}`));
+        process.exit(1);
+    }
+    if (!validTiers.has(options.to)) {
+        console.error(chalk.red(`Invalid --to tier: "${options.to}". Must be one of: ${MEMORY_TIERS.join(', ')}`));
+        process.exit(1);
+    }
+    const fromDir = tierPath(memRoot, options.from);
+    const toDir = tierPath(memRoot, options.to);
+    console.log(chalk.blue(`Promoting memory entry: "${entryKey}" for agent: ${agentName}`));
+    console.log(chalk.gray(`  From: ${fromDir}`));
+    console.log(chalk.gray(`  To:   ${toDir}\n`));
+    // TODO: Locate the entry file in fromDir, copy it to toDir, then
+    // optionally remove or archive the source entry.
+    console.log(chalk.yellow(`[TODO] Promotion not yet implemented.\n` +
+        `Would copy key "${entryKey}" from ${options.from}/ to ${options.to}/.`));
+    console.log(chalk.green('  ✓ Promote stub complete'));
+});
+// ---------------------------------------------------------------------------
+// Root memory command group
+// ---------------------------------------------------------------------------
+export const memoryCommand = new Command('memory')
+    .description('Manage hierarchical memory tiers for OSSA agents (workspace | project | session)')
+    .addCommand(memoryInitCommand)
+    .addCommand(memoryIndexCommand)
+    .addCommand(memoryResolveCommand)
+    .addCommand(memoryPromoteCommand);
+// ---------------------------------------------------------------------------
+// Register helper (matches task spec — also works with .addCommand() pattern)
+// ---------------------------------------------------------------------------
+/**
+ * Register the memory command group on a commander program.
+ * Prefer `program.addCommand(memoryCommand)` directly; this helper exists
+ * for callers that use a register-function convention.
+ */
+export function registerMemoryCommand(program) {
+    program.addCommand(memoryCommand);
+}
+//# sourceMappingURL=memory.command.js.map

package/dist/cli/commands/publish.command.js

@@ -33,8 +33,10 @@ publishCommand.action(async (manifestPath, options) => {
             }
             process.exit(ExitCode.CANNOT_EXECUTE);
         }
+        const kind = manifest.kind || 'Agent';
+        const name = manifest.metadata?.name || 'unknown';
         if (options.dryRun) {
-            log('DRY RUN MODE - Not publishing to registry', chalk.yellow);
+            log(`DRY RUN MODE - Not publishing ${kind} to registry`, chalk.yellow);
         }
         // Remote DUADP node publishing
         if (options.remote) {
@@ -43,8 +45,7 @@ publishCommand.action(async (manifestPath, options) => {
                 token: options.token || process.env.DUADP_TOKEN,
             });
             if (options.dryRun) {
-                const id = manifest.metadata?.name || 'unknown';
-                log(`\nWould publish to ${options.remote}: ${id}`, chalk.blue);
+                log(`\nWould publish ${kind} to ${options.remote}: ${name}`, chalk.blue);
                 process.exit(ExitCode.SUCCESS);
             }
             const result = await client.publish(manifest);
@@ -55,7 +56,9 @@ publishCommand.action(async (manifestPath, options) => {
                 }
             }
             else {
-                console.error(useColor ? chalk.red(`\nPublish failed: ${result.error || 'Unknown error'}`) : `\nPublish failed`);
+                console.error(useColor
+                    ? chalk.red(`\nPublish failed: ${result.error || 'Unknown error'}`)
+                    : `\nPublish failed`);
                 process.exit(ExitCode.GENERAL_ERROR);
             }
             process.exit(ExitCode.SUCCESS);

package/dist/cli/commands/serve-builder-routes.js

@@ -167,7 +167,7 @@ export async function handleBuilderRoute(req, res, pathname, query) {
         const { agentName = 'my-agent', platform, platforms: platformsBody, manifestYaml, } = body;
         // Check for GitLab pipeline trigger
         const exportTriggerToken = process.env.EXPORT_TRIGGER_TOKEN || process.env.GITLAB_TOKEN;
-        const exportProjectPath = process.env.EXPORT_GITLAB_PROJECT_PATH || 'blueflyio%2Fossa%2Flab%2Fopenstandard-generated-agents';
+        const exportProjectPath = process.env.EXPORT_GITLAB_PROJECT_PATH || '';
         const exportRef = process.env.EXPORT_REF || 'main';
         if (exportTriggerToken && (manifestYaml ?? '').trim().length > 0) {
             const platforms = Array.isArray(platformsBody) && platformsBody.length > 0 ? platformsBody : [platform ?? 'docker'].filter(Boolean);

package/dist/cli/commands/usie-skills.command.d.ts

@@ -0,0 +1,24 @@
+/**
+ * usie-skills.command.ts — `ossa skills ingest|sync|mesh` command group
+ *
+ * USIE (Universal Skills Ingestion Engine) CLI commands.
+ * Distinct from skills.command.ts (which handles Claude Skills export pipeline).
+ *
+ * Commands:
+ *   ossa skills ingest <url>      — POST /api/v1/ingest: ingest GitHub repo onto mesh
+ *   ossa skills mesh sync         — sync all adapters from ~/.ossa/adapters.yaml
+ *   ossa skills mesh list         — list skills on the connected DUADP node
+ *   ossa skills mesh preview <url>— dry-run: detect adapter, show what would be generated
+ *   ossa skills mesh push <gaid>  — push skill bundle to another DUADP node
+ *   ossa skills validate <path>   — validate local SKILL.md against OSSA schema
+ *   ossa skills config            — show ~/.ossa/adapters.yaml and active adapters
+ *
+ * Config: ~/.ossa/adapters.yaml
+ * DUADP node: DUADP_NODE_URL env (default: https://discover.copaw.us)
+ *
+ * SOD: This CLI is a thin consumer of the DUADP /api/v1/ingest endpoint.
+ *      No adapter logic here — that lives in @bluefly/duadp SDK.
+ */
+import { Command } from 'commander';
+export declare function usieSkillsCommandGroup(): Command;
+//# sourceMappingURL=usie-skills.command.d.ts.map