project-logbook 0.3.3 → 0.3.4

package/dist/commands/start.js

@@ -1,10 +1,11 @@
 import fs from 'fs-extra';
 import { join } from 'node:path';
 import { execSync } from 'node:child_process';
-import chalk from 'chalk';
+import { error as errorStyle, warning as warningStyle, neutral, header, successMessage } from '../lib/theme.js';
 import matter from 'gray-matter';
-import { getConfig } from '../lib/config.js';
+import { getConfig, getLogbookDirPath } from '../lib/config.js';
 import { getActiveEntry } from '../lib/session.js';
+import { getEntryPath } from '../lib/entry-paths.js';
 import { LOCKFILE_NAME } from '../lib/lockfile.js';
 function getGitUsername() {
     try {
@@ -22,31 +23,31 @@ export async function start(id) {
     // 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.`));
+        console.error(errorStyle(`Error: Entry '${existing.slug}' is already active.`));
+        console.error(errorStyle(`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 logbookDir = getLogbookDirPath(config, cwd);
     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.`));
+        console.error(errorStyle(`Error: No entry found matching ID '${resolvedId}' in ${config.logbookDir}/.`));
+        console.error(errorStyle(`Run 'logbook new <id> <slug>' to create it first.`));
         process.exit(1);
     }
     const slug = matchingDir;
-    const entryDir = join(logbookDir, slug);
+    const entryDir = getEntryPath(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}'.`));
+        console.warn(warningStyle(`Warning: Your current Git branch resolves to active entry '${activeFromBranch.slug}', but you are manually starting '${slug}'.`));
     }
     // 3. Detect git prompter
     const prompter = getGitUsername();
@@ -65,23 +66,27 @@ export async function start(id) {
         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}`);
+        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}`;
-            });
+        if (prompter) {
+            if (raw.includes('prompter: "[PROMPTER]"')) {
+                raw = raw.replace('prompter: "[PROMPTER]"', `prompter: '${prompter.replace(/'/g, "''")}'`);
+            }
+            else if (!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}`));
+    console.log(successMessage('Started', `entry: ${slug}`));
     if (prompter) {
-        console.log(chalk.blue(`Prompter set to: ${prompter}`));
+        console.log(header(`Prompter set to: ${prompter}`));
     }
-    console.log(chalk.gray(`Lockfile written to ${LOCKFILE_NAME}. Run 'logbook release' when done.`));
+    console.log(neutral(`Lockfile written to ${LOCKFILE_NAME}. Run 'logbook release' when done.`));
 }

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,122 @@
+import fs from 'fs-extra';
+import { getConfig, getLogbookDirPath } from '../lib/config.js';
+import { getLogbookEntries } from '../utils/fs.js';
+import { getActiveEntry } from '../lib/session.js';
+import { parseTicketId } from '../utils/id.js';
+import { error, neutral, highlight, bold, warning } from '../lib/theme.js';
+import { getChangedLOC } from '../lib/git-helpers.js';
+export async function status() {
+    const config = getConfig();
+    const logbookDir = getLogbookDirPath(config);
+    if (!(await fs.pathExists(logbookDir))) {
+        console.error(error(`Error: Logbook directory '${config.logbookDir}' not found. Run 'logbook init' first.`));
+        process.exit(1);
+    }
+    // Detect currently active entry (if any)
+    const active = await getActiveEntry();
+    const activeSlug = active?.slug;
+    const logbookEntries = await getLogbookEntries(logbookDir);
+    let totalCount = logbookEntries.length;
+    let draftCount = 0;
+    let doneCount = 0;
+    let activeCount = 0;
+    for (const entry of logbookEntries) {
+        const isActive = activeSlug === entry.slug;
+        if (isActive) {
+            activeCount++;
+        }
+        if (!entry.hasIndex) {
+            draftCount++;
+            continue;
+        }
+        const { data, content } = entry;
+        // Check frontmatter field values for bracket-style unfilled placeholders
+        const dataValues = Object.values(data)
+            .filter((v) => typeof v === 'string')
+            .join('\n');
+        const frontmatterHasPlaceholders = dataValues.includes('[DATE_END]') ||
+            dataValues.includes('[DATE_START]') ||
+            dataValues.includes('[WRITE_SUMMARY_HERE]') ||
+            dataValues.includes('[PROMPTER]') ||
+            dataValues.includes('[HARNESS]') ||
+            dataValues.includes('[LLM]');
+        // Check body content for unfilled template hints (strip inline code spans to avoid false positives)
+        const contentWithoutCode = content.replace(/`[^`]*`/g, '');
+        const bodyHasPlaceholders = contentWithoutCode.includes('TODO:') ||
+            content.includes('Write a polished, highly readable "short story" of the change here.');
+        const hasPlaceholders = frontmatterHasPlaceholders || bodyHasPlaceholders;
+        if (hasPlaceholders) {
+            draftCount++;
+        }
+        else if (!isActive) {
+            doneCount++;
+        }
+    }
+    // Find latest entry (sorted descending by ticket id / slug)
+    const sortedEntries = [...logbookEntries].sort((a, b) => {
+        const idA = parseTicketId(a.slug);
+        const idB = parseTicketId(b.slug);
+        if (idA && idB) {
+            if (idA.prefix !== idB.prefix) {
+                return idB.prefix.localeCompare(idA.prefix);
+            }
+            return idB.number - idA.number;
+        }
+        return b.slug.localeCompare(a.slug);
+    });
+    const latestEntry = sortedEntries[0];
+    let latestText = neutral('None');
+    if (latestEntry) {
+        const latestTitle = latestEntry.data?.title || latestEntry.slug.replace(/^[A-Za-z]+-\d+-/, '').replace(/-/g, ' ');
+        latestText = `${highlight(latestEntry.slug)} - ${latestTitle}`;
+    }
+    // Print Active Task section
+    console.log(`\n${bold.underline('Logbook Status')}`);
+    console.log(`\n${bold('Active Task:')}`);
+    if (active) {
+        const activeDetail = logbookEntries.find((e) => e.slug === active.slug);
+        const activeTitle = activeDetail?.data?.title || active.slug.replace(/^[A-Za-z]+-\d+-/, '').replace(/-/g, ' ');
+        console.log(`  ${bold('Slug/ID:')}    ${highlight(active.slug)}`);
+        console.log(`  ${bold('Title:')}      ${activeTitle}`);
+        console.log(`  ${bold('Source:')}     ${warning(active.source)}`);
+        if (active.startedAt) {
+            console.log(`  ${bold('Started:')}    ${active.startedAt}`);
+        }
+        if (active.prompter) {
+            console.log(`  ${bold('Prompter:')}   ${active.prompter}`);
+        }
+    }
+    else {
+        console.log(`  ${neutral('No active task detected.')}`);
+    }
+    // Calculate changed LOC
+    try {
+        const summary = await getChangedLOC(config.logbookDir);
+        const activeLOC = `${summary.total} (+${summary.insertions}, -${summary.deletions})`;
+        console.log(`\n${bold('Changed LOC Count:')}   ${highlight(activeLOC)}\n`);
+    }
+    catch { }
+    // Print Settings section
+    console.log(`\n${bold('Settings (.project-logbook):')}`);
+    console.log(`  ${bold('Project Name:')}      ${config.projectName}`);
+    console.log(`  ${bold('Logbook Directory:')} ${config.logbookDir}`);
+    console.log(`  ${bold('Output Directory:')}  ${config.outputDir}`);
+    console.log(`  ${bold('Primary Color:')}     ${config.primaryColor}`);
+    if (config.jiraBaseUrl) {
+        console.log(`  ${bold('Jira Base URL:')}     ${config.jiraBaseUrl}`);
+    }
+    if (config.jiraPrefix) {
+        console.log(`  ${bold('Jira Prefix:')}       ${config.jiraPrefix}`);
+    }
+    if (config.tags?.allowed) {
+        console.log(`  ${bold('Allowed Tags:')}      ${config.tags.allowed.join(', ')}`);
+    }
+    // Print Stats section
+    console.log(`\n${bold('Stats:')}`);
+    console.log(`  ${bold('Total Entries:')}    ${totalCount}`);
+    console.log(`  ${bold('Active Tasks:')}     ${activeCount}`);
+    console.log(`  ${bold('Completed Done:')}   ${doneCount}`);
+    console.log(`  ${bold('Ticket Drafts:')}    ${draftCount}`);
+    console.log(`  ${bold('Latest Entry:')}     ${latestText}`);
+    console.log('');
+}

package/dist/commands/steer.js

@@ -1,22 +1,22 @@
 import fs from 'fs-extra';
 import { join } from 'node:path';
-import chalk from 'chalk';
+import { warning as warningStyle, header, error as errorStyle, success, errorMessage, bold, highlight, } from '../lib/theme.js';
 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.'));
+        console.error(errorMessage('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:'));
+        .replace(/^PROJECT LOGBOOK:.+$/m, (m) => bold(highlight(m)))
+        .replace(/^Phase \d:.+$/gm, (m) => bold(m))
+        .replace(/logbook \w+/g, (m) => success(m))
+        .replace(/\w+\.md/g, (m) => header(m))
+        .replace(/Mandatory:/g, warningStyle('Mandatory:'))
+        .replace(/Storytelling Mode:/g, warningStyle('Storytelling Mode:'))
+        .replace(/Quality Gate:/g, errorStyle('Quality Gate:'));
     console.log(formatted);
 }

package/dist/commands/upgrade.js

@@ -1,23 +1,23 @@
 import fs from 'fs-extra';
-import chalk from 'chalk';
+import { success, header } from '../lib/theme.js';
 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}`));
+            console.log(header(`[UP TO DATE] ${file.name}`));
         }
         else {
             await fs.writeFile(file.localPath, file.templateContent);
-            console.log(chalk.green(`[${file.status === 'MISSING' ? 'CREATED' : 'UPDATED'}] ${file.name}`));
+            console.log(success(`[${file.status === 'MISSING' ? 'CREATED' : 'UPDATED'}] ${file.name}`));
             updatedCount++;
         }
     }
     if (updatedCount === 0) {
-        console.log(chalk.blue('\nEverything is already up to date.'));
+        console.log(header('\nEverything is already up to date.'));
     }
     else {
-        console.log(chalk.green(`\nSuccessfully upgraded ${updatedCount} files.`));
+        console.log(success(`\nSuccessfully upgraded ${updatedCount} files.`));
     }
 }

package/dist/index.js

@@ -1,14 +1,8 @@
 #!/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'));
+import { getPackageVersion } from './lib/package-version.js';
 const program = new Command();
-program.name('logbook').description('A CLI tool for managing project logbooks.').version(pkg.version);
+program.name('logbook').description('A CLI tool for managing project logbooks.').version(getPackageVersion());
 program
     .command('init')
     .description('Initialize .project-logbook config and /logbook folder')
@@ -74,6 +68,13 @@ program
     const { list } = await import('./commands/list.js');
     await list(options);
 });
+program
+    .command('status')
+    .description('Show current active logbook task, configuration settings, and statistics')
+    .action(async () => {
+    const { status } = await import('./commands/status.js');
+    await status();
+});
 program
     .command('log <message>')
     .description('Append a timestamped log entry to the active log.md (e.g. logbook log "Did a thing")')

package/dist/lib/build-helpers.js

@@ -1,24 +1,22 @@
 import fs from 'fs-extra';
-import { join } from 'node:path';
-import { unified } from 'unified';
-import remarkParse from 'remark-parse';
-import remarkGfm from 'remark-gfm';
-import remarkRehype from 'remark-rehype';
-import rehypeSlug from 'rehype-slug';
-import rehypeFormat from 'rehype-format';
-import rehypeStringify from 'rehype-stringify';
+import { join, resolve } from 'node:path';
 import matter from 'gray-matter';
 import { layout, postTemplate } from './templates.js';
 import { getGitCommits } from './git-helpers.js';
+import { visitHastElements } from './hast-helpers.js';
+import { createGeneralMarkdownProcessor, createEntryMarkdownProcessor } from './markdown-processors.js';
+import { isExternalUrl, isExternalUrlOrAnchor } from './url-helpers.js';
+import { readFileIfExists, pathExistsOrNull } from '../utils/fs.js';
+import { getEntryFilePaths } from './entry-paths.js';
 import { mdToHtmlWithImages, extractImagePathsFromMarkdown, copyImages, rehypeRewriteImagePaths, } from './image-helpers.js';
 /** Rehype plugin: rewrite relative .md links to /index.html equivalents. */
 const rehypeRewriteMdLinks = () => {
     return (tree) => {
-        visitLinks(tree, (node) => {
+        visitHastElements(tree, 'a', (node) => {
             const href = node.properties?.href;
             if (typeof href !== 'string')
                 return;
-            if (/^[a-z][a-z\d+\-.]*:/i.test(href) || href.startsWith('#'))
+            if (isExternalUrlOrAnchor(href))
                 return;
             const mdMatch = href.match(/^(.*?)\.md(#.*)?$/i);
             if (!mdMatch)
@@ -29,33 +27,8 @@ const rehypeRewriteMdLinks = () => {
         });
     };
 };
-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(remarkGfm)
-    .use(remarkRehype)
-    .use(rehypeSlug)
-    .use(rehypeRewriteMdLinks)
-    .use(rehypeFormat)
-    .use(rehypeStringify);
-/** Processor for entry content with image path rewriting */
-const entryProcessor = unified()
-    .use(remarkParse)
-    .use(remarkGfm)
-    .use(remarkRehype)
-    .use(rehypeSlug)
-    .use(rehypeRewriteMdLinks)
-    .use(rehypeRewriteImagePaths)
-    .use(rehypeFormat)
-    .use(rehypeStringify);
+const processor = createGeneralMarkdownProcessor(rehypeRewriteMdLinks);
+const entryProcessor = createEntryMarkdownProcessor(rehypeRewriteMdLinks, rehypeRewriteImagePaths);
 export async function mdToHtml(md) {
     const result = await processor.process(md);
     return result.toString();
@@ -103,18 +76,24 @@ async function renderLinkedMdFiles(markdownSources, entryPath, entryOutputDir, c
             const href = raw.split('#')[0];
             if (!href)
                 continue;
-            if (/^[a-z][a-z\d+\-.]*:/i.test(href))
+            if (isExternalUrl(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))) {
+            sourcePath = (await pathExistsOrNull(sourcePath)) ?? join(process.cwd(), href);
+            if (!sourcePath || !(await pathExistsOrNull(sourcePath))) {
                 console.warn(`  Linked file not found, skipping: ${href}`);
                 continue;
             }
+            // Path traversal protection: ensure resolved path stays within project boundaries
+            const resolvedPath = resolve(sourcePath);
+            const projectRoot = resolve(process.cwd());
+            if (!resolvedPath.startsWith(projectRoot + '/') && resolvedPath !== projectRoot) {
+                console.warn(`  Path traversal blocked: ${href}`);
+                continue;
+            }
             const mdContent = await fs.readFile(sourcePath, 'utf8');
             const bodyHtml = await mdToHtml(mdContent);
             const title = href.replace(/\.md$/i, '');
@@ -135,12 +114,11 @@ async function renderLinkedMdFiles(markdownSources, entryPath, entryOutputDir, c
     }
 }
 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') : '';
+    const entryFilePaths = getEntryFilePaths(ctx.logbookDir, data.slug);
+    const entryPath = entryFilePaths.index.replace(/\/index\.md$/, '');
+    const { content, content: summaryContent } = matter(await fs.readFile(entryFilePaths.index, 'utf8'));
+    const ticketRaw = await readFileIfExists(entryFilePaths.ticket);
+    const logRaw = await readFileIfExists(entryFilePaths.log);
     // 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
@@ -151,7 +129,7 @@ export async function renderPost(data, i, allEntries, ctx) {
     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({
+    const { header: postHeader, content: postMainContent } = postTemplate({
         ...data,
         title: data.title ?? data.slug,
         harness: data.harness ?? '',
@@ -173,8 +151,8 @@ export async function renderPost(data, i, allEntries, ctx) {
         description: descriptionRaw.substring(0, 160),
         bodySlug: data.slug,
         buildMeta,
-        header: postContent.split('</header>')[0] + '</header>',
-        content: postContent.split('</header>')[1],
+        header: postHeader,
+        content: postMainContent,
     });
     const entryOutputDir = join(ctx.outputDir, data.slug);
     await fs.mkdirp(entryOutputDir);

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

@@ -0,0 +1,20 @@
+import type { LogbookConfig } from './config.js';
+/**
+ * Set up the output directory: create it, copy static assets (favicon, styles, script).
+ */
+export declare function setupOutputDirectory(outputDir: string, config: LogbookConfig): Promise<void>;
+/**
+ * Process README.md if it exists and return rendered HTML + image paths.
+ */
+export declare function processReadme(projectRoot: string): Promise<{
+    html: string;
+    imagePaths: string[];
+}>;
+/**
+ * Copy README images to the output directory.
+ */
+export declare function copyReadmeImages(projectRoot: string, outputDir: string, imagePaths: string[]): Promise<void>;
+/**
+ * Process the About content and return rendered HTML.
+ */
+export declare function processAboutContent(aboutContent: string): Promise<string>;

package/dist/lib/build-steps.js

@@ -0,0 +1,57 @@
+/**
+ * Helper functions for the build command.
+ * Breaks down the monolithic build() function into testable, reusable steps.
+ */
+import fs from 'fs-extra';
+import { join } from 'node:path';
+import { warning } from './theme.js';
+import { URL } from 'node:url';
+import { mdToHtmlWithImages, copyImages } from './image-helpers.js';
+import { getStyles } from './styles.js';
+import { getClientScript } from './logbook-client.js';
+import { mdToHtml } from './build-helpers.js';
+/**
+ * Set up the output directory: create it, copy static assets (favicon, styles, script).
+ */
+export async function setupOutputDirectory(outputDir, config) {
+    await fs.remove(outputDir);
+    await fs.mkdirp(outputDir);
+    await fs.copyFile(new URL('../templates/favicon.svg', import.meta.url), join(outputDir, 'favicon.svg'));
+    await fs.writeFile(join(outputDir, 'style.css'), getStyles(config.primaryColor));
+    await fs.writeFile(join(outputDir, 'logbook.js'), getClientScript());
+}
+/**
+ * Process README.md if it exists and return rendered HTML + image paths.
+ */
+export async function processReadme(projectRoot) {
+    const readmePath = join(projectRoot, 'README.md');
+    let readmeHtml = '';
+    let readmeImages = [];
+    try {
+        if (await fs.pathExists(readmePath)) {
+            const readmeContent = await fs.readFile(readmePath, 'utf8');
+            const { html, imagePaths } = await mdToHtmlWithImages(readmeContent);
+            readmeHtml = html;
+            readmeImages = imagePaths;
+        }
+    }
+    catch (error) {
+        console.warn(warning(`Warning: Failed to read README.md: ${error instanceof Error ? error.message : error}`));
+        readmeHtml = '<p>README unavailable.</p>';
+    }
+    return { html: readmeHtml, imagePaths: readmeImages };
+}
+/**
+ * Copy README images to the output directory.
+ */
+export async function copyReadmeImages(projectRoot, outputDir, imagePaths) {
+    if (imagePaths.length > 0) {
+        await copyImages(projectRoot, outputDir, imagePaths);
+    }
+}
+/**
+ * Process the About content and return rendered HTML.
+ */
+export async function processAboutContent(aboutContent) {
+    return await mdToHtml(aboutContent);
+}

package/dist/lib/config.d.ts

@@ -12,3 +12,19 @@ export interface LogbookConfig {
 }
 export declare const DEFAULT_CONFIG: LogbookConfig;
 export declare function getConfig(cwd?: string): LogbookConfig;
+/**
+ * Get the absolute path to the logbook directory.
+ * Convenience function to avoid repeating: join(process.cwd(), config.logbookDir)
+ * @param config - The logbook config
+ * @param cwd - Optional working directory (defaults to process.cwd())
+ * @returns Absolute path to the logbook directory
+ */
+export declare function getLogbookDirPath(config: LogbookConfig, cwd?: string): string;
+/**
+ * Get the absolute path to the output directory.
+ * Convenience function to avoid repeating: join(process.cwd(), config.outputDir)
+ * @param config - The logbook config
+ * @param cwd - Optional working directory (defaults to process.cwd())
+ * @returns Absolute path to the output directory
+ */
+export declare function getOutputDirPath(config: LogbookConfig, cwd?: string): string;

package/dist/lib/config.js

@@ -39,3 +39,23 @@ export function getConfig(cwd = process.cwd()) {
     }
     return DEFAULT_CONFIG;
 }
+/**
+ * Get the absolute path to the logbook directory.
+ * Convenience function to avoid repeating: join(process.cwd(), config.logbookDir)
+ * @param config - The logbook config
+ * @param cwd - Optional working directory (defaults to process.cwd())
+ * @returns Absolute path to the logbook directory
+ */
+export function getLogbookDirPath(config, cwd = process.cwd()) {
+    return join(cwd, config.logbookDir);
+}
+/**
+ * Get the absolute path to the output directory.
+ * Convenience function to avoid repeating: join(process.cwd(), config.outputDir)
+ * @param config - The logbook config
+ * @param cwd - Optional working directory (defaults to process.cwd())
+ * @returns Absolute path to the output directory
+ */
+export function getOutputDirPath(config, cwd = process.cwd()) {
+    return join(cwd, config.outputDir);
+}

package/dist/lib/entry-id.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Entry ID utilities for handling slug/ticket pairs.
+ * Normalizes the relationship between entry slug and optional ticket ID.
+ */
+/**
+ * Get the display ID for an entry.
+ * Falls back to slug if ticket is not available.
+ * Used when displaying entries in lists, timelines, etc.
+ * @param ticket - Optional ticket ID (e.g., "LB-43", "PROJ-100")
+ * @param slug - Fallback slug (e.g., "LB-43-my-feature")
+ * @returns The ticket if available, otherwise the slug
+ */
+export declare function getEntryDisplayId(ticket: string | undefined, slug: string): string;
+/**
+ * Get the title/display name for an entry.
+ * Falls back to slug if title is not available.
+ * Used when displaying entries without a proper title.
+ * @param title - Optional title (e.g., "Implement feature X")
+ * @param slug - Fallback slug (e.g., "LB-43-my-feature")
+ * @returns The title if available, otherwise the slug
+ */
+export declare function getEntryDisplayTitle(title: string | undefined, slug: string): string;

package/dist/lib/entry-id.js

@@ -0,0 +1,26 @@
+/**
+ * Entry ID utilities for handling slug/ticket pairs.
+ * Normalizes the relationship between entry slug and optional ticket ID.
+ */
+/**
+ * Get the display ID for an entry.
+ * Falls back to slug if ticket is not available.
+ * Used when displaying entries in lists, timelines, etc.
+ * @param ticket - Optional ticket ID (e.g., "LB-43", "PROJ-100")
+ * @param slug - Fallback slug (e.g., "LB-43-my-feature")
+ * @returns The ticket if available, otherwise the slug
+ */
+export function getEntryDisplayId(ticket, slug) {
+    return ticket || slug;
+}
+/**
+ * Get the title/display name for an entry.
+ * Falls back to slug if title is not available.
+ * Used when displaying entries without a proper title.
+ * @param title - Optional title (e.g., "Implement feature X")
+ * @param slug - Fallback slug (e.g., "LB-43-my-feature")
+ * @returns The title if available, otherwise the slug
+ */
+export function getEntryDisplayTitle(title, slug) {
+    return title || slug;
+}

package/dist/lib/entry-paths.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Encapsulates knowledge of logbook entry folder structure.
+ * Provides consistent path construction for entry-related files.
+ */
+/**
+ * Get the base directory path for a logbook entry.
+ * @param logbookDir - The root logbook directory (e.g., "/project/logbook")
+ * @param entrySlug - The entry's slug (e.g., "LB-43-my-feature")
+ * @returns Path to the entry folder (e.g., "/project/logbook/LB-43-my-feature")
+ */
+export declare function getEntryPath(logbookDir: string, entrySlug: string): string;
+/**
+ * Get all standard entry file paths at once.
+ * Useful when you need to access index, ticket, and log files.
+ * @param logbookDir - The root logbook directory
+ * @param entrySlug - The entry's slug
+ * @returns Object with paths to index.md, ticket.md, and log.md
+ */
+export declare function getEntryFilePaths(logbookDir: string, entrySlug: string): {
+    index: string;
+    ticket: string;
+    log: string;
+};