project-logbook 0.3.0

package/dist/commands/new.js

@@ -0,0 +1,135 @@
+import fs from 'fs-extra';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createInterface } from 'node:readline';
+import chalk from 'chalk';
+import { getConfig } from '../lib/config.js';
+import { getTemplatesDir } from '../lib/migrations.js';
+import { parseTicketId, getNextId } from '../utils/id.js';
+import { sanitiseSlug } from '../utils/slug.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+const question = (prompt) => {
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+};
+export async function createNewEntry(id, slug) {
+    const config = getConfig();
+    const logbookDir = join(process.cwd(), config.logbookDir);
+    if (!(await fs.pathExists(logbookDir))) {
+        await fs.mkdirp(logbookDir);
+    }
+    let entryId = id;
+    let entrySlug = slug;
+    // Interactive mode if no parameters provided
+    if (!entryId || !entrySlug) {
+        console.log(chalk.blue('\n📝 Creating a new logbook entry (interactive mode)\n'));
+        // Determine if we have a jiraPrefix configured
+        const hasJiraPrefix = !!config.jiraPrefix;
+        if (!entryId) {
+            if (hasJiraPrefix) {
+                // Auto-generate ID based on jiraPrefix
+                const nextId = getNextId(logbookDir, config.jiraPrefix);
+                const input = await question(chalk.cyan(`Enter entry ID (e.g. ${nextId}, press Enter for auto-generated): `));
+                if (input) {
+                    const parsed = parseTicketId(input);
+                    const bareNumber = /^\d+$/.test(input) ? parseInt(input, 10) : null;
+                    if (parsed && parsed.prefix.toUpperCase() !== config.jiraPrefix?.toUpperCase()) {
+                        console.warn(chalk.yellow(`Warning: Prefix '${parsed.prefix}' doesn't match configured '${config.jiraPrefix}'. Using configured prefix.`));
+                        entryId = `${config.jiraPrefix}-${parsed.number}`;
+                    }
+                    else if (parsed) {
+                        entryId = input.toUpperCase();
+                    }
+                    else if (bareNumber !== null) {
+                        entryId = `${config.jiraPrefix}-${bareNumber}`;
+                    }
+                    else {
+                        console.warn(chalk.yellow('Invalid ID format. Using auto-generated ID.'));
+                        entryId = nextId;
+                    }
+                }
+                else {
+                    entryId = nextId;
+                }
+            }
+            else {
+                const nextId = getNextId(logbookDir, 'LB');
+                const input = await question(chalk.cyan(`Enter entry ID (e.g. ${nextId}, press Enter for auto-generated): `));
+                if (input) {
+                    const parsed = parseTicketId(input);
+                    const bareNumber = /^\d+$/.test(input) ? parseInt(input, 10) : null;
+                    if (parsed) {
+                        entryId = input.toUpperCase();
+                    }
+                    else if (bareNumber !== null) {
+                        entryId = `LB-${bareNumber}`;
+                    }
+                    else {
+                        console.warn(chalk.yellow('Invalid ID format. Using auto-generated ID.'));
+                        entryId = nextId;
+                    }
+                }
+                else {
+                    entryId = nextId;
+                }
+            }
+        }
+        if (!entrySlug) {
+            const input = await question(chalk.cyan('Enter a short title (will be converted to slug): '));
+            if (!input) {
+                console.error(chalk.red('Error: Title is required.'));
+                process.exit(1);
+            }
+            entrySlug = sanitiseSlug(input);
+        }
+        rl.close();
+    }
+    else {
+        rl.close();
+    }
+    // Sanitise slug
+    const sanitised = sanitiseSlug(entrySlug);
+    if (sanitised !== entrySlug) {
+        console.log(chalk.yellow(`Notice: Slug normalised from '${entrySlug}' to '${sanitised}'.`));
+        entrySlug = sanitised;
+    }
+    const entryDir = join(process.cwd(), config.logbookDir, `${entryId}-${entrySlug}`);
+    if (await fs.pathExists(entryDir)) {
+        console.error(chalk.red(`Error: Entry ${entryId}-${entrySlug} already exists.`));
+        process.exit(1);
+    }
+    await fs.mkdirp(entryDir);
+    const pkg = JSON.parse(await fs.readFile(join(__dirname, '../../package.json'), 'utf8'));
+    const version = pkg.version;
+    const now = new Date();
+    const replacements = {
+        id: entryId,
+        slug: entrySlug,
+        title: entrySlug.replace(/-/g, ' '),
+        date: now.toISOString().split('T')[0],
+        time: now.toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit', second: '2-digit' }),
+        fullIso: now.toISOString(),
+        version: `v${version}`,
+    };
+    const templatesDir = getTemplatesDir();
+    const getTemplate = (name) => {
+        const p = join(templatesDir, name);
+        if (fs.existsSync(p))
+            return fs.readFileSync(p, 'utf8');
+        throw new Error(`Template ${name} not found.`);
+    };
+    const fillTemplate = (template) => {
+        return template.replace(/{{(\w+)}}/g, (_, key) => replacements[key] || `{{${key}}}`);
+    };
+    await fs.writeFile(join(entryDir, 'index.md'), fillTemplate(getTemplate('index.md')));
+    await fs.writeFile(join(entryDir, 'ticket.md'), fillTemplate(getTemplate('ticket.md')));
+    await fs.writeFile(join(entryDir, 'log.md'), fillTemplate(getTemplate('log.md')));
+    console.log(chalk.green(`\nSuccessfully created logbook entry in ${config.logbookDir}/${entryId}-${entrySlug}/`));
+}

package/dist/commands/preview.d.ts

@@ -0,0 +1 @@
+export declare function preview(): Promise<void>;

package/dist/commands/preview.js

@@ -0,0 +1,19 @@
+import { exec } from 'node:child_process';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { getConfig } from '../lib/config.js';
+import { build } from './build.js';
+export async function preview() {
+    const config = getConfig();
+    const outputDir = join(process.cwd(), config.outputDir);
+    const indexPath = join(outputDir, 'index.html');
+    console.log(chalk.blue('Building logbook before preview...'));
+    await build();
+    console.log(chalk.blue(`Opening preview: ${indexPath}`));
+    const start = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${start} "${indexPath}"`, (err) => {
+        if (err) {
+            console.error(chalk.red(`Failed to open preview: ${err.message}`));
+        }
+    });
+}

package/dist/commands/release.d.ts

@@ -0,0 +1,3 @@
+export declare function release(options?: {
+    id?: string;
+}): Promise<void>;

package/dist/commands/release.js

@@ -0,0 +1,66 @@
+import fs from 'fs-extra';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import matter from 'gray-matter';
+import { getConfig } from '../lib/config.js';
+import { getActiveEntry } from '../lib/session.js';
+import { LOCKFILE_NAME } from '../lib/lockfile.js';
+export async function release(options = {}) {
+    const cwd = process.cwd();
+    const lockfilePath = join(cwd, LOCKFILE_NAME);
+    const active = await getActiveEntry(options, cwd);
+    if (!active) {
+        console.log(chalk.yellow('No active entry resolved. Nothing to release.'));
+        return;
+    }
+    const releasedAt = new Date().toISOString();
+    // Inject dateEnd into index.md frontmatter
+    const config = getConfig();
+    const entryDir = join(cwd, config.logbookDir, active.slug);
+    const indexPath = join(entryDir, 'index.md');
+    if (await fs.pathExists(indexPath)) {
+        let raw = await fs.readFile(indexPath, 'utf8');
+        // Always update dateEnd (replace placeholder OR existing value)
+        const hasPlaceholder = raw.includes('dateEnd: [DATE_END]');
+        const dateEndRegex = /dateEnd:.*$/m;
+        if (hasPlaceholder || dateEndRegex.test(raw)) {
+            raw = raw.replace(dateEndRegex, `dateEnd: ${releasedAt}`);
+        }
+        // Parse frontmatter and re-stringify to strip YAML comments
+        const parsed = matter(raw);
+        const cleanedFrontmatter = matter.stringify(parsed.content, parsed.data);
+        await fs.writeFile(indexPath, cleanedFrontmatter);
+    }
+    // Remove lockfile if it exists and matches the released entry slug (or is general)
+    if (await fs.pathExists(lockfilePath)) {
+        try {
+            const lock = await fs.readJson(lockfilePath);
+            if (lock.slug === active.slug) {
+                await fs.remove(lockfilePath);
+            }
+        }
+        catch {
+            // corrupt lockfile, remove it anyway
+            await fs.remove(lockfilePath);
+        }
+    }
+    console.log(chalk.green(`Released entry: ${active.slug} (via ${active.source})`));
+    if (active.startedAt) {
+        const elapsed = formatElapsed(new Date(active.startedAt), new Date(releasedAt));
+        console.log(chalk.gray(`Active for ${elapsed}. You may now commit and build.`));
+    }
+    else {
+        console.log(chalk.gray(`Released at ${releasedAt}. You may now commit and build.`));
+    }
+}
+function formatElapsed(from, to) {
+    const totalSeconds = Math.floor((to.getTime() - from.getTime()) / 1000);
+    const h = Math.floor(totalSeconds / 3600);
+    const m = Math.floor((totalSeconds % 3600) / 60);
+    const s = totalSeconds % 60;
+    if (h > 0)
+        return `${h}h ${m}m`;
+    if (m > 0)
+        return `${m}m ${s}s`;
+    return `${s}s`;
+}

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function start(id: string): Promise<void>;

package/dist/commands/start.js

@@ -0,0 +1,87 @@
+import fs from 'fs-extra';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import matter from 'gray-matter';
+import { getConfig } from '../lib/config.js';
+import { getActiveEntry } from '../lib/session.js';
+import { LOCKFILE_NAME } from '../lib/lockfile.js';
+function getGitUsername() {
+    try {
+        return (execSync('git config user.name', { stdio: ['ignore', 'pipe', 'ignore'] })
+            .toString()
+            .trim() || undefined);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function start(id) {
+    const cwd = process.cwd();
+    const lockfilePath = join(cwd, LOCKFILE_NAME);
+    // 1. Enforce single active entry
+    if (await fs.pathExists(lockfilePath)) {
+        const existing = await fs.readJson(lockfilePath);
+        console.error(chalk.red(`Error: Entry '${existing.slug}' is already active.`));
+        console.error(chalk.red(`Run 'logbook release' before starting a new entry.`));
+        process.exit(1);
+    }
+    // 2. Resolve folder by ID prefix (e.g. "LB-5" → "LB-5-jira-support")
+    const config = getConfig();
+    // If a bare number is given (e.g. "19"), auto-prepend the configured jiraPrefix
+    const resolvedId = /^\d+$/.test(id) && config.jiraPrefix ? `${config.jiraPrefix}-${id}` : id;
+    const logbookDir = join(cwd, config.logbookDir);
+    const allDirs = await fs.readdir(logbookDir);
+    const matchingDir = allDirs.find((d) => {
+        const prefix = d.split('-').slice(0, resolvedId.split('-').length).join('-');
+        return prefix.toLowerCase() === resolvedId.toLowerCase();
+    });
+    if (!matchingDir) {
+        console.error(chalk.red(`Error: No entry found matching ID '${resolvedId}' in ${config.logbookDir}/.`));
+        console.error(chalk.red(`Run 'logbook new <id> <slug>' to create it first.`));
+        process.exit(1);
+    }
+    const slug = matchingDir;
+    const entryDir = join(logbookDir, slug);
+    // Warn if branch-resolved entry is different
+    const activeFromBranch = await getActiveEntry({}, cwd);
+    if (activeFromBranch && activeFromBranch.source === 'branch' && activeFromBranch.slug !== slug) {
+        console.warn(chalk.yellow(`Warning: Your current Git branch resolves to active entry '${activeFromBranch.slug}', but you are manually starting '${slug}'.`));
+    }
+    // 3. Detect git prompter
+    const prompter = getGitUsername();
+    // 4. Write lockfile — store the resolved folder name
+    const lockData = {
+        slug,
+        startedAt: new Date().toISOString(),
+        ...(prompter ? { prompter } : {}),
+    };
+    await fs.writeJson(lockfilePath, lockData, { spaces: 2 });
+    // 5. Inject `dateStart` and `prompter` into index.md frontmatter
+    // We do a raw string injection rather than matter.stringify() to avoid
+    // YAML re-serialization corrupting bracket placeholders like [YOUR_NAME].
+    const indexPath = join(entryDir, 'index.md');
+    if (await fs.pathExists(indexPath)) {
+        let raw = await fs.readFile(indexPath, 'utf8');
+        const parsed = matter(raw);
+        // Inject dateStart only if the placeholder exists (preserve existing dateStart on re-start)
+        // Note: gray-matter parses [DATE_START] as a YAML array, so we check the raw string directly.
+        if (raw.includes('dateStart: [DATE_START]')) {
+            raw = raw.replace('dateStart: [DATE_START]', `dateStart: ${lockData.startedAt}`);
+        }
+        // Inject prompter if available and not already set
+        if (prompter && !parsed.data.prompter) {
+            raw = raw.replace(/^(---\n[\s\S]*?)(^---$)/m, (_, frontmatter, closing) => {
+                if (frontmatter.includes('prompter:'))
+                    return _;
+                return `${frontmatter}prompter: '${prompter.replace(/'/g, "''")}'\n${closing}`;
+            });
+        }
+        await fs.writeFile(indexPath, raw);
+    }
+    console.log(chalk.green(`Started entry: ${slug}`));
+    if (prompter) {
+        console.log(chalk.blue(`Prompter set to: ${prompter}`));
+    }
+    console.log(chalk.gray(`Lockfile written to ${LOCKFILE_NAME}. Run 'logbook release' when done.`));
+}

package/dist/commands/steer.d.ts

@@ -0,0 +1 @@
+export declare function steer(): Promise<void>;

package/dist/commands/steer.js

@@ -0,0 +1,22 @@
+import fs from 'fs-extra';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { getTemplatesDir } from '../lib/migrations.js';
+export async function steer() {
+    const steerPath = join(getTemplatesDir(), 'steer.txt');
+    if (!fs.existsSync(steerPath)) {
+        console.error(chalk.red('Error: Steering template not found.'));
+        return;
+    }
+    const protocol = fs.readFileSync(steerPath, 'utf8');
+    // Add some color to headers and mandatory parts
+    const formatted = protocol
+        .replace(/^PROJECT LOGBOOK:.+$/m, (m) => chalk.bold.cyan(m))
+        .replace(/^Phase \d:.+$/gm, (m) => chalk.bold(m))
+        .replace(/logbook \w+/g, (m) => chalk.green(m))
+        .replace(/\w+\.md/g, (m) => chalk.blue(m))
+        .replace(/Mandatory:/g, chalk.yellow('Mandatory:'))
+        .replace(/Storytelling Mode:/g, chalk.yellow('Storytelling Mode:'))
+        .replace(/Quality Gate:/g, chalk.red('Quality Gate:'));
+    console.log(formatted);
+}

package/dist/commands/upgrade.d.ts

@@ -0,0 +1 @@
+export declare function upgrade(): Promise<void>;

package/dist/commands/upgrade.js

@@ -0,0 +1,23 @@
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { getProjectStatus } from '../lib/migrations.js';
+export async function upgrade() {
+    const projectStatus = await getProjectStatus();
+    let updatedCount = 0;
+    for (const file of projectStatus) {
+        if (file.status === 'UP_TO_DATE') {
+            console.log(chalk.blue(`[UP TO DATE] ${file.name}`));
+        }
+        else {
+            await fs.writeFile(file.localPath, file.templateContent);
+            console.log(chalk.green(`[${file.status === 'MISSING' ? 'CREATED' : 'UPDATED'}] ${file.name}`));
+            updatedCount++;
+        }
+    }
+    if (updatedCount === 0) {
+        console.log(chalk.blue('\nEverything is already up to date.'));
+    }
+    else {
+        console.log(chalk.green(`\nSuccessfully upgraded ${updatedCount} files.`));
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkgPath = join(__dirname, '..', 'package.json');
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+const program = new Command();
+program.name('logbook').description('A CLI tool for managing project logbooks.').version(pkg.version);
+program
+    .command('init')
+    .description('Initialize .project-logbook config and /logbook folder')
+    .action(async () => {
+    const { init } = await import('./commands/init.js');
+    await init();
+});
+program
+    .command('new [id] [slug]')
+    .description('Create a new logbook entry (with optional id and slug, or use interactive mode)')
+    .action(async (id, slug) => {
+    const { createNewEntry } = await import('./commands/new.js');
+    await createNewEntry(id, slug);
+});
+program
+    .command('lint')
+    .description('Verify the 3-file structure and frontmatter')
+    .action(async () => {
+    const { lint } = await import('./commands/lint.js');
+    await lint();
+});
+program
+    .command('build')
+    .description('Compile the logbook into a static website')
+    .action(async () => {
+    const { build } = await import('./commands/build.js');
+    await build();
+});
+program
+    .command('preview')
+    .description('Build and open the logbook in the browser')
+    .action(async () => {
+    const { preview } = await import('./commands/preview.js');
+    await preview();
+});
+program
+    .command('upgrade')
+    .description('Upgrade project files (like CONTRIBUTING.md) to the latest templates')
+    .action(async () => {
+    const { upgrade } = await import('./commands/upgrade.js');
+    await upgrade();
+});
+program
+    .command('start <id>')
+    .description('Mark a logbook entry as active by ID, e.g. LB-5 (writes .logbook-active lockfile)')
+    .action(async (id) => {
+    const { start } = await import('./commands/start.js');
+    await start(id);
+});
+program
+    .command('release')
+    .description('Release the active logbook entry (removes .logbook-active lockfile)')
+    .option('-i, --id <id>', 'Target logbook entry ID to release')
+    .action(async (options) => {
+    const { release } = await import('./commands/release.js');
+    await release(options);
+});
+program
+    .command('list')
+    .description('List all logbook entries with their status')
+    .option('-a, --all', 'Show all entries (default is latest 20)')
+    .action(async (options) => {
+    const { list } = await import('./commands/list.js');
+    await list(options);
+});
+program
+    .command('log <message...>')
+    .description('Append a timestamped log entry to the active log.md (e.g. logbook log "Did a thing")')
+    .option('-i, --id <id>', 'Override active logbook entry ID')
+    .action(async (messages, options) => {
+    const { log } = await import('./commands/log.js');
+    await log(messages, options);
+});
+program
+    .command('steer')
+    .description('Output the Agentic Protocol for AI agents')
+    .action(async () => {
+    const { steer } = await import('./commands/steer.js');
+    await steer();
+});
+program.parse();

package/dist/lib/about-content.d.ts

@@ -0,0 +1 @@
+export declare function getAboutContent(): string;

package/dist/lib/about-content.js

@@ -0,0 +1,7 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function getAboutContent() {
+    return readFileSync(join(__dirname, '../templates/ABOUT.md'), 'utf8');
+}

package/dist/lib/build-helpers.d.ts

@@ -0,0 +1,15 @@
+import type { LogbookConfig } from './config.js';
+import type { TimelineEntry } from './template-types.js';
+export declare function mdToHtml(md: string): Promise<string>;
+export declare function buildProjectMdFiles(projectRoot: string, outputDir: string, excludeDirs: string[], ctx: {
+    config: LogbookConfig;
+    version: string;
+    buildTime: string;
+}): Promise<void>;
+export declare function renderPost(data: TimelineEntry, i: number, allEntries: TimelineEntry[], ctx: {
+    logbookDir: string;
+    outputDir: string;
+    config: LogbookConfig;
+    version: string;
+    buildTime: string;
+}): Promise<void>;

package/dist/lib/build-helpers.js

@@ -0,0 +1,171 @@
+import fs from 'fs-extra';
+import { join } from 'node:path';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkRehype from 'remark-rehype';
+import rehypeSlug from 'rehype-slug';
+import rehypeFormat from 'rehype-format';
+import rehypeStringify from 'rehype-stringify';
+import matter from 'gray-matter';
+import { layout, postTemplate } from './templates.js';
+import { getGitCommits } from './git-helpers.js';
+import { mdToHtmlWithImages, extractImagePathsFromMarkdown, copyImages } from './image-helpers.js';
+/** Rehype plugin: rewrite relative .md links to /index.html equivalents. */
+const rehypeRewriteMdLinks = () => {
+    return (tree) => {
+        visitLinks(tree, (node) => {
+            const href = node.properties?.href;
+            if (typeof href !== 'string')
+                return;
+            if (/^[a-z][a-z\d+\-.]*:/i.test(href) || href.startsWith('#'))
+                return;
+            const mdMatch = href.match(/^(.*?)\.md(#.*)?$/i);
+            if (!mdMatch)
+                return;
+            const base = mdMatch[1];
+            const fragment = mdMatch[2] ?? '';
+            node.properties.href = `${base}/index.html${fragment}`;
+        });
+    };
+};
+function visitLinks(node, visitor) {
+    for (const child of node.children) {
+        if (child.type === 'element') {
+            if (child.tagName === 'a')
+                visitor(child);
+            visitLinks(child, visitor);
+        }
+    }
+}
+const processor = unified()
+    .use(remarkParse)
+    .use(remarkRehype)
+    .use(rehypeSlug)
+    .use(rehypeRewriteMdLinks)
+    .use(rehypeFormat)
+    .use(rehypeStringify);
+export async function mdToHtml(md) {
+    const result = await processor.process(md);
+    return result.toString();
+}
+export async function buildProjectMdFiles(projectRoot, outputDir, excludeDirs, ctx) {
+    const entries = await fs.readdir(projectRoot, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.md'))
+            continue;
+        if (excludeDirs.includes(entry.name))
+            continue;
+        const sourcePath = join(projectRoot, entry.name);
+        const stem = entry.name.replace(/\.md$/i, '');
+        const outDir = join(outputDir, stem);
+        const mdContent = await fs.readFile(sourcePath, 'utf8');
+        const bodyHtml = await mdToHtml(mdContent);
+        const buildMeta = `Generated by ${ctx.config.projectName} v${ctx.version} • ${ctx.buildTime}`;
+        const pageHtml = layout({
+            title: stem,
+            projectName: ctx.config.projectName,
+            basePath: '../',
+            buildMeta,
+            header: `<header><h1>${stem}</h1></header>`,
+            content: bodyHtml,
+        });
+        await fs.mkdirp(outDir);
+        await fs.writeFile(join(outDir, 'index.html'), pageHtml);
+    }
+}
+async function renderLinkedMdFiles(markdownSources, entryPath, entryOutputDir, ctx) {
+    const linkRegex = /\[.*?\]\(([^)]+\.md(?:#[^)]*)?)?\)/gi;
+    const seen = new Set();
+    for (const source of markdownSources) {
+        let match;
+        linkRegex.lastIndex = 0;
+        while ((match = linkRegex.exec(source)) !== null) {
+            const raw = match[1];
+            if (!raw)
+                continue;
+            const href = raw.split('#')[0];
+            if (!href)
+                continue;
+            if (/^[a-z][a-z\d+\-.]*:/i.test(href))
+                continue;
+            if (seen.has(href))
+                continue;
+            seen.add(href);
+            let sourcePath = join(entryPath, href);
+            if (!(await fs.pathExists(sourcePath)))
+                sourcePath = join(process.cwd(), href);
+            if (!(await fs.pathExists(sourcePath))) {
+                console.warn(`  Linked file not found, skipping: ${href}`);
+                continue;
+            }
+            const mdContent = await fs.readFile(sourcePath, 'utf8');
+            const bodyHtml = await mdToHtml(mdContent);
+            const title = href.replace(/\.md$/i, '');
+            const buildMeta = `Generated by ${ctx.config.projectName} v${ctx.version} • ${ctx.buildTime}`;
+            const pageHtml = layout({
+                title,
+                projectName: ctx.config.projectName,
+                basePath: '../',
+                buildMeta,
+                header: `<header><h1>${title}</h1></header>`,
+                content: bodyHtml,
+            });
+            const stem = href.replace(/\.md$/i, '').replace(/^\.\//, '');
+            const outDir = join(entryOutputDir, stem);
+            await fs.mkdirp(outDir);
+            await fs.writeFile(join(outDir, 'index.html'), pageHtml);
+        }
+    }
+}
+export async function renderPost(data, i, allEntries, ctx) {
+    const entryPath = join(ctx.logbookDir, data.slug);
+    const ticketPath = join(entryPath, 'ticket.md');
+    const logPath = join(entryPath, 'log.md');
+    const { content, content: summaryContent } = matter(await fs.readFile(join(entryPath, 'index.md'), 'utf8'));
+    const ticketRaw = (await fs.pathExists(ticketPath)) ? await fs.readFile(ticketPath, 'utf8') : '';
+    const logRaw = (await fs.pathExists(logPath)) ? await fs.readFile(logPath, 'utf8') : '';
+    // Process with image collection for index.md content
+    const { html: storyHtml, imagePaths: storyImages } = await mdToHtmlWithImages(content.replace(/^#\s+.+$/m, '').trim());
+    // Collect images from all markdown sources
+    const ticketImages = extractImagePathsFromMarkdown(ticketRaw);
+    const logImages = extractImagePathsFromMarkdown(logRaw);
+    const allImagePaths = [...storyImages, ...ticketImages, ...logImages];
+    const commits = await getGitCommits(entryPath);
+    const jiraUrl = ctx.config.jiraBaseUrl && data.ticket ? `${ctx.config.jiraBaseUrl}${data.ticket}` : undefined;
+    const prev = i > 0 ? allEntries[i - 1] : null;
+    const next = i < allEntries.length - 1 ? allEntries[i + 1] : null;
+    const postContent = postTemplate({
+        ...data,
+        title: data.title ?? data.slug,
+        harness: data.harness ?? '',
+        content: storyHtml,
+        ticketHtml: ticketRaw ? await mdToHtml(ticketRaw) : '',
+        logHtml: logRaw ? await mdToHtml(logRaw) : '',
+        commits,
+        version: ctx.version,
+        jiraUrl,
+        prevEntry: prev ? { slug: prev.slug, title: prev.title ?? '', ticket: prev.ticket } : null,
+        nextEntry: next ? { slug: next.slug, title: next.title ?? '', ticket: next.ticket } : null,
+    });
+    const descriptionRaw = typeof data.summary === 'string' ? data.summary.replace(/[*#`]/g, '').trim() : '';
+    const buildMeta = `Generated by ${ctx.config.projectName} v${ctx.version} • ${ctx.buildTime}`;
+    const postHtml = layout({
+        title: data.title ?? data.slug,
+        projectName: ctx.config.projectName,
+        basePath: '../',
+        description: descriptionRaw.substring(0, 160),
+        bodySlug: data.slug,
+        buildMeta,
+        header: postContent.split('</header>')[0] + '</header>',
+        content: postContent.split('</header>')[1],
+    });
+    const entryOutputDir = join(ctx.outputDir, data.slug);
+    await fs.mkdirp(entryOutputDir);
+    await fs.writeFile(join(entryOutputDir, 'index.html'), postHtml);
+    // Copy images to output directory
+    if (allImagePaths.length > 0) {
+        const imagesOutputDir = join(entryOutputDir, 'images');
+        await copyImages(entryPath, imagesOutputDir, allImagePaths);
+    }
+    await renderLinkedMdFiles([summaryContent, ticketRaw, logRaw], entryPath, entryOutputDir, ctx);
+}