@synergenius/flow-weaver 0.22.8 → 0.22.10

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

@@ -32,6 +32,7 @@ export interface InitConfig {
     /** Free-text description when user picked "Something else" */
     useCaseDescription?: string;
     mcp: boolean;
+    installWeaver: boolean;
 }
 export interface InitReport {
     projectDir: string;
@@ -55,7 +56,7 @@ export declare function validateProjectName(name: string): string | true;
 export declare function toWorkflowName(projectName: string): string;
 export declare function isNonInteractive(): boolean;
 export declare function resolveInitConfig(dirArg: string | undefined, options: InitOptions): Promise<InitConfig>;
-export declare function generateProjectFiles(projectName: string, template: string, format?: TModuleFormat, persona?: PersonaId): Record<string, string>;
+export declare function generateProjectFiles(projectName: string, template: string, format?: TModuleFormat, persona?: PersonaId, installWeaver?: boolean): Record<string, string>;
 export declare function scaffoldProject(targetDir: string, files: Record<string, string>, options: {
     force: boolean;
 }): {

package/dist/cli/commands/init.js

@@ -183,6 +183,17 @@ export async function resolveInitConfig(dirArg, options) {
         if (!useCaseDescription)
             useCaseDescription = undefined;
     }
+    // 3c. Weaver AI assistant opt-in
+    let installWeaver;
+    if (skipPrompts) {
+        installWeaver = false;
+    }
+    else {
+        installWeaver = await confirm({
+            message: 'Install Weaver AI assistant? (Recommended)\n  Weaver helps you create, modify, and manage workflows with AI.',
+            default: true,
+        });
+    }
     // 4. MCP setup (nocode, vibecoder, lowcode: prompt; expert: skip unless --mcp)
     let mcp;
     if (options.mcp !== undefined) {
@@ -255,10 +266,11 @@ export async function resolveInitConfig(dirArg, options) {
         useCase,
         useCaseDescription,
         mcp,
+        installWeaver,
     };
 }
 // ── Pure file generation ─────────────────────────────────────────────────────
-export function generateProjectFiles(projectName, template, format = 'esm', persona = 'expert') {
+export function generateProjectFiles(projectName, template, format = 'esm', persona = 'expert', installWeaver = false) {
     const workflowName = toWorkflowName(projectName);
     const workflowFile = `${projectName}-workflow.ts`;
     const tmpl = getWorkflowTemplate(template);
@@ -284,6 +296,7 @@ export function generateProjectFiles(projectName, template, format = 'esm', pers
         scripts,
         dependencies: {
             '@synergenius/flow-weaver': 'latest',
+            ...(installWeaver ? { '@synergenius/flow-weaver-pack-weaver': 'latest' } : {}),
         },
         devDependencies: {
             typescript: '^5.3.0',
@@ -382,6 +395,10 @@ export function generateProjectFiles(projectName, template, format = 'esm', pers
     if (persona === 'lowcode') {
         files['examples/example-workflow.ts'] = generateExampleWorkflow(projectName);
     }
+    // Add Weaver config if opted in
+    if (installWeaver) {
+        files['.weaver.json'] = JSON.stringify({ provider: 'auto', approval: 'auto' }, null, 2) + '\n';
+    }
     return files;
 }
 // ── Filesystem writer ────────────────────────────────────────────────────────
@@ -502,7 +519,7 @@ export async function initCommand(dirArg, options) {
             throw new Error(`${config.targetDir} already contains a package.json. Use --force to overwrite.`);
         }
         // Generate and scaffold
-        const files = generateProjectFiles(config.projectName, config.template, config.format, config.persona);
+        const files = generateProjectFiles(config.projectName, config.template, config.format, config.persona, config.installWeaver);
         const { filesCreated, filesSkipped } = scaffoldProject(config.targetDir, files, {
             force: config.force,
         });
@@ -622,6 +639,15 @@ export async function initCommand(dirArg, options) {
                 logger.warn(`Compile failed: ${compileResult.error}`);
             }
         }
+        if (config.installWeaver) {
+            logger.success('Weaver AI assistant installed');
+            logger.newline();
+            logger.log('  Weaver installed. Try:');
+            logger.log('    flow-weaver weaver assistant      # AI assistant');
+            logger.log('    flow-weaver weaver bot "..."      # create workflows with AI');
+            logger.log('    flow-weaver weaver examples       # see what\'s possible');
+            logger.newline();
+        }
         // Read the workflow code for preview
         const workflowCode = files[`src/${workflowFile}`] ?? null;
         // Persona-specific rich output

package/dist/cli/config/credentials.d.ts

@@ -0,0 +1,15 @@
+export interface StoredCredentials {
+    token: string;
+    email: string;
+    plan: 'free' | 'pro' | 'business';
+    platformUrl: string;
+    expiresAt: number;
+    userId?: string;
+}
+export declare function loadCredentials(): StoredCredentials | null;
+export declare function saveCredentials(creds: StoredCredentials): void;
+export declare function clearCredentials(): void;
+export declare function isTokenExpired(creds: StoredCredentials): boolean;
+export declare function getPlatformUrl(): string;
+export declare function isLoggedIn(): boolean;
+//# sourceMappingURL=credentials.d.ts.map

package/dist/cli/config/credentials.js

@@ -0,0 +1,43 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const FW_CONFIG_DIR = path.join(os.homedir(), '.fw');
+const CREDENTIALS_FILE = path.join(FW_CONFIG_DIR, 'credentials.json');
+export function loadCredentials() {
+    if (!fs.existsSync(CREDENTIALS_FILE))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf-8'));
+        if (isTokenExpired(data))
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    fs.mkdirSync(FW_CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), 'utf-8');
+    try {
+        fs.chmodSync(CREDENTIALS_FILE, 0o600);
+    }
+    catch { /* Windows */ }
+}
+export function clearCredentials() {
+    try {
+        fs.unlinkSync(CREDENTIALS_FILE);
+    }
+    catch { /* not found */ }
+}
+export function isTokenExpired(creds) {
+    return Date.now() > creds.expiresAt;
+}
+export function getPlatformUrl() {
+    const creds = loadCredentials();
+    return creds?.platformUrl ?? process.env.FW_PLATFORM_URL ?? 'https://app.synergenius.pt';
+}
+export function isLoggedIn() {
+    return loadCredentials() !== null;
+}
+//# sourceMappingURL=credentials.js.map

package/dist/cli/config/platform-client.d.ts

@@ -0,0 +1,36 @@
+import type { StoredCredentials } from './credentials.js';
+export declare class PlatformClient {
+    private baseUrl;
+    private token;
+    constructor(creds: StoredCredentials);
+    private fetch;
+    getUser(): Promise<{
+        id: string;
+        email: string;
+        name: string;
+        plan: string;
+    }>;
+    pushWorkflow(name: string, source: string): Promise<{
+        slug: string;
+        version: number;
+    }>;
+    deploy(slug: string): Promise<{
+        slug: string;
+        status: string;
+    }>;
+    undeploy(slug: string): Promise<void>;
+    listDeployments(): Promise<Array<{
+        slug: string;
+        status: string;
+        workflowName?: string;
+    }>>;
+    getUsage(): Promise<{
+        executions: number;
+        aiCalls: number;
+        plan: string;
+    }>;
+    streamChat(message: string, conversationId?: string): AsyncGenerator<Record<string, unknown>>;
+    validate(): Promise<boolean>;
+}
+export declare function createPlatformClient(creds: StoredCredentials): PlatformClient;
+//# sourceMappingURL=platform-client.d.ts.map

package/dist/cli/config/platform-client.js

@@ -0,0 +1,122 @@
+export class PlatformClient {
+    baseUrl;
+    token;
+    constructor(creds) {
+        this.baseUrl = creds.platformUrl.replace(/\/+$/, '');
+        this.token = creds.token;
+    }
+    async fetch(path, opts = {}) {
+        const isApiKey = this.token.startsWith('fw_');
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(isApiKey
+                ? { 'X-API-Key': this.token }
+                : { Authorization: `Bearer ${this.token}` }),
+            ...(opts.headers ?? {}),
+        };
+        return fetch(`${this.baseUrl}${path}`, { ...opts, headers });
+    }
+    // Auth
+    async getUser() {
+        const resp = await this.fetch('/auth/me');
+        if (!resp.ok)
+            throw new Error(`Auth failed: ${resp.status}`);
+        const data = await resp.json();
+        return data.user;
+    }
+    // Workflows
+    async pushWorkflow(name, source) {
+        // Try update first, then create
+        const slug = name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+        let resp = await this.fetch(`/workflows/${slug}`, {
+            method: 'PUT',
+            body: JSON.stringify({ source, name }),
+        });
+        if (resp.status === 404) {
+            resp = await this.fetch('/workflows', {
+                method: 'POST',
+                body: JSON.stringify({ source, name }),
+            });
+        }
+        if (!resp.ok) {
+            const err = await resp.json().catch(() => ({ error: resp.statusText }));
+            throw new Error(err.error ?? `Push failed: ${resp.status}`);
+        }
+        const data = await resp.json();
+        return data.workflow;
+    }
+    async deploy(slug) {
+        const resp = await this.fetch(`/workflows/${slug}/deploy`, { method: 'POST' });
+        if (!resp.ok) {
+            const err = await resp.json().catch(() => ({ error: resp.statusText }));
+            throw new Error(err.error ?? `Deploy failed: ${resp.status}`);
+        }
+        const data = await resp.json();
+        return data.deployment;
+    }
+    async undeploy(slug) {
+        const resp = await this.fetch(`/deployments/${slug}`, { method: 'DELETE' });
+        if (!resp.ok && resp.status !== 404)
+            throw new Error(`Undeploy failed: ${resp.status}`);
+    }
+    async listDeployments() {
+        const resp = await this.fetch('/deployments');
+        if (!resp.ok)
+            throw new Error(`List failed: ${resp.status}`);
+        const data = await resp.json();
+        return data.deployments;
+    }
+    // Usage
+    async getUsage() {
+        const resp = await this.fetch('/monitoring/usage');
+        if (!resp.ok)
+            return { executions: 0, aiCalls: 0, plan: 'unknown' };
+        return await resp.json();
+    }
+    // AI Chat streaming
+    async *streamChat(message, conversationId) {
+        const resp = await this.fetch('/ai-chat/stream', {
+            method: 'POST',
+            body: JSON.stringify({ message, conversationId }),
+        });
+        if (!resp.ok) {
+            const err = await resp.text();
+            throw new Error(`AI chat failed: ${resp.status} ${err.slice(0, 200)}`);
+        }
+        if (!resp.body)
+            return;
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                try {
+                    yield JSON.parse(line.slice(6));
+                }
+                catch { /* skip non-JSON */ }
+            }
+        }
+    }
+    // Validate connection
+    async validate() {
+        try {
+            const resp = await this.fetch('/ready');
+            return resp.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export function createPlatformClient(creds) {
+    return new PlatformClient(creds);
+}
+//# sourceMappingURL=platform-client.js.map