@lhi/n8m 0.2.4 → 0.3.0

package/dist/commands/fixture.js

@@ -215,12 +215,31 @@ export default class Fixture extends Command {
             return;
         }
         const fixtureManager = new FixtureManager();
-        const fixturePath = path.join(process.cwd(), '.n8m', 'fixtures', `${resolvedId}.json`);
+        const defaultName = latest.status === 'success' ? 'happy-path' : 'error-case';
+        const { fixtureName } = await inquirer.prompt([{
+                type: 'input',
+                name: 'fixtureName',
+                message: 'Name this fixture (e.g. happy-path, missing-field, bad-auth):',
+                default: defaultName,
+            }]);
+        const { expectedOutcome } = await inquirer.prompt([{
+                type: 'select',
+                name: 'expectedOutcome',
+                message: 'Expected test outcome for this case:',
+                choices: [
+                    { name: 'pass  — execution should succeed', value: 'pass' },
+                    { name: 'fail  — execution should fail (testing error handling)', value: 'fail' },
+                ],
+                default: latest.status === 'success' ? 'pass' : 'fail',
+            }]);
+        const fixtureDir = path.join(process.cwd(), '.n8m', 'fixtures', resolvedId);
+        const safeName = fixtureName.replace(/[^a-z0-9_-]/gi, '-').replace(/-+/g, '-').toLowerCase();
+        const fixturePath = path.join(fixtureDir, `${safeName}.json`);
         if (existsSync(fixturePath)) {
             const { overwrite } = await inquirer.prompt([{
                     type: 'confirm',
                     name: 'overwrite',
-                    message: `Fixture already exists for workflow ${resolvedId}. Overwrite?`,
+                    message: `Fixture "${safeName}" already exists. Overwrite?`,
                     default: true,
                 }]);
             if (!overwrite) {
@@ -228,11 +247,13 @@ export default class Fixture extends Command {
                 return;
             }
         }
-        await fixtureManager.save({
+        await fixtureManager.saveNamed({
             version: '1.0',
             capturedAt: new Date().toISOString(),
             workflowId: resolvedId,
             workflowName: resolvedName ?? resolvedId,
+            description: fixtureName,
+            expectedOutcome: expectedOutcome,
             workflow,
             execution: {
                 id: fullExec.id,
@@ -245,14 +266,16 @@ export default class Fixture extends Command {
                     },
                 },
             },
-        });
+        }, safeName);
         const nodeCount = Object.keys(fullExec.data?.resultData?.runData ?? {}).length;
-        this.log(theme.success(`Fixture saved to .n8m/fixtures/${resolvedId}.json`));
+        this.log(theme.success(`Fixture saved to .n8m/fixtures/${resolvedId}/${safeName}.json`));
         this.log(theme.muted(`  Workflow: ${resolvedName}`));
         this.log(theme.muted(`  Execution: ${fullExec.status} · ${nodeCount} node(s) captured`));
+        this.log(theme.muted(`  Expected outcome: ${expectedOutcome}`));
         this.log('');
-        this.log(theme.muted('  To test with this fixture:'));
-        this.log(theme.muted(`    n8m test --fixture .n8m/fixtures/${resolvedId}.json`));
-        this.log(theme.muted(`  Or just run: n8m test  (auto-detected by workflow ID)`));
+        this.log(theme.muted('  To run this fixture:'));
+        this.log(theme.muted(`    n8m test --fixture .n8m/fixtures/${resolvedId}/${safeName}.json`));
+        this.log(theme.muted('  To run all fixtures for this workflow:'));
+        this.log(theme.muted(`    n8m test --fixture .n8m/fixtures/${resolvedId}`));
     }
 }

package/dist/commands/learn.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class Learn extends Command {
+    static args: {
+        workflow: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        github: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'github-path': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private runGitHubImport;
+    private collectMdFiles;
+    private processWorkflow;
+}

package/dist/commands/learn.js

@@ -0,0 +1,277 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { theme } from '../utils/theme.js';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+async function listGitHubPatterns(owner, repo, dirPath, branch, token) {
+    const url = `https://api.github.com/repos/${owner}/${repo}/contents/${dirPath}${branch ? `?ref=${branch}` : ''}`;
+    const headers = { 'User-Agent': 'n8m-cli', Accept: 'application/vnd.github.v3+json' };
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const res = await fetch(url, { headers });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`GitHub API error ${res.status}: ${body}`);
+    }
+    const entries = await res.json();
+    return entries;
+}
+async function fetchRaw(url, token) {
+    const headers = { 'User-Agent': 'n8m-cli' };
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const res = await fetch(url, { headers });
+    if (!res.ok)
+        throw new Error(`Failed to fetch ${url}: ${res.status}`);
+    return res.text();
+}
+async function findWorkflowFiles(rootDir) {
+    const choices = [];
+    async function scan(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await scan(fullPath);
+            }
+            else if (entry.name.endsWith('.json')) {
+                const rel = path.relative(rootDir, fullPath);
+                let label = rel;
+                try {
+                    const raw = await fs.readFile(fullPath, 'utf-8');
+                    const parsed = JSON.parse(raw);
+                    if (parsed.name)
+                        label = `${parsed.name}  (${rel})`;
+                }
+                catch {
+                    // use rel path as label
+                }
+                choices.push({ name: label, value: fullPath });
+            }
+        }
+    }
+    await scan(rootDir);
+    return choices;
+}
+export default class Learn extends Command {
+    static args = {
+        workflow: Args.string({
+            description: 'Path to workflow JSON file (omit for interactive menu)',
+            required: false,
+        }),
+    };
+    static description = 'Extract reusable patterns from a validated workflow into the pattern library';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> ./workflows/my-workflow/workflow.json',
+        '<%= config.bin %> <%= command.id %> --github owner/repo',
+        '<%= config.bin %> <%= command.id %> --github owner/repo --github-path patterns/google',
+    ];
+    static flags = {
+        dir: Flags.string({
+            char: 'd',
+            description: 'Directory to scan for workflows (default: ./workflows)',
+        }),
+        all: Flags.boolean({
+            description: 'Generate patterns for all workflows in the directory',
+            default: false,
+        }),
+        github: Flags.string({
+            description: 'Import patterns from a GitHub repo (format: owner/repo or owner/repo@branch)',
+        }),
+        'github-path': Flags.string({
+            description: 'Path within the GitHub repo to import from (default: patterns)',
+            default: 'patterns',
+        }),
+        token: Flags.string({
+            description: 'GitHub personal access token (increases rate limit for public repos)',
+            env: 'GITHUB_TOKEN',
+        }),
+    };
+    async run() {
+        this.log(theme.brand());
+        const { args, flags } = await this.parse(Learn);
+        this.log(theme.header('PATTERN LEARNING'));
+        const patternsDir = path.join(process.cwd(), '.n8m', 'patterns');
+        await fs.mkdir(patternsDir, { recursive: true });
+        // GitHub import mode
+        if (flags.github) {
+            await this.runGitHubImport(flags.github, flags['github-path'], flags.token, patternsDir);
+            return;
+        }
+        // Local workflow → AI generation mode
+        const { AIService } = await import('../services/ai.service.js');
+        const aiService = AIService.getInstance();
+        const workflowsDir = flags.dir ?? path.join(process.cwd(), 'workflows');
+        let workflowPaths = [];
+        if (args.workflow) {
+            workflowPaths = [args.workflow];
+        }
+        else if (flags.all) {
+            this.log(theme.agent(`Scanning ${theme.secondary(workflowsDir)} for workflows...`));
+            const choices = await findWorkflowFiles(workflowsDir);
+            if (choices.length === 0) {
+                this.error(`No workflow JSON files found in ${workflowsDir}.`);
+            }
+            workflowPaths = choices.map(c => c.value);
+            this.log(theme.info(`Found ${workflowPaths.length} workflow(s).`));
+        }
+        else {
+            const { default: select } = await import('@inquirer/select');
+            this.log(theme.agent(`Scanning ${theme.secondary(workflowsDir)} for workflows...`));
+            const choices = await findWorkflowFiles(workflowsDir);
+            if (choices.length === 0) {
+                this.error(`No workflow JSON files found in ${workflowsDir}. Pass a file path directly or use --dir to specify another directory.`);
+            }
+            const selected = await select({
+                message: 'Select a workflow to learn from:',
+                choices,
+                pageSize: 15,
+            });
+            workflowPaths = [selected];
+        }
+        for (const workflowPath of workflowPaths) {
+            await this.processWorkflow(workflowPath, patternsDir, aiService);
+        }
+    }
+    async runGitHubImport(repoArg, dirPath, token, patternsDir) {
+        // Parse owner/repo@branch
+        const [repoPart, branch = ''] = repoArg.split('@');
+        const [owner, repo] = repoPart.split('/');
+        if (!owner || !repo) {
+            this.error('--github must be in the format owner/repo or owner/repo@branch');
+        }
+        this.log(theme.agent(`Fetching pattern list from ${theme.secondary(`github.com/${owner}/${repo}/${dirPath}`)}...`));
+        let entries;
+        try {
+            entries = await listGitHubPatterns(owner, repo, dirPath, branch, token);
+        }
+        catch (err) {
+            this.error(`Could not reach GitHub: ${err.message}`);
+        }
+        // Collect all .md files, recursing into subdirectories
+        const mdFiles = await this.collectMdFiles(entries, owner, repo, branch, token);
+        if (mdFiles.length === 0) {
+            this.log(theme.warn(`No .md pattern files found at ${dirPath} in ${owner}/${repo}.`));
+            return;
+        }
+        this.log(theme.info(`Found ${mdFiles.length} pattern(s).`));
+        const { checkbox } = await import('inquirer');
+        const selected = await checkbox({
+            message: 'Select patterns to import:',
+            choices: mdFiles.map(f => ({ name: f.path, value: f.path, checked: true })),
+            pageSize: 20,
+        });
+        if (selected.length === 0) {
+            this.log(theme.muted('Nothing selected.'));
+            return;
+        }
+        const toDownload = mdFiles.filter(f => selected.includes(f.path));
+        for (const file of toDownload) {
+            if (!file.download_url)
+                continue;
+            this.log(theme.agent(`Downloading ${theme.secondary(file.name)}...`));
+            const content = await fetchRaw(file.download_url, token);
+            const outPath = path.join(patternsDir, file.name);
+            if (existsSync(outPath)) {
+                const { default: select } = await import('@inquirer/select');
+                const action = await select({
+                    message: `"${file.name}" already exists locally. Overwrite?`,
+                    choices: [
+                        { name: 'Overwrite', value: 'overwrite' },
+                        { name: 'Skip', value: 'skip' },
+                    ],
+                });
+                if (action === 'skip') {
+                    this.log(theme.muted(`Skipped ${file.name}.`));
+                    continue;
+                }
+            }
+            await fs.writeFile(outPath, content, 'utf-8');
+            this.log(theme.done(`Saved: ${theme.primary(outPath)}`));
+        }
+        this.log(theme.done(`Import complete. ${toDownload.length} pattern(s) added to ${theme.primary(patternsDir)}`));
+    }
+    async collectMdFiles(entries, owner, repo, branch, token) {
+        const result = [];
+        for (const entry of entries) {
+            if (entry.type === 'file' && entry.name.endsWith('.md')) {
+                result.push(entry);
+            }
+            else if (entry.type === 'dir') {
+                try {
+                    const sub = await listGitHubPatterns(owner, repo, entry.path, branch, token);
+                    const subFiles = await this.collectMdFiles(sub, owner, repo, branch, token);
+                    result.push(...subFiles);
+                }
+                catch {
+                    // skip unreadable subdirs
+                }
+            }
+        }
+        return result;
+    }
+    async processWorkflow(workflowPath, patternsDir, aiService) {
+        this.log(theme.divider(40));
+        this.log(`${theme.label('Workflow')} ${theme.value(workflowPath)}`);
+        let workflowJson;
+        try {
+            const raw = await fs.readFile(workflowPath, 'utf-8');
+            workflowJson = JSON.parse(raw);
+        }
+        catch {
+            this.log(theme.fail(`Could not read or parse ${workflowPath} — skipping.`));
+            return;
+        }
+        this.log(theme.agent(`Analyzing ${theme.secondary(workflowJson.name || 'workflow')}...`));
+        const { content, slug } = await aiService.generatePattern(workflowJson);
+        // Show preview
+        this.log(theme.subHeader('Generated Pattern Preview'));
+        const previewLines = content.split('\n').slice(0, 20);
+        previewLines.forEach((line) => this.log(theme.muted(line)));
+        if (content.split('\n').length > 20) {
+            this.log(theme.muted(`  ... (${content.split('\n').length - 20} more lines)`));
+        }
+        this.log('');
+        const outPath = path.join(patternsDir, `${slug}.md`);
+        const alreadyExists = existsSync(outPath);
+        const { default: select } = await import('@inquirer/select');
+        const action = await select({
+            message: alreadyExists
+                ? `Pattern file "${slug}.md" already exists. What would you like to do?`
+                : `Save pattern as "${slug}.md"?`,
+            choices: alreadyExists
+                ? [
+                    { name: 'Overwrite existing pattern', value: 'save' },
+                    { name: 'Save with a new name', value: 'rename' },
+                    { name: 'Skip', value: 'skip' },
+                ]
+                : [
+                    { name: 'Save pattern', value: 'save' },
+                    { name: 'Save with a different name', value: 'rename' },
+                    { name: 'Skip', value: 'skip' },
+                ],
+        });
+        if (action === 'skip') {
+            this.log(theme.muted('Skipped.'));
+            return;
+        }
+        let finalPath = outPath;
+        if (action === 'rename') {
+            const { default: input } = await import('@inquirer/input');
+            const customName = await input({
+                message: 'Enter filename (without .md):',
+                default: slug,
+            });
+            finalPath = path.join(patternsDir, `${customName.replace(/\.md$/, '')}.md`);
+        }
+        await fs.writeFile(finalPath, content, 'utf-8');
+        this.log(theme.done(`Pattern saved: ${theme.primary(finalPath)}`));
+    }
+}