@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/commands/org.js

@@ -1,136 +0,0 @@
-import { requireLogin, isUuid, fmt, exitWithError } from '../utils/cli-helpers.js';
-/**
- * Resolve an org identifier (UUID, slug, name, or prefix) to an org ID.
- * Exact slug/name matches take priority over prefix matches.
- */
-async function resolveOrgId(client, identifier) {
-    if (isUuid(identifier))
-        return identifier;
-    const orgs = await client.listOrgs();
-    // Exact match first (slug or name)
-    const exact = orgs.find((o) => o.slug === identifier || o.name === identifier);
-    if (exact)
-        return exact.id;
-    // Prefix match as fallback
-    const prefixMatches = orgs.filter((o) => o.slug.startsWith(identifier) || o.id.startsWith(identifier));
-    if (prefixMatches.length === 0) {
-        throw new Error(`No organization matching "${identifier}". Run: fw org list`);
-    }
-    if (prefixMatches.length > 1) {
-        throw new Error(`Ambiguous: "${identifier}" matches ${prefixMatches.length} organizations. Use the full slug or ID.`);
-    }
-    return prefixMatches[0].id;
-}
-/**
- * Resolve a user identifier (email, email prefix, or UUID) to a userId within an org.
- * Exact email matches take priority over prefix matches.
- */
-async function resolveUserId(client, orgId, identifier, orgLabel) {
-    if (isUuid(identifier))
-        return identifier;
-    const org = await client.getOrg(orgId);
-    // Exact match first
-    const exact = org.members.find((m) => m.email === identifier);
-    if (exact)
-        return exact.userId;
-    // Prefix match as fallback
-    const prefixMatches = org.members.filter((m) => m.email.startsWith(identifier) || m.userId.startsWith(identifier));
-    if (prefixMatches.length === 0) {
-        throw new Error(`No member matching "${identifier}" in this organization. Run: fw org members ${orgLabel ?? orgId}`);
-    }
-    if (prefixMatches.length > 1) {
-        throw new Error(`Ambiguous: "${identifier}" matches ${prefixMatches.length} members. Use the full email or ID.`);
-    }
-    return prefixMatches[0].userId;
-}
-export async function orgListCommand() {
-    const { client } = requireLogin();
-    try {
-        const orgs = await client.listOrgs();
-        console.log('');
-        if (orgs.length === 0) {
-            console.log('  No organizations. Create one with: fw org create <name>');
-        }
-        else {
-            console.log(`  ${orgs.length} organization${orgs.length === 1 ? '' : 's'}:`);
-            console.log('');
-            for (const org of orgs) {
-                const roleColor = org.role === 'owner' ? '\x1b[33m' : '\x1b[2m';
-                console.log(`    ${fmt.bold(org.name)}  ${fmt.dim(org.slug)}  ${roleColor}${org.role}\x1b[0m`);
-            }
-        }
-        console.log('');
-    }
-    catch (err) {
-        exitWithError(err, 'Failed to list organizations');
-    }
-}
-export async function orgCreateCommand(name) {
-    const { client } = requireLogin();
-    try {
-        const org = await client.createOrg(name);
-        console.log('');
-        console.log(fmt.ok('Organization created'));
-        console.log('');
-        console.log(`  Name: ${org.name}`);
-        console.log(`  Slug: ${org.slug}`);
-        console.log(`  ID:   ${fmt.dim(org.id)}`);
-        console.log('');
-        console.log(`  Invite members: fw org invite ${org.slug} <email>`);
-        console.log('');
-    }
-    catch (err) {
-        exitWithError(err, 'Failed to create organization');
-    }
-}
-export async function orgMembersCommand(identifier) {
-    const { client } = requireLogin();
-    try {
-        const orgId = await resolveOrgId(client, identifier);
-        const org = await client.getOrg(orgId);
-        console.log('');
-        console.log(`  ${fmt.bold(org.name)}`);
-        console.log('');
-        if (org.members.length === 0) {
-            console.log('  No members.');
-        }
-        else {
-            for (const m of org.members) {
-                const roleColor = m.role === 'owner' ? '\x1b[33m' : '\x1b[2m';
-                console.log(`    ${m.email.padEnd(30)} ${m.name.padEnd(20)} ${roleColor}${m.role}\x1b[0m`);
-            }
-        }
-        console.log('');
-    }
-    catch (err) {
-        exitWithError(err, 'Failed to get organization');
-    }
-}
-export async function orgInviteCommand(identifier, email, options) {
-    const { client } = requireLogin();
-    const role = options.role ?? 'editor';
-    try {
-        if (!['editor', 'viewer'].includes(role)) {
-            throw new Error(`Invalid role "${role}". Use: editor, viewer`);
-        }
-        const orgId = await resolveOrgId(client, identifier);
-        await client.inviteOrgMember(orgId, email, role);
-        console.log(fmt.ok(`Invited ${email} as ${role}`));
-    }
-    catch (err) {
-        exitWithError(err, 'Failed to invite member');
-    }
-}
-export async function orgRemoveCommand(identifier, userIdentifier) {
-    const { client } = requireLogin();
-    try {
-        const orgId = await resolveOrgId(client, identifier);
-        const userId = await resolveUserId(client, orgId, userIdentifier, identifier);
-        await client.removeOrgMember(orgId, userId);
-        console.log(fmt.ok('Member removed'));
-    }
-    catch (err) {
-        exitWithError(err, 'Failed to remove member');
-    }
-}
-//# sourceMappingURL=org.js.map

package/dist/cli/commands/pattern.d.ts

@@ -1,34 +0,0 @@
-/**
- * CLI pattern commands
- * - list: Find patterns in files/directories
- * - apply: Merge pattern into workflow
- * - extract: Create pattern from workflow nodes
- */
-interface ListOptions {
-    json?: boolean;
-}
-interface ApplyOptions {
-    preview?: boolean;
-    prefix?: string;
-    name?: string;
-}
-interface ExtractOptions {
-    nodes: string;
-    output: string;
-    name?: string;
-    preview?: boolean;
-}
-/**
- * Find patterns in a file or directory
- */
-export declare function patternListCommand(inputPath: string, options: ListOptions): Promise<void>;
-/**
- * Apply a pattern to a workflow file
- */
-export declare function patternApplyCommand(patternFile: string, targetFile: string, options: ApplyOptions): Promise<void>;
-/**
- * Extract a pattern from workflow nodes
- */
-export declare function patternExtractCommand(sourceFile: string, options: ExtractOptions): Promise<void>;
-export {};
-//# sourceMappingURL=pattern.d.ts.map

package/dist/cli/commands/pattern.js

@@ -1,186 +0,0 @@
-/* eslint-disable no-console */
-/**
- * CLI pattern commands
- * - list: Find patterns in files/directories
- * - apply: Merge pattern into workflow
- * - extract: Create pattern from workflow nodes
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import { AnnotationParser } from '../../parser.js';
-import { logger } from '../utils/logger.js';
-import { safeWriteFile } from '../utils/safe-write.js';
-import { listPatterns, applyPattern, extractPattern } from '../../api/patterns.js';
-const parser = new AnnotationParser();
-/**
- * Find patterns in a file or directory
- */
-export async function patternListCommand(inputPath, options) {
-    if (!fs.existsSync(inputPath)) {
-        throw new Error(`Path not found: ${inputPath}`);
-    }
-    const stat = fs.statSync(inputPath);
-    let files;
-    if (stat.isDirectory()) {
-        files = await glob('**/*.ts', { cwd: inputPath, absolute: true });
-    }
-    else {
-        files = [inputPath];
-    }
-    const allPatterns = [];
-    for (const file of files) {
-        try {
-            const patterns = listPatterns(file);
-            if (patterns.length > 0) {
-                allPatterns.push({ file, patterns });
-            }
-        }
-        catch {
-            // Skip files that fail to parse
-        }
-    }
-    const flat = allPatterns.flatMap(({ file, patterns }) => patterns.map((p) => ({ file, ...p })));
-    if (flat.length === 0) {
-        if (options.json) {
-            console.log(JSON.stringify([]));
-        }
-        else {
-            logger.info('No patterns found');
-        }
-        return;
-    }
-    if (options.json) {
-        console.log(JSON.stringify(flat, null, 2));
-        return;
-    }
-    // Human-readable output
-    for (const { file, name, description, inputPorts, outputPorts, nodes } of flat) {
-        logger.section(name);
-        if (description) {
-            logger.info(description);
-        }
-        logger.info(`File: ${path.relative(process.cwd(), file)}`);
-        if (inputPorts.length > 0) {
-            logger.info('Input ports:');
-            for (const port of inputPorts) {
-                logger.log(`  ${port.name}${port.description ? ` - ${port.description}` : ''}`);
-            }
-        }
-        if (outputPorts.length > 0) {
-            logger.info('Output ports:');
-            for (const port of outputPorts) {
-                logger.log(`  ${port.name}${port.description ? ` - ${port.description}` : ''}`);
-            }
-        }
-        if (nodes.length > 0) {
-            logger.info(`Nodes: ${nodes.join(', ')}`);
-        }
-        logger.newline();
-    }
-}
-/**
- * Apply a pattern to a workflow file
- */
-export async function patternApplyCommand(patternFile, targetFile, options) {
-    // Parse pattern file
-    const patternResult = parser.parse(patternFile);
-    if (patternResult.patterns.length === 0) {
-        throw new Error(`No patterns found in ${patternFile}`);
-    }
-    // Select pattern (by name if specified, otherwise first)
-    let pattern;
-    if (options.name) {
-        const found = patternResult.patterns.find((p) => p.name === options.name);
-        if (!found) {
-            throw new Error(`Pattern "${options.name}" not found in ${patternFile}`);
-        }
-        pattern = found;
-    }
-    else {
-        pattern = patternResult.patterns[0];
-    }
-    // Parse target to detect existing node types
-    const targetContent = fs.readFileSync(targetFile, 'utf8');
-    const targetResult = parser.parse(targetFile);
-    const existingNodeTypes = new Set(targetResult.nodeTypes.map((nt) => nt.name));
-    // Apply pattern via API
-    const result = applyPattern({
-        patternAST: pattern,
-        targetContent,
-        targetNodeTypes: existingNodeTypes,
-        prefix: options.prefix,
-    });
-    if (result.conflicts.length > 0) {
-        console.log(`\u26A0\uFE0F  Node type conflict detected: ${result.conflicts.join(', ')}`);
-        console.log('   Existing node types will be preserved. Consider using --prefix to avoid conflicts.');
-    }
-    if (options.preview) {
-        console.log(result.modifiedContent);
-        logger.newline();
-        logger.section('Manual wiring required');
-        for (const instruction of result.wiringInstructions) {
-            logger.log(`  ${instruction}`);
-        }
-        logger.info('Input ports:');
-        for (const name of Object.keys(pattern.inputPorts)) {
-            logger.log(`  IN.${name}`);
-        }
-        logger.info('Output ports:');
-        for (const name of Object.keys(pattern.outputPorts)) {
-            logger.log(`  OUT.${name}`);
-        }
-        return;
-    }
-    // Write modified content
-    safeWriteFile(targetFile, result.modifiedContent);
-    logger.success(`Applied pattern "${pattern.name}" to ${targetFile}`);
-    if (result.nodeTypesAdded.length > 0) {
-        logger.info(`Added node types: ${result.nodeTypesAdded.join(', ')}`);
-    }
-    const nodePrefix = options.prefix ? `${options.prefix}_` : '';
-    logger.info(`Added nodes: ${pattern.instances.map((i) => `${nodePrefix}${i.id}`).join(', ')}`);
-    logger.newline();
-    logger.section('Wire these ports manually');
-    for (const instruction of result.wiringInstructions) {
-        logger.log(`  ${instruction}`);
-    }
-    logger.info('Input ports:');
-    for (const name of Object.keys(pattern.inputPorts)) {
-        logger.log(`  IN.${name}`);
-    }
-    logger.info('Output ports:');
-    for (const name of Object.keys(pattern.outputPorts)) {
-        logger.log(`  OUT.${name}`);
-    }
-}
-/**
- * Extract a pattern from workflow nodes
- */
-export async function patternExtractCommand(sourceFile, options) {
-    // Parse source file
-    const parseResult = parser.parse(sourceFile);
-    if (parseResult.workflows.length === 0) {
-        throw new Error(`No workflows found in ${sourceFile}`);
-    }
-    const workflow = parseResult.workflows[0];
-    const nodeIds = options.nodes.split(',').map((s) => s.trim());
-    // Extract pattern via API
-    const result = extractPattern({
-        workflowAST: workflow,
-        nodeTypes: parseResult.nodeTypes,
-        nodeIds,
-        name: options.name,
-    });
-    if (options.preview) {
-        console.log(result.patternCode);
-        return;
-    }
-    // Write to output file
-    safeWriteFile(options.output, result.patternCode);
-    logger.success(`Extracted pattern "${result.patternName}" to ${options.output}`);
-    logger.info(`Included nodes: ${result.nodes.join(', ')}`);
-    logger.info(`Input ports: ${result.inputPorts.join(', ') || 'none'}`);
-    logger.info(`Output ports: ${result.outputPorts.join(', ') || 'none'}`);
-}
-//# sourceMappingURL=pattern.js.map

package/dist/cli/commands/plugin.d.ts

@@ -1,16 +0,0 @@
-/**
- * Plugin command — scaffolds a new external plugin directory
- */
-export interface PluginInitOptions {
-    area?: string;
-    system?: boolean;
-    preview?: boolean;
-    force?: boolean;
-}
-export declare function validatePluginName(name: string): string | true;
-export declare function generatePluginFiles(pluginName: string, options: {
-    area: string;
-    system: boolean;
-}): Record<string, string>;
-export declare function pluginInitCommand(name: string, options: PluginInitOptions): Promise<void>;
-//# sourceMappingURL=plugin.d.ts.map

package/dist/cli/commands/plugin.js

@@ -1,176 +0,0 @@
-/* eslint-disable no-console */
-/**
- * Plugin command — scaffolds a new external plugin directory
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { logger } from '../utils/logger.js';
-// ── Validation ───────────────────────────────────────────────────────────────
-const PLUGIN_NAME_RE = /^[a-zA-Z0-9][-a-zA-Z0-9_.]*$/;
-const VALID_AREAS = ['sidebar', 'main', 'toolbar', 'modal', 'panel'];
-export function validatePluginName(name) {
-    if (!name)
-        return 'Plugin name cannot be empty';
-    if (name.length > 100)
-        return 'Plugin name must be at most 100 characters';
-    if (!PLUGIN_NAME_RE.test(name)) {
-        return 'Plugin name must start with a letter or digit and contain only letters, digits, hyphens, dots, and underscores';
-    }
-    return true;
-}
-// ── File generation ──────────────────────────────────────────────────────────
-function toPascalCase(name) {
-    return name
-        .split(/[-_.]/)
-        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-        .join('');
-}
-export function generatePluginFiles(pluginName, options) {
-    const componentName = toPascalCase(pluginName) + 'Panel';
-    const pluginArtifact = [
-        `name: ${pluginName}`,
-        'version: 1.0.0',
-        `description: ${pluginName} plugin`,
-        'entry:',
-        '  client: ./client/index.tsx',
-        ...(options.system ? ['  system: ./system/index.ts'] : []),
-        'capabilities: {}',
-        '',
-    ].join('\n');
-    const clientIndex = [
-        "import { PluginPanel, createPlugin } from '@synergenius/flow-weaver/plugin';",
-        "import type { TPluginComponentProps, TPluginComponentApi } from '@synergenius/flow-weaver/plugin';",
-        "import React from 'react';",
-        '',
-        `const PLUGIN_NAME = '${pluginName}';`,
-        '',
-        ...(options.system
-            ? [
-                `const fetchData = async (api: TPluginComponentApi) =>`,
-                `  api.call(PLUGIN_NAME, 'getData', undefined);`,
-                '',
-            ]
-            : []),
-        `const ${componentName} = (props: TPluginComponentProps) => {`,
-        '  return (',
-        '    <PluginPanel {...props}>',
-        `      <div style={{ padding: 16 }}>`,
-        `        <h3>${pluginName}</h3>`,
-        ...(options.system
-            ? [
-                '        <button',
-                '          onClick={async () => {',
-                '            const result = await fetchData(props.api);',
-                '            console.log(result);',
-                '          }}',
-                '        >',
-                '          Fetch Data',
-                '        </button>',
-            ]
-            : ['        <p>Plugin loaded.</p>']),
-        '      </div>',
-        '    </PluginPanel>',
-        '  );',
-        '};',
-        '',
-        'export default createPlugin(() => ({',
-        '  async initialize() {},',
-        '  ui: {',
-        '    components: {',
-        `      ${componentName},`,
-        '    },',
-        '    config: {',
-        `      ${componentName}: {`,
-        `        name: '${componentName}',`,
-        `        displayName: '${pluginName}',`,
-        `        area: '${options.area}',`,
-        `        description: '${pluginName} plugin panel',`,
-        '      },',
-        '    },',
-        '  },',
-        '}));',
-        '',
-    ].join('\n');
-    const files = {
-        'plugin-artifact.yaml': pluginArtifact,
-        'client/index.tsx': clientIndex,
-    };
-    if (options.system) {
-        const systemIndex = [
-            "import type { TPluginSystemModule } from '@synergenius/flow-weaver/plugin';",
-            '',
-            'const plugin: TPluginSystemModule = {',
-            '  async initialize() {',
-            '    // Plugin system module initialized',
-            '  },',
-            '  methods: {',
-            '    async getData() {',
-            `      return { message: 'Hello from ${pluginName}!' };`,
-            '    },',
-            '  },',
-            '  async cleanup() {',
-            '    // Plugin cleanup',
-            '  },',
-            '};',
-            '',
-            'export default plugin;',
-            '',
-        ].join('\n');
-        files['system/index.ts'] = systemIndex;
-    }
-    return files;
-}
-// ── CLI entrypoint ───────────────────────────────────────────────────────────
-export async function pluginInitCommand(name, options) {
-    const area = options.area ?? 'panel';
-    const includeSystem = options.system !== false;
-    const preview = options.preview ?? false;
-    const force = options.force ?? false;
-    // Validate plugin name
-    const valid = validatePluginName(name);
-    if (valid !== true) {
-        throw new Error(valid);
-    }
-    // Validate area
-    if (!VALID_AREAS.includes(area)) {
-        throw new Error(`Invalid area "${area}". Available: ${VALID_AREAS.join(', ')}`);
-    }
-    const files = generatePluginFiles(name, { area, system: includeSystem });
-    if (preview) {
-        logger.section('Preview');
-        for (const [relativePath, content] of Object.entries(files)) {
-            logger.log(`\n── ${relativePath} ──`);
-            logger.log(content);
-        }
-        return;
-    }
-    // Write files under plugins/<name>/
-    const targetDir = path.resolve('plugins', name);
-    const filesCreated = [];
-    const filesSkipped = [];
-    for (const [relativePath, content] of Object.entries(files)) {
-        const absPath = path.join(targetDir, relativePath);
-        const dir = path.dirname(absPath);
-        fs.mkdirSync(dir, { recursive: true });
-        if (fs.existsSync(absPath) && !force) {
-            filesSkipped.push(relativePath);
-            continue;
-        }
-        fs.writeFileSync(absPath, content, 'utf8');
-        filesCreated.push(relativePath);
-    }
-    // Output
-    logger.section('Plugin scaffolded');
-    for (const file of filesCreated) {
-        logger.success(`Created plugins/${name}/${file}`);
-    }
-    for (const file of filesSkipped) {
-        logger.warn(`Skipped plugins/${name}/${file} (already exists)`);
-    }
-    logger.newline();
-    logger.section('Next steps');
-    logger.log(`  Ensure your .flowweaver/config.yaml has: pluginsDir: plugins`);
-    logger.log(`  Then restart the editor to load the plugin.`);
-    logger.newline();
-}
-//# sourceMappingURL=plugin.js.map