forkfeed-mcp 1.0.15 → 1.2.0

package/dist/index.js

@@ -1,12 +1,15 @@
 #!/usr/bin/env node
 import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { join, basename } from 'node:path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import QRCode from 'qrcode';
 import { GUIDE_CONTENT } from './guide-content.js';
-import { IMAGE_CATALOG } from './image-catalog.js';
+import { IMAGE_CATALOG, IMAGE_BASE_URL, resolveImageId } from './image-catalog.js';
+const execFileAsync = promisify(execFile);
 const APP_SERVER_URL = (process.env.APP_SERVER_URL || 'https://api.forkfeed.link').replace(/\/+$/, '');
 const TOKEN = process.env.FORKFEED_TOKEN || '';
 // ── Manifest schemas ──────────────────────────────────────────────────
@@ -14,7 +17,7 @@ const forkSchema = z.object({
     _id: z.string().min(1, 'Fork _id is required'),
     title: z.string().min(1, 'Fork title is required'),
     description: z.string(),
-    imageSrc: z.string(),
+    imageSrc: z.string().min(1, 'Fork imageSrc is required'),
     feedIds: z.array(z.string().min(1)).min(1, 'Fork must reference at least one feed'),
     actionLabel: z.string().optional(),
     actionUrl: z.string().optional(),
@@ -23,7 +26,7 @@ const feedSchema = z.object({
     _id: z.string().min(1, 'Feed _id is required'),
     title: z.string().min(1, 'Feed title is required').max(60, 'Feed title max 60 chars'),
     description: z.string().optional(),
-    imageSrc: z.string(),
+    imageSrc: z.string().min(1, 'Feed imageSrc is required'),
     mode: z.string(),
     scrollDirection: z.string(),
     engagement: z.boolean().optional(),
@@ -40,14 +43,13 @@ const contentBlockSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal('CONTENT_TITLE'), title: z.string().min(1) }).passthrough(),
     z.object({ type: z.literal('CONTENT_TEXT'), text: z.string().min(1) }).passthrough(),
     z.object({ type: z.literal('CONTENT_CODE'), code: z.string().min(1), language: z.string().optional() }).passthrough(),
-    z.object({ type: z.literal('CONTENT_SOCIAL'), name: z.string().min(1), avatarSrc: z.string(), source: socialSourceEnum }).passthrough(),
+    z.object({ type: z.literal('CONTENT_SOCIAL'), name: z.string().min(1), subtitle: z.string().optional(), avatarSrc: z.string(), source: socialSourceEnum }).passthrough(),
     z.object({ type: z.literal('CONTENT_SUBTEXT'), text: z.string().min(1) }).passthrough(),
     z.object({ type: z.literal('CONTENT_QUIZ'), question: z.string().min(1), options: z.array(quizOptionSchema).min(2), explanation: z.string().optional() }).passthrough(),
     z.object({ type: z.literal('CONTENT_BUTTON'), label: z.string().min(1), action: buttonActionEnum, target: z.string().min(1) }).passthrough(),
 ]);
 const variantSchema = z.discriminatedUnion('type', [
-    z.object({ type: z.literal('FULL_IMAGE'), imageSrc: z.string().min(1, 'FULL_IMAGE requires imageSrc'), title: z.string().optional(), subtitle: z.string().optional() }).passthrough(),
-    z.object({ type: z.literal('FULL_VIDEO'), videoSrc: z.string().min(1), title: z.string().optional() }).passthrough(),
+    z.object({ type: z.literal('FULL_IMAGE'), imageSrc: z.string().min(1, 'FULL_IMAGE requires imageSrc'), title: z.string().optional(), subtitle: z.string().max(200, 'FULL_IMAGE subtitle max 200 chars').optional() }).passthrough(),
     z.object({ type: z.literal('CONTENT'), blocks: z.array(contentBlockSchema).min(1, 'CONTENT variant needs at least one block'), backgroundSrc: z.string().optional() }).passthrough(),
 ]);
 const cardSchema = z.object({
@@ -96,76 +98,285 @@ function authHeaders() {
         Authorization: `Bearer ${TOKEN}`,
     };
 }
-// ── MCP Server ─────────────────────────────────────────────────────────
-const server = new McpServer({
-    name: 'forkfeed',
-    version: '1.0.0',
-});
-// ── Tool: forkfeed_guide ───────────────────────────────────────────────
-server.tool('forkfeed_guide', 'Get the complete guide for generating forkfeed content from GitHub commits. Call this first to learn the format before generating content.', {}, async () => ({
-    content: [{ type: 'text', text: GUIDE_CONTENT }],
-}));
-// ── Tool: forkfeed_images ──────────────────────────────────────────────
-server.tool('forkfeed_images', 'Get the IT Scenes image catalog (200 scene images + 30 backgrounds). Use this to pick images that match your content by tags and name. Call after forkfeed_guide.', {}, async () => {
-    const scenes = IMAGE_CATALOG.filter((i) => i.id.startsWith('img'));
-    const bgs = IMAGE_CATALOG.filter((i) => i.id.startsWith('bg'));
-    const lines = [
-        '# IT Scenes Image Catalog',
-        '',
-        'Match images to content by tags and name. Use img* for covers and inline images, bg* for card backgrounds.',
-        '',
-        'Tags: deploy, git, disaster, debug, hype, victory, beginner, language, lifestyle, workplace, sarcastic, general',
-        '',
-        '## Scene Images (covers + inline)',
-        '',
-        ...scenes.map((i) => `${i.id} | ${i.name} | ${i.tags} | ${i.url}`),
-        '',
-        '## Background Images',
-        '',
-        ...bgs.map((i) => `${i.id} | ${i.name} | ${i.tags} | ${i.url}`),
-    ];
-    return { content: [{ type: 'text', text: lines.join('\n') }] };
-});
-// ── Tool: forkfeed_push ────────────────────────────────────────────────
-server.tool('forkfeed_push', 'Push a generated manifest (forks, feeds, cards) to forkfeed. The manifest JSON must conform to the structure described in forkfeed_guide.', {
-    manifest: z
-        .object({
-        forks: z.array(z.any()),
-        feeds: z.array(z.any()),
-        cards: z.array(z.any()),
-    })
-        .describe('The complete manifest with forks, feeds, and cards arrays'),
-}, async ({ manifest }) => {
-    if (!TOKEN) {
+// ── Git helpers ───────────────────────────────────────────────────────
+async function gitExec(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync('git', args, {
+            cwd,
+            maxBuffer: 5 * 1024 * 1024,
+            timeout: 15_000,
+        });
+        return stdout;
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'ENOENT')
+            throw new Error('git command not found. Ensure git is installed and in PATH.');
+        if (e.killed)
+            throw new Error('git command timed out after 15s.');
+        throw new Error(e.stderr?.trim() || e.message || 'git command failed');
+    }
+}
+async function isGitRepo(cwd) {
+    try {
+        await gitExec(['rev-parse', '--is-inside-work-tree'], cwd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getRepoInfo(cwd) {
+    try {
+        const url = (await gitExec(['remote', 'get-url', 'origin'], cwd)).trim();
+        const m = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+        if (m)
+            return { owner: m[1], repo: m[2], isLocal: false };
+    }
+    catch { /* no remote */ }
+    return { owner: null, repo: basename(cwd), isLocal: true };
+}
+async function getCommitList(cwd, count = 15) {
+    const fmt = '%H|%h|%s|%an|%aI|%P';
+    const raw = await gitExec(['log', '--no-merges', `-${count}`, `--format=${fmt}`], cwd);
+    return raw.trim().split('\n').filter(Boolean).map((line) => {
+        const [sha, shortSha, message, author, date] = line.split('|');
+        return { sha, shortSha, message, author, date: date?.slice(0, 10) || '' };
+    });
+}
+function truncateDiff(diff, maxLinesPerFile = 200) {
+    const fileDiffs = diff.split(/^(?=diff --git )/m);
+    return fileDiffs.map((fd) => {
+        if (/^Binary files/.test(fd) || fd.includes('Binary files')) {
+            const path = fd.match(/diff --git a\/(.+?) b\//)?.[1] || 'unknown';
+            return `Binary file: ${path} (skipped)`;
+        }
+        const lines = fd.split('\n');
+        if (lines.length <= maxLinesPerFile)
+            return fd;
+        return lines.slice(0, maxLinesPerFile).join('\n') + `\n... [truncated, ${lines.length - maxLinesPerFile} more lines]`;
+    }).join('\n');
+}
+async function getCommitDetail(cwd, sha) {
+    const [meta, stats, diff] = await Promise.all([
+        gitExec(['show', sha, '--format=%H|%h|%s|%an|%aI', '--no-patch'], cwd),
+        gitExec(['diff', `${sha}^..${sha}`, '--stat'], cwd),
+        gitExec(['diff', `${sha}^..${sha}`, '-U3'], cwd),
+    ]);
+    const [fullSha, shortSha, message, author, date] = meta.trim().split('|');
+    return {
+        sha: fullSha,
+        shortSha,
+        message,
+        author,
+        date: date?.slice(0, 10) || '',
+        stats: stats.trim(),
+        diff: truncateDiff(diff),
+    };
+}
+const TAG_KEYWORDS = {
+    debug: ['fix', 'bug', 'patch', 'hotfix', 'error', 'crash', 'test', 'spec'],
+    deploy: ['deploy', 'release', 'ci', 'cd', 'docker', 'build', 'publish', 'pipeline'],
+    disaster: ['break', 'crash', 'fail', 'revert', 'rollback', 'incident', 'down'],
+    git: ['merge', 'conflict', 'branch', 'rebase', 'cherry-pick'],
+    hype: ['feat', 'feature', 'add', 'new', 'launch', 'ship', 'initial'],
+    victory: ['complete', 'finish', 'done', 'success', 'milestone'],
+    language: ['typescript', 'javascript', 'python', 'rust', 'go', 'java'],
+    general: ['refactor', 'clean', 'update', 'chore', 'docs', 'style'],
+    sarcastic: ['hack', 'workaround', 'todo', 'fixme', 'wtf'],
+    workplace: ['meeting', 'standup', 'review', 'sprint'],
+    lifestyle: ['config', 'setup', 'env', 'tooling'],
+};
+const PATH_TAGS = [
+    [/\.(test|spec)\.[jt]sx?$/, 'debug'],
+    [/\.github\/workflows|Dockerfile|docker|\.ci|Jenkinsfile/, 'deploy'],
+    [/\.env|config/, 'lifestyle'],
+];
+function detectTags(message, filePaths) {
+    const tags = new Set();
+    const lower = message.toLowerCase();
+    for (const [tag, keywords] of Object.entries(TAG_KEYWORDS)) {
+        if (keywords.some((kw) => lower.includes(kw)))
+            tags.add(tag);
+    }
+    for (const fp of filePaths) {
+        for (const [re, tag] of PATH_TAGS) {
+            if (re.test(fp))
+                tags.add(tag);
+        }
+    }
+    if (tags.size === 0)
+        tags.add('general');
+    return [...tags];
+}
+function filterImagesByTags(tags) {
+    const tagSet = new Set(tags);
+    function score(entry) {
+        return entry.tags.split(',').map((t) => t.trim()).filter((t) => tagSet.has(t)).length;
+    }
+    const scenes = IMAGE_CATALOG
+        .filter((i) => i.id.startsWith('img'))
+        .map((i) => ({ ...i, score: score(i) }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 30)
+        .map((i) => `${i.id} | ${i.name} | ${i.tags} | ${IMAGE_BASE_URL}${i.file}`);
+    const backgrounds = IMAGE_CATALOG
+        .filter((i) => i.id.startsWith('bg'))
+        .map((i) => ({ ...i, score: score(i) }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 10)
+        .map((i) => `${i.id} | ${i.name} | ${i.tags} | ${IMAGE_BASE_URL}${i.file}`);
+    return { scenes, backgrounds };
+}
+async function fetchStatusData() {
+    const res = await fetch(`${APP_SERVER_URL}/api/content/status`, {
+        headers: authHeaders(),
+        signal: AbortSignal.timeout(10_000),
+    });
+    const data = await res.json();
+    if (!res.ok)
+        throw new Error(`Status check failed (${res.status}): ${data.error || JSON.stringify(data)}`);
+    return data;
+}
+// ── Cover titles (fixed per card index) ──────────────────────────────
+const COVERS = [
+    { title: "Explain Like I'm 5", subtitle: "Hopefully now you'll understand what you pushed" },
+    { title: "The Roast", subtitle: "Your code had it coming" },
+    { title: "Commit Message, Decoded", subtitle: "What you wrote vs what you meant vs what actually happened" },
+    { title: "The LinkedIn Post", subtitle: "Mass cringe, freshly generated" },
+    { title: "Statistics", subtitle: "The numbers don't lie, but they do judge" },
+    { title: "Learning Moment", subtitle: "Something useful buried in your chaos" },
+    { title: "Alternatives", subtitle: "What you could have done instead" },
+    { title: "Quiz", subtitle: "Let's see if you even understand your own code" },
+];
+// ── Simplified block inference ───────────────────────────────────────
+function inferBlock(block) {
+    if ('question' in block) {
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: 'Error: FORKFEED_TOKEN not set. Get your API token from forkfeed.link/admin/user/token and add it to your .mcp.json env.',
-                },
-            ],
-            isError: true,
+            type: 'CONTENT_QUIZ',
+            question: block.question,
+            options: block.options,
+            ...(block.explanation != null ? { explanation: block.explanation } : {}),
         };
     }
-    // Validate manifest structure before pushing
-    const parsed = manifestSchema.safeParse(manifest);
-    if (!parsed.success) {
-        const issues = parsed.error.issues
-            .map((i) => `  ${i.path.join('.')}: ${i.message}`)
-            .join('\n');
+    if ('name' in block && 'avatar' in block) {
         return {
-            content: [{ type: 'text', text: `Manifest validation failed:\n${issues}\n\nFix the issues above and try again.` }],
-            isError: true,
+            type: 'CONTENT_SOCIAL',
+            name: block.name,
+            avatarSrc: resolveImageId(block.avatar),
+            source: block.source,
+            ...(block.subtitle != null ? { subtitle: block.subtitle } : {}),
         };
     }
-    const crossErr = crossValidate(parsed.data);
-    if (crossErr) {
+    if ('label' in block && 'action' in block && 'target' in block) {
         return {
-            content: [{ type: 'text', text: `Manifest cross-reference errors:\n${crossErr}\n\nFix the issues above and try again.` }],
+            type: 'CONTENT_BUTTON',
+            label: block.label,
+            action: block.action,
+            target: block.target,
+        };
+    }
+    if ('img' in block) {
+        return {
+            type: 'CONTENT_IMAGE',
+            imageSrc: resolveImageId(block.img),
+            sizing: (block.sizing || 'wide'),
+        };
+    }
+    if ('code' in block) {
+        return {
+            type: 'CONTENT_CODE',
+            code: block.code,
+            ...(block.lang != null ? { language: block.lang } : {}),
+        };
+    }
+    if ('subtext' in block) {
+        return { type: 'CONTENT_SUBTEXT', text: block.subtext };
+    }
+    if ('title' in block) {
+        return { type: 'CONTENT_TITLE', title: block.title };
+    }
+    if ('text' in block) {
+        return { type: 'CONTENT_TEXT', text: block.text };
+    }
+    throw new Error(`Cannot infer block type from fields: ${Object.keys(block).join(', ')}`);
+}
+// ── Build input schema ───────────────────────────────────────────────
+const buildInputSchema = z.object({
+    owner: z.string().min(1),
+    repo: z.string().min(1),
+    sha: z.string().min(1),
+    feedTitle: z.string().min(1).max(60),
+    feedDescription: z.string().min(1),
+    forkTitle: z.string().min(1),
+    forkDescription: z.string().min(1),
+    actionUrl: z.string().optional(),
+    existingFeedIds: z.array(z.string()).optional(),
+    images: z.object({
+        bg: z.array(z.string()).length(8),
+        cover: z.array(z.string()).length(8).optional(),
+    }),
+    cards: z.array(z.object({
+        variants: z.array(z.object({
+            blocks: z.array(z.record(z.string(), z.unknown())).min(1),
+        })).min(1),
+    })).length(8),
+});
+// ── Manifest builder ─────────────────────────────────────────────────
+function buildManifest(input) {
+    const forkId = `tfip-${input.owner}-${input.repo}`;
+    const feedId = `tfip-${input.owner}-${input.repo}-${input.sha.slice(0, 7)}`;
+    // Resolve image IDs
+    const bgUrls = input.images.bg.map(resolveImageId);
+    const coverUrls = input.images.cover
+        ? input.images.cover.map(resolveImageId)
+        : bgUrls;
+    const fork = {
+        _id: forkId,
+        title: input.forkTitle,
+        description: input.forkDescription,
+        imageSrc: coverUrls[0],
+        feedIds: [...(input.existingFeedIds || []), feedId],
+        ...(input.actionUrl ? { actionLabel: 'View on GitHub', actionUrl: input.actionUrl } : {}),
+    };
+    const feed = {
+        _id: feedId,
+        title: input.feedTitle,
+        description: input.feedDescription,
+        imageSrc: coverUrls[0],
+        mode: 'sequential',
+        scrollDirection: 'vertical',
+        engagement: true,
+    };
+    const cards = input.cards.map((card, i) => {
+        const coverVariant = {
+            type: 'FULL_IMAGE',
+            imageSrc: coverUrls[i],
+            title: COVERS[i].title,
+            subtitle: COVERS[i].subtitle,
+        };
+        const detailVariants = card.variants.map((v) => ({
+            type: 'CONTENT',
+            backgroundSrc: bgUrls[i],
+            blocks: v.blocks.map((b) => inferBlock(b)),
+        }));
+        return {
+            _id: crypto.randomUUID(),
+            feedId,
+            order: i,
+            variants: [coverVariant, ...detailVariants],
+        };
+    });
+    return { forks: [fork], feeds: [feed], cards };
+}
+async function pushManifestToServer(manifest) {
+    if (!TOKEN) {
+        return {
+            content: [{ type: 'text', text: 'Error: FORKFEED_TOKEN not set. Get your API token from forkfeed.link/admin/user/token and add it to your .mcp.json env.' }],
             isError: true,
         };
     }
-    // Save manifest locally before uploading (best-effort, doesn't block push)
+    // Save manifest locally (best-effort)
     const forkId = manifest.forks?.[0]?._id;
     const filename = `${forkId || `manifest-${Date.now()}`}.json`;
     const dir = join(process.cwd(), 'forkfeed');
@@ -183,43 +394,31 @@ server.tool('forkfeed_push', 'Push a generated manifest (forks, feeds, cards) to
             method: 'POST',
             headers: authHeaders(),
             body: JSON.stringify({ manifest }),
+            signal: AbortSignal.timeout(15_000),
         });
         const data = await res.json();
         if (!res.ok) {
             return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Push failed (${res.status}): ${data.error || JSON.stringify(data)}`,
-                    },
-                ],
+                content: [{ type: 'text', text: `Push failed (${res.status}): ${data.error || JSON.stringify(data)}` }],
                 isError: true,
             };
         }
         const forkSummary = data.forks
             ?.map((f) => `  - ${f.title} (${f.feeds} feeds)`)
             .join('\n');
-        // Generate QR code for the first fork's deep link
         let qrBlock = '';
         if (forkId) {
             const url = `https://forkfeed.link/fork/${forkId}`;
             try {
                 const qr = await QRCode.toString(url, { type: 'utf8', errorCorrectionLevel: 'L' });
-                qrBlock = [
-                    '',
-                    'Scan to open in forkfeed:',
-                    '',
-                    qr,
-                    url,
-                ].join('\n');
+                qrBlock = ['', 'Scan to open in forkfeed:', '', qr, url].join('\n');
             }
             catch {
                 qrBlock = `\nLink: ${url}`;
             }
         }
         return {
-            content: [
-                {
+            content: [{
                     type: 'text',
                     text: [
                         'Content pushed successfully!',
@@ -235,21 +434,216 @@ server.tool('forkfeed_push', 'Push a generated manifest (forks, feeds, cards) to
                         'To make it public, change visibility in the app (requires admin approval).',
                         qrBlock,
                     ].join('\n'),
-                },
-            ],
+                }],
         };
     }
     catch (err) {
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Push failed: ${err instanceof Error ? err.message : String(err)}`,
-                },
-            ],
+            content: [{ type: 'text', text: `Push failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+}
+// ── MCP Server ─────────────────────────────────────────────────────────
+const server = new McpServer({
+    name: 'forkfeed',
+    version: '1.0.0',
+});
+// ── Tool: forkfeed_guide ───────────────────────────────────────────────
+server.tool('forkfeed_guide', 'Get the complete guide for generating forkfeed content from GitHub commits. Call this first to learn the format before generating content.', {}, async () => ({
+    content: [{ type: 'text', text: GUIDE_CONTENT }],
+}));
+// ── Tool: forkfeed_commits ─────────────────────────────────────────────
+server.tool('forkfeed_commits', 'Read git commits from the current repo. Without sha: lists recent commits with published status. With sha: returns structured commit details + pre-filtered images for content generation.', {
+    sha: z.string().optional().describe('Full or short SHA to analyze in detail. Omit to list recent commits.'),
+    cwd: z.string().optional().describe('Working directory. Defaults to process.cwd().'),
+}, async ({ sha, cwd: inputCwd }) => {
+    const cwd = inputCwd || process.cwd();
+    if (!(await isGitRepo(cwd))) {
+        return { content: [{ type: 'text', text: 'Not in a git repo. Navigate to a git repository first.' }], isError: true };
+    }
+    const repoInfo = await getRepoInfo(cwd);
+    const repoLabel = repoInfo.owner ? `${repoInfo.owner}/${repoInfo.repo}` : `local/${repoInfo.repo}`;
+    // ── List mode ──
+    if (!sha) {
+        let commits;
+        try {
+            commits = await getCommitList(cwd);
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to read git log: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+        if (commits.length === 0) {
+            return { content: [{ type: 'text', text: 'No commits found in this repository.' }] };
+        }
+        // Fetch published status (best-effort)
+        let publishedShas = new Set();
+        let existingFeedIds = [];
+        let statusWarning = '';
+        if (TOKEN) {
+            try {
+                const status = await fetchStatusData();
+                existingFeedIds = (status.feeds || []).map((f) => f.externalFeedId);
+                for (const feedId of existingFeedIds) {
+                    const parts = feedId.split('-');
+                    const feedSha = parts[parts.length - 1];
+                    if (feedSha)
+                        publishedShas.add(feedSha);
+                }
+            }
+            catch {
+                statusWarning = '\nNote: could not check published status (network error or token issue).';
+            }
+        }
+        const lines = [
+            `Repo: ${repoLabel}`,
+            '',
+            '| # | SHA | Message | Author | Date | Published |',
+            '|---|-----|---------|--------|------|-----------|',
+        ];
+        for (let i = 0; i < commits.length; i++) {
+            const c = commits[i];
+            const pub = publishedShas.has(c.shortSha) ? 'yes' : '';
+            lines.push(`| ${i + 1} | ${c.shortSha} | ${c.message.slice(0, 60)} | ${c.author} | ${c.date} | ${pub} |`);
+        }
+        if (existingFeedIds.length > 0) {
+            lines.push('', `Existing feed IDs (include ALL in fork.feedIds): ${existingFeedIds.join(', ')}`);
+        }
+        if (statusWarning)
+            lines.push(statusWarning);
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+    // ── Detail mode ──
+    let detail;
+    try {
+        detail = await getCommitDetail(cwd, sha);
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Failed to read commit ${sha}: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+    // Extract file paths from stats for tag detection
+    const filePathMatches = detail.stats.match(/^\s*(.+?)\s+\|/gm) || [];
+    const filePaths = filePathMatches.map((m) => m.trim().replace(/\s+\|$/, ''));
+    const tags = detectTags(detail.message, filePaths);
+    const images = filterImagesByTags(tags);
+    const lines = [
+        `## Commit: ${detail.shortSha} - ${detail.message}`,
+        `Author: ${detail.author} | Date: ${detail.date}`,
+        `Repo: ${repoLabel}`,
+        repoInfo.owner ? `GitHub: https://github.com/${repoInfo.owner}/${repoInfo.repo}` : '',
+        '',
+        '## File Stats',
+        detail.stats,
+        '',
+        '## Diff',
+        detail.diff,
+        '',
+        `## Suggested Images (tags: ${tags.join(', ')})`,
+        '',
+        'Scene images (for covers + inline):',
+        ...images.scenes,
+        '',
+        'Background images (for card backgrounds):',
+        ...images.backgrounds,
+    ].filter(Boolean);
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+});
+// ── Tool: forkfeed_images ──────────────────────────────────────────────
+server.tool('forkfeed_images', 'Get the IT Scenes image catalog (200 scene images + 30 backgrounds). Use this to pick images that match your content by tags and name. Call after forkfeed_guide.', {}, async () => {
+    const scenes = IMAGE_CATALOG.filter((i) => i.id.startsWith('img'));
+    const bgs = IMAGE_CATALOG.filter((i) => i.id.startsWith('bg'));
+    const lines = [
+        '# IT Scenes Image Catalog',
+        '',
+        `Base URL: ${IMAGE_BASE_URL}`,
+        'Prepend base URL to all filenames below to get the full image URL.',
+        '',
+        'Match images to content by tags and name. Use img* for covers and inline images, bg* for card backgrounds.',
+        '',
+        'Tags: deploy, git, disaster, debug, hype, victory, beginner, language, lifestyle, workplace, sarcastic, general',
+        '',
+        '## Scene Images (covers + inline)',
+        '',
+        ...scenes.map((i) => `${i.id} | ${i.name} | ${i.tags} | ${i.file}`),
+        '',
+        '## Background Images',
+        '',
+        ...bgs.map((i) => `${i.id} | ${i.name} | ${i.tags} | ${i.file}`),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+});
+// ── Tool: forkfeed_push ────────────────────────────────────────────────
+server.tool('forkfeed_push', 'Push a generated manifest (forks, feeds, cards) to forkfeed. The manifest JSON must conform to the structure described in forkfeed_guide.', {
+    manifest: z
+        .object({
+        forks: z.array(z.any()),
+        feeds: z.array(z.any()),
+        cards: z.array(z.any()),
+    })
+        .describe('The complete manifest with forks, feeds, and cards arrays'),
+}, async ({ manifest }) => {
+    // Validate manifest structure before pushing
+    const parsed = manifestSchema.safeParse(manifest);
+    if (!parsed.success) {
+        const issues = parsed.error.issues
+            .map((i) => `  ${i.path.join('.')}: ${i.message}`)
+            .join('\n');
+        return {
+            content: [{ type: 'text', text: `Manifest validation failed:\n${issues}\n\nFix the issues above and try again.` }],
+            isError: true,
+        };
+    }
+    const crossErr = crossValidate(parsed.data);
+    if (crossErr) {
+        return {
+            content: [{ type: 'text', text: `Manifest cross-reference errors:\n${crossErr}\n\nFix the issues above and try again.` }],
+            isError: true,
+        };
+    }
+    return pushManifestToServer(parsed.data);
+});
+// ── Tool: forkfeed_build ──────────────────────────────────────────────
+server.tool('forkfeed_build', 'Build a forkfeed manifest from simplified content and push it. Generates UUIDs, resolves image IDs to URLs, adds cover variants automatically. Use this instead of forkfeed_push for faster content creation.', {
+    content: buildInputSchema.describe('Simplified content: repo info, image IDs, and creative card content only'),
+    push: z.boolean().optional().describe('Push immediately after building (default: true)'),
+}, async ({ content, push }) => {
+    const shouldPush = push !== false;
+    // Build the full manifest from simplified input
+    let manifest;
+    try {
+        manifest = buildManifest(content);
+    }
+    catch (err) {
+        return {
+            content: [{ type: 'text', text: `Build failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+    // Validate the assembled manifest
+    const parsed = manifestSchema.safeParse(manifest);
+    if (!parsed.success) {
+        const issues = parsed.error.issues
+            .map((i) => `  ${i.path.join('.')}: ${i.message}`)
+            .join('\n');
+        return {
+            content: [{ type: 'text', text: `Built manifest failed validation:\n${issues}` }],
             isError: true,
         };
     }
+    const crossErr = crossValidate(parsed.data);
+    if (crossErr) {
+        return {
+            content: [{ type: 'text', text: `Built manifest cross-reference errors:\n${crossErr}` }],
+            isError: true,
+        };
+    }
+    if (shouldPush) {
+        return pushManifestToServer(parsed.data);
+    }
+    // Return the manifest for review
+    return {
+        content: [{ type: 'text', text: `Manifest built successfully (${manifest.cards.length} cards). Review below, then call forkfeed_push to publish.\n\n${JSON.stringify(manifest, null, 2)}` }],
+    };
 });
 // ── Tool: forkfeed_status ──────────────────────────────────────────────
 server.tool('forkfeed_status', 'Check your current forkfeed content: which forks and feeds you have published.', {}, async () => {
@@ -265,21 +659,7 @@ server.tool('forkfeed_status', 'Check your current forkfeed content: which forks
         };
     }
     try {
-        const res = await fetch(`${APP_SERVER_URL}/api/content/status`, {
-            headers: authHeaders(),
-        });
-        const data = await res.json();
-        if (!res.ok) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Status check failed (${res.status}): ${data.error || JSON.stringify(data)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        const data = await fetchStatusData();
         if (!data.forks?.length) {
             return {
                 content: [
@@ -327,26 +707,13 @@ server.prompt('forkfeed', 'Turn GitHub commits into swipeable forkfeed content.
                 type: 'text',
                 text: `Turn the commits in this repo into forkfeed content. Follow these steps exactly:
 
-1. Call **forkfeed_guide** and **forkfeed_images** in parallel to load the content guide and image catalog.
-2. Call **forkfeed_status** to check for existing content.
-3. Detect the repo from the working directory. Show recent commits in a table with a column indicating whether each already has a published feed (match 7-char SHA from status feed IDs). Ask which ONE commit to process (default: latest). One commit at a time, never more. Do NOT ask about image style.
-4. Fetch the commit diff and stats via git.
-5. Plan the manifest skeleton (output this before generating cards):
-   - Fork: ID, title, description, imageSrc
-   - Feed: ID, title, description, imageSrc, mode: "sequential", scrollDirection: "vertical", engagement: true
-   - Assign 8 unique cover images (img*) and 8 unique backgrounds (bg*) to cards 0-7
-   - Pre-generate 8 card UUIDs
-   - Split remaining scene images into 8 non-overlapping pools for inline CONTENT_IMAGE use
-   - Include ALL existing feed IDs in the fork's feedIds array (see "Incremental updates" in guide)
-6. Generate all 8 cards IN PARALLEL using the Agent tool. Launch ALL 8 agents in a SINGLE message.
-   Each agent prompt must include: the card number, section type and rules (from the guide), the full commit diff, assigned cover/background/inline images, the card UUID, and the feed ID.
-   Each agent must return ONLY the raw card JSON object: { "_id": "...", "feedId": "...", "order": N, "variants": [...] }
-   Tell each agent: "Do NOT use any tools, scripts, or commands. Just output the JSON directly as text."
-   See "Parallel card generation" in the guide for details.
-7. Assemble the full manifest from the skeleton + 8 card JSON results. Validate against the checklist.
-8. Call **forkfeed_push** with the complete manifest.
+1. Call **forkfeed_guide** and **forkfeed_commits()** in parallel (no arguments for commits = list mode).
+2. Show the commits table from forkfeed_commits. It already indicates which commits have published feeds and lists existing feed IDs. Ask which ONE commit to process. One commit at a time, never more. Do NOT ask about image style.
+3. Call **forkfeed_commits** with the selected commit SHA. This returns the diff, file stats, and pre-filtered images. Do NOT call forkfeed_images separately, do NOT run git commands yourself.
+4. Generate the simplified content JSON as documented in the guide. Use short image IDs (img47, bg10), not full URLs. Do NOT generate UUIDs, cover variants, type wrappers, or fork/feed boilerplate. The builder handles all of that. Include ALL existing feed IDs (listed in step 1 output) in existingFeedIds.
+5. Call **forkfeed_build** with the simplified content (push defaults to true).
 
-Start now. Load the guide and images in parallel, then detect the repo.`,
+Start now.`,
             },
         },
     ],