fogtrail-cli 0.1.0

package/README.md

@@ -0,0 +1,61 @@
+# fogtrail-cli
+
+CLI tool to push blog content to your [Fogtrail](https://fogtrail.io) instance for AEO (Answer Engine Optimization).
+
+## Installation
+
+```bash
+# Use directly with npx (no install needed)
+npx fogtrail-cli push --token <TOKEN> --dir ./blogs
+
+# Or install globally
+npm install -g fogtrail-cli
+```
+
+## Usage
+
+### Push blog content
+
+Push all markdown and HTML files from a directory to Fogtrail:
+
+```bash
+fogtrail-cli push --token <TOKEN> --dir ./blogs --url https://your-fogtrail-instance.com
+```
+
+### Options
+
+| Option | Required | Default | Description |
+|--------|----------|---------|-------------|
+| `--token <token>` | Yes | - | Ingest session token from Fogtrail UI |
+| `--dir <directory>` | Yes | - | Directory containing blog files (.md, .html) |
+| `--url <url>` | No | `http://localhost:3000` | Fogtrail instance URL |
+| `--batch-size <size>` | No | `10` | Number of files per upload batch |
+| `--no-recursive` | No | - | Do not scan subdirectories |
+
+### How it works
+
+1. Open your Fogtrail dashboard and click **Add Content** > **Import from Website**
+2. Copy the command shown in the dialog (includes your unique token)
+3. Run the command in your terminal from your project directory
+4. The CLI scans for `.md` and `.html` files, uploads them to Fogtrail
+5. HTML files are automatically converted to Markdown
+6. Files without YAML frontmatter get auto-generated metadata
+
+### Supported file formats
+
+- **Markdown** (`.md`) - uploaded as-is with frontmatter validation
+- **HTML** (`.html`, `.htm`) - converted to Markdown before upload
+
+### Example
+
+```bash
+# Push all blog posts from ./content/blog
+npx fogtrail-cli push \
+  --token abc123def456... \
+  --dir ./content/blog \
+  --url https://app.fogtrail.io
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const push_1 = require("./push");
+const program = new commander_1.Command();
+program
+    .name('fogtrail-cli')
+    .description('Push blog content to your Fogtrail instance')
+    .version('0.1.0');
+program
+    .command('push')
+    .description('Push markdown/HTML files to Fogtrail')
+    .requiredOption('--token <token>', 'Ingest session token (from Fogtrail UI)')
+    .requiredOption('--dir <directory>', 'Directory containing blog files (.md, .html)')
+    .option('--url <url>', 'Fogtrail instance URL', 'http://localhost:3000')
+    .option('--batch-size <size>', 'Files per request batch', '10')
+    .option('--no-recursive', 'Do not scan subdirectories')
+    .action(push_1.pushCommand);
+program.parse();

package/dist/push.d.ts

@@ -0,0 +1,9 @@
+interface PushOptions {
+    token: string;
+    dir: string;
+    url: string;
+    batchSize: string;
+    recursive: boolean;
+}
+export declare function pushCommand(options: PushOptions): Promise<void>;
+export {};

package/dist/push.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushCommand = pushCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const utils_1 = require("./utils");
+async function pushCommand(options) {
+    const { token, dir, url, batchSize: batchSizeStr } = options;
+    const recursive = options.recursive !== false;
+    const batchSize = parseInt(batchSizeStr, 10) || 10;
+    // Validate directory
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        console.error(`Error: Directory not found: ${resolvedDir}`);
+        process.exit(1);
+    }
+    if (!fs.statSync(resolvedDir).isDirectory()) {
+        console.error(`Error: Not a directory: ${resolvedDir}`);
+        process.exit(1);
+    }
+    console.log(`Scanning ${resolvedDir} for blog files...`);
+    // Discover files
+    const files = await (0, utils_1.discoverFiles)(resolvedDir, recursive);
+    if (files.length === 0) {
+        console.log('No .md or .html files found.');
+        process.exit(0);
+    }
+    console.log(`Found ${files.length} file${files.length !== 1 ? 's' : ''}`);
+    // Read all files
+    const entries = [];
+    let readErrors = 0;
+    for (const filepath of files) {
+        try {
+            const entry = (0, utils_1.readFileContent)(filepath);
+            entries.push(entry);
+        }
+        catch (error) {
+            const err = error;
+            console.error(`  Warning: Failed to read ${path.basename(filepath)}: ${err.message}`);
+            readErrors++;
+        }
+    }
+    if (entries.length === 0) {
+        console.error('No files could be read.');
+        process.exit(1);
+    }
+    console.log(`Read ${entries.length} file${entries.length !== 1 ? 's' : ''}${readErrors > 0 ? ` (${readErrors} failed)` : ''}`);
+    console.log();
+    // Upload in batches
+    const totalBatches = Math.ceil(entries.length / batchSize);
+    let totalReceived = 0;
+    let totalErrors = [];
+    const apiUrl = `${url.replace(/\/$/, '')}/api/ingest/push`;
+    for (let i = 0; i < totalBatches; i++) {
+        const start = i * batchSize;
+        const end = Math.min(start + batchSize, entries.length);
+        const batch = entries.slice(start, end);
+        const isLastBatch = i === totalBatches - 1;
+        const progress = `[${end}/${entries.length}]`;
+        process.stdout.write(`${progress} Uploading batch ${i + 1} of ${totalBatches}...`);
+        try {
+            const response = await fetch(apiUrl, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    files: batch.map((entry) => ({
+                        filename: entry.filename,
+                        content: entry.content,
+                        sourceUrl: entry.sourceUrl,
+                    })),
+                    done: isLastBatch,
+                }),
+            });
+            if (!response.ok) {
+                const data = await response.json().catch(() => ({ error: `HTTP ${response.status}` }));
+                if (response.status === 401) {
+                    console.error(` failed\n\nError: Invalid token. Please check your token and try again.`);
+                    process.exit(1);
+                }
+                if (response.status === 410) {
+                    console.error(` failed\n\nError: Session expired. Please create a new import session from the Fogtrail UI.`);
+                    process.exit(1);
+                }
+                console.error(` failed\n\nError: ${data.error || `HTTP ${response.status}`}`);
+                process.exit(1);
+            }
+            const data = await response.json();
+            if (!data.success) {
+                console.error(` failed: ${data.error}`);
+                process.exit(1);
+            }
+            totalReceived += data.received || 0;
+            if (data.errors && data.errors.length > 0) {
+                totalErrors = [...totalErrors, ...data.errors];
+            }
+            console.log(' done');
+        }
+        catch (error) {
+            const err = error;
+            if (err.message.includes('ECONNREFUSED') || err.message.includes('fetch failed')) {
+                console.error(` failed\n\nError: Could not connect to ${url}. Make sure your Fogtrail instance is running.`);
+            }
+            else {
+                console.error(` failed\n\nError: ${err.message}`);
+            }
+            process.exit(1);
+        }
+    }
+    // Summary
+    console.log();
+    console.log(`Successfully pushed ${totalReceived} file${totalReceived !== 1 ? 's' : ''} to Fogtrail`);
+    if (totalErrors.length > 0) {
+        console.log(`${totalErrors.length} error${totalErrors.length !== 1 ? 's' : ''}:`);
+        for (const err of totalErrors.slice(0, 10)) {
+            console.log(`  - ${err}`);
+        }
+        if (totalErrors.length > 10) {
+            console.log(`  ...and ${totalErrors.length - 10} more`);
+        }
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,21 @@
+export interface FileEntry {
+    filename: string;
+    content: string;
+    sourceUrl: string | null;
+}
+/**
+ * Discover all .md and .html files in a directory
+ */
+export declare function discoverFiles(dir: string, recursive: boolean): Promise<string[]>;
+/**
+ * Read a file and return its content, converting HTML to markdown if needed
+ */
+export declare function readFileContent(filepath: string): FileEntry;
+/**
+ * Convert HTML to Markdown
+ */
+export declare function htmlToMarkdown(html: string): string;
+/**
+ * Ensure content has YAML frontmatter. If not, generate minimal frontmatter.
+ */
+export declare function ensureFrontmatter(content: string, filename: string): string;

package/dist/utils.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverFiles = discoverFiles;
+exports.readFileContent = readFileContent;
+exports.htmlToMarkdown = htmlToMarkdown;
+exports.ensureFrontmatter = ensureFrontmatter;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const turndown_1 = __importDefault(require("turndown"));
+const turndown = new turndown_1.default({
+    headingStyle: 'atx',
+    codeBlockStyle: 'fenced',
+});
+/**
+ * Discover all .md and .html files in a directory
+ */
+async function discoverFiles(dir, recursive) {
+    const pattern = recursive ? '**/*.{md,html,htm}' : '*.{md,html,htm}';
+    const files = await (0, glob_1.glob)(pattern, {
+        cwd: dir,
+        nodir: true,
+        absolute: true,
+    });
+    return files.sort();
+}
+/**
+ * Read a file and return its content, converting HTML to markdown if needed
+ */
+function readFileContent(filepath) {
+    const content = fs.readFileSync(filepath, 'utf-8');
+    const filename = path.basename(filepath);
+    const ext = path.extname(filepath).toLowerCase();
+    let finalContent;
+    if (ext === '.html' || ext === '.htm') {
+        finalContent = htmlToMarkdown(content);
+    }
+    else {
+        finalContent = content;
+    }
+    // Ensure frontmatter exists
+    finalContent = ensureFrontmatter(finalContent, filename);
+    return {
+        filename,
+        content: finalContent,
+        sourceUrl: null,
+    };
+}
+/**
+ * Convert HTML to Markdown
+ */
+function htmlToMarkdown(html) {
+    return turndown.turndown(html);
+}
+/**
+ * Ensure content has YAML frontmatter. If not, generate minimal frontmatter.
+ */
+function ensureFrontmatter(content, filename) {
+    try {
+        const parsed = (0, gray_matter_1.default)(content);
+        if (parsed.data && Object.keys(parsed.data).length > 0) {
+            return content; // Already has frontmatter
+        }
+    }
+    catch {
+        // Not valid frontmatter, continue to add it
+    }
+    // Extract title from first heading or filename
+    const headingMatch = content.match(/^#\s+(.+)$/m);
+    const title = headingMatch
+        ? headingMatch[1].trim()
+        : filename.replace(/\.(md|html|htm)$/i, '').replace(/[-_]/g, ' ');
+    const escapedTitle = title.replace(/"/g, '\\"');
+    const frontmatter = `---\ntitle: "${escapedTitle}"\ntopics: []\n---\n\n`;
+    return frontmatter + content;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "fogtrail-cli",
+  "version": "0.1.0",
+  "description": "CLI tool to push blog content to Fogtrail for AEO optimization",
+  "bin": {
+    "fogtrail-cli": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "fogtrail",
+    "aeo",
+    "seo",
+    "blog",
+    "content",
+    "cli"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "glob": "^11.0.0",
+    "gray-matter": "^4.0.3",
+    "turndown": "^7.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/turndown": "^5.0.5",
+    "typescript": "^5"
+  }
+}