project-logbook 0.3.0

package/dist/lib/config.d.ts

@@ -0,0 +1,14 @@
+export declare function getWorkspaces(cwd?: string): string[];
+export interface LogbookConfig {
+    projectName: string;
+    logbookDir: string;
+    outputDir: string;
+    primaryColor: string;
+    jiraBaseUrl?: string;
+    jiraPrefix?: string;
+    tags?: {
+        allowed: string[];
+    };
+}
+export declare const DEFAULT_CONFIG: LogbookConfig;
+export declare function getConfig(cwd?: string): LogbookConfig;

package/dist/lib/config.js

@@ -0,0 +1,41 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+export function getWorkspaces(cwd = process.cwd()) {
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(pkgPath))
+        return [];
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        const ws = pkg.workspaces;
+        if (Array.isArray(ws))
+            return ws.map(String);
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+export const DEFAULT_CONFIG = {
+    projectName: 'My Project',
+    logbookDir: 'logbook',
+    outputDir: 'dist/logbook',
+    primaryColor: '#2563eb',
+    tags: {
+        allowed: ['#bugfix', '#feature', '#refactor'],
+    },
+};
+export function getConfig(cwd = process.cwd()) {
+    const configPath = join(cwd, '.project-logbook');
+    if (existsSync(configPath)) {
+        try {
+            const userConfig = JSON.parse(readFileSync(configPath, 'utf8'));
+            return { ...DEFAULT_CONFIG, ...userConfig };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            console.warn(`Warning: Failed to parse .project-logbook config — using defaults. (${errorMessage})`);
+            return DEFAULT_CONFIG;
+        }
+    }
+    return DEFAULT_CONFIG;
+}

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

@@ -0,0 +1,16 @@
+import type { GitCommit } from './template-types.js';
+/**
+ * Parse the raw output of `git log --pretty=format:"%H|%s|%aI"` into GitCommit objects.
+ * Pure function (no I/O) — unit-testable without spawning git.
+ */
+export declare function parseGitLogOutput(raw: string, now?: Date): GitCommit[];
+export declare function getGitCommits(dir: string, maxCount?: number): Promise<GitCommit[]>;
+export declare function getGitTags(): Promise<{
+    name: string;
+    timestamp: string;
+}[]>;
+/**
+ * Synchronous branch detection — used in session resolution (not the build pipeline).
+ * Kept synchronous intentionally; simple-git is used for the heavier async build operations.
+ */
+export declare function getCurrentBranch(cwd?: string): string | undefined;

package/dist/lib/git-helpers.js

@@ -0,0 +1,93 @@
+import { execSync } from 'node:child_process';
+import { simpleGit } from 'simple-git';
+/**
+ * Parse the raw output of `git log --pretty=format:"%H|%s|%aI"` into GitCommit objects.
+ * Pure function (no I/O) — unit-testable without spawning git.
+ */
+export function parseGitLogOutput(raw, now = new Date()) {
+    if (!raw.trim())
+        return [];
+    return raw
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => {
+        const [sha, message, timestamp] = line.split('|');
+        if (!sha || !message || !timestamp)
+            return null;
+        const relativeTime = formatRelativeTime(timestamp, now);
+        return { sha: sha.slice(0, 7), message, timestamp, relativeTime };
+    })
+        .filter((c) => c !== null);
+}
+function formatRelativeTime(isoTimestamp, now) {
+    const d = new Date(isoTimestamp);
+    if (isNaN(d.getTime()))
+        return isoTimestamp;
+    const diffMs = now.getTime() - d.getTime();
+    const diffSec = Math.floor(diffMs / 1000);
+    if (diffSec < 60)
+        return 'just now';
+    const diffMin = Math.floor(diffSec / 60);
+    if (diffMin < 60)
+        return `${diffMin} minute${diffMin === 1 ? '' : 's'} ago`;
+    const diffHour = Math.floor(diffMin / 60);
+    if (diffHour < 24)
+        return `${diffHour} hour${diffHour === 1 ? '' : 's'} ago`;
+    const diffDay = Math.floor(diffHour / 24);
+    if (diffDay < 30)
+        return `${diffDay} day${diffDay === 1 ? '' : 's'} ago`;
+    const diffMonth = Math.floor(diffDay / 30);
+    if (diffMonth < 12)
+        return `${diffMonth} month${diffMonth === 1 ? '' : 's'} ago`;
+    const diffYear = Math.floor(diffMonth / 12);
+    return `${diffYear} year${diffYear === 1 ? '' : 's'} ago`;
+}
+export async function getGitCommits(dir, maxCount = 100) {
+    try {
+        const git = simpleGit(process.cwd());
+        const raw = await git.raw(['log', '--follow', `-n`, String(maxCount), '--pretty=format:%H|%s|%aI', '--', dir]);
+        return parseGitLogOutput(raw);
+    }
+    catch {
+        return [];
+    }
+}
+export async function getGitTags() {
+    try {
+        const git = simpleGit(process.cwd());
+        const raw = await git.raw(['tag', '-l', '--sort=-creatordate', '--format=%(creatordate:iso8601)|%(refname:short)']);
+        return raw
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            const idx = line.indexOf('|');
+            if (idx === -1)
+                return null;
+            const timestamp = line.slice(0, idx).trim();
+            const name = line.slice(idx + 1).trim();
+            if (!timestamp || !name)
+                return null;
+            return { name, timestamp };
+        })
+            .filter((t) => t !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Synchronous branch detection — used in session resolution (not the build pipeline).
+ * Kept synchronous intentionally; simple-git is used for the heavier async build operations.
+ */
+export function getCurrentBranch(cwd = process.cwd()) {
+    try {
+        return (execSync('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf8',
+            cwd,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim() || undefined);
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Extract image paths from markdown content
+ */
+export declare function extractImagePathsFromMarkdown(content: string): string[];
+/**
+ * Process markdown with image collection enabled
+ * Returns { html, imagePaths }
+ */
+export declare function mdToHtmlWithImages(md: string): Promise<{
+    html: string;
+    imagePaths: string[];
+}>;
+/**
+ * Copy images from source directory to output directory
+ * @param sourceDir - Directory where images are referenced from (e.g., logbook entry folder)
+ * @param outputDir - Output directory where images should be copied (e.g., public/entry-slug/images)
+ * @param imagePaths - Array of image paths from markdown (e.g., ["./images/screenshot.png", "../assets/img.jpg", "/static/img.png"])
+ */
+export declare function copyImages(sourceDir: string, outputDir: string, imagePaths: string[]): Promise<void>;

package/dist/lib/image-helpers.js

@@ -0,0 +1,121 @@
+import fs from 'fs-extra';
+import { join, dirname, relative } 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 chalk from 'chalk';
+/** Regex to match image links in markdown: ![alt](path) */
+const imageLinkRegex = /!\[.*?\]\(([^)]+\.(?:png|jpe?g|gif|svg|webp|bmp|ico))\)/gi;
+/**
+ * Extract image paths from markdown content
+ */
+export function extractImagePathsFromMarkdown(content) {
+    const paths = [];
+    let match;
+    imageLinkRegex.lastIndex = 0;
+    while ((match = imageLinkRegex.exec(content)) !== null) {
+        paths.push(match[1]);
+    }
+    return paths;
+}
+/** ImageProcessor: tracks images encountered during markdown-to-html conversion */
+class ImageProcessor {
+    images = [];
+    reset() {
+        this.images = [];
+    }
+    getImagePaths() {
+        return [...this.images];
+    }
+    /** Rehype plugin: collect image paths from markdown */
+    rehypeCollectImages = () => {
+        return (tree) => {
+            visitImages(tree, (node) => {
+                const src = node.properties?.src;
+                if (typeof src !== 'string')
+                    return;
+                // Skip external URLs and data URIs
+                if (/^[a-z][a-z\d+\-.]*:/i.test(src))
+                    return;
+                if (src.startsWith('data:'))
+                    return;
+                this.images.push(src);
+            });
+        };
+    };
+}
+const imageProcessor = new ImageProcessor();
+function visitImages(node, visitor) {
+    for (const child of node.children) {
+        if (child.type === 'element') {
+            if (child.tagName === 'img')
+                visitor(child);
+            visitImages(child, visitor);
+        }
+    }
+}
+/**
+ * Process markdown with image collection enabled
+ * Returns { html, imagePaths }
+ */
+export async function mdToHtmlWithImages(md) {
+    imageProcessor.reset();
+    const processorWithImages = unified()
+        .use(remarkParse)
+        .use(remarkRehype)
+        .use(imageProcessor.rehypeCollectImages)
+        .use(rehypeSlug)
+        .use(rehypeFormat)
+        .use(rehypeStringify);
+    const result = await processorWithImages.process(md);
+    return { html: result.toString(), imagePaths: imageProcessor.getImagePaths() };
+}
+/**
+ * Copy images from source directory to output directory
+ * @param sourceDir - Directory where images are referenced from (e.g., logbook entry folder)
+ * @param outputDir - Output directory where images should be copied (e.g., public/entry-slug/images)
+ * @param imagePaths - Array of image paths from markdown (e.g., ["./images/screenshot.png", "../assets/img.jpg", "/static/img.png"])
+ */
+export async function copyImages(sourceDir, outputDir, imagePaths) {
+    await fs.mkdirp(outputDir);
+    const processedPaths = new Set();
+    for (const imagePath of imagePaths) {
+        // Skip if already processed
+        if (processedPaths.has(imagePath))
+            continue;
+        processedPaths.add(imagePath);
+        let sourcePath = '';
+        let destRelPath = '';
+        // Handle absolute paths starting with /
+        if (imagePath.startsWith('/')) {
+            // Absolute path like /static/screenshot.jpg -> copy from project root to public/static/
+            const relativeToProjectRoot = imagePath.substring(1); // Remove leading /
+            sourcePath = join(process.cwd(), relativeToProjectRoot);
+            destRelPath = relativeToProjectRoot;
+        }
+        else {
+            // Resolve the image path relative to the source directory
+            let resolvedPath = imagePath;
+            if (!imagePath.startsWith('./') && !imagePath.startsWith('../')) {
+                resolvedPath = `./${imagePath}`;
+            }
+            const fullPath = join(sourceDir, resolvedPath);
+            sourcePath = fullPath;
+            // Get the relative path from source dir to maintain folder structure
+            destRelPath = relative(sourceDir, fullPath);
+        }
+        // Check if image exists
+        if (!(await fs.pathExists(sourcePath))) {
+            console.warn(chalk.yellow(`  Image not found: ${sourcePath}`));
+            continue;
+        }
+        const destPath = join(outputDir, destRelPath);
+        // Create destination directory if needed
+        await fs.mkdirp(dirname(destPath));
+        // Copy the image
+        await fs.copyFile(sourcePath, destPath);
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Replaces PREFIX-NNN occurrences in a commit message with Jira links.
+ * Only applied when both jiraBaseUrl and jiraPrefix are provided.
+ */
+export declare const linkJiraIds: (msg: string, base: string, prefix: string) => string;

package/dist/lib/jira-helpers.js

@@ -0,0 +1,5 @@
+/**
+ * Replaces PREFIX-NNN occurrences in a commit message with Jira links.
+ * Only applied when both jiraBaseUrl and jiraPrefix are provided.
+ */
+export const linkJiraIds = (msg, base, prefix) => msg.replace(new RegExp(`(${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-\\d+)`, 'g'), (m) => `<a href="${base}${m}" target="_blank" rel="noopener noreferrer" class="commit-jira-link">${m}</a>`);

package/dist/lib/lint-runner.d.ts

@@ -0,0 +1,2 @@
+import { LinterContext } from './lint-types.js';
+export declare function runLinters(context: LinterContext): Promise<boolean>;

package/dist/lib/lint-runner.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+import { linters } from '../linters/index.js';
+export async function runLinters(context) {
+    const issues = [];
+    for (const linter of linters) {
+        try {
+            const result = await linter.check(context);
+            issues.push(...result);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error running linter '${linter.name}':`), err);
+        }
+    }
+    if (issues.length === 0) {
+        return true;
+    }
+    if (context.entryName) {
+        console.log(chalk.blue(`\nEntry: ${context.entryName}`));
+    }
+    let hasErrors = false;
+    for (const issue of issues) {
+        if (issue.level === 'error') {
+            console.error(chalk.red(`  [${issue.category.toUpperCase()}] ${issue.message}`));
+            hasErrors = true;
+        }
+        else {
+            console.warn(chalk.yellow(`  [${issue.category.toUpperCase()}] ${issue.message}`));
+        }
+    }
+    return !hasErrors;
+}

package/dist/lib/lint-types.d.ts

@@ -0,0 +1,24 @@
+import { LogbookConfig } from './config.js';
+export interface LintIssue {
+    level: 'error' | 'warning';
+    message: string;
+    category: string;
+}
+export interface LinterContext {
+    config: LogbookConfig;
+    entryName?: string;
+    entryPath?: string;
+    indexPath?: string;
+    content?: string;
+    frontmatter?: Record<string, unknown>;
+}
+export interface Linter {
+    name: string;
+    description: string;
+    /**
+     * Run the linter.
+     * If entryName is provided, it's an entry-level check.
+     * Otherwise, it's a project-level check.
+     */
+    check(context: LinterContext): Promise<LintIssue[]>;
+}

package/dist/lib/lint-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/lockfile.d.ts

@@ -0,0 +1,6 @@
+export declare const LOCKFILE_NAME = ".logbook-active";
+export interface LockfileData {
+    slug: string;
+    startedAt: string;
+    prompter?: string;
+}

package/dist/lib/lockfile.js

@@ -0,0 +1 @@
+export const LOCKFILE_NAME = '.logbook-active';

package/dist/lib/logbook-client.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the client-side logbook.js helper script content.
+ * This is emitted as a standalone JS file into the build output.
+ */
+export declare function getClientScript(): string;

package/dist/lib/logbook-client.js

@@ -0,0 +1,11 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Returns the client-side logbook.js helper script content.
+ * This is emitted as a standalone JS file into the build output.
+ */
+export function getClientScript() {
+    return readFileSync(join(__dirname, '../templates/logbook-client.js'), 'utf8');
+}

package/dist/lib/migrations.d.ts

@@ -0,0 +1,11 @@
+export declare function getTemplatesDir(): string;
+type FileStatus = 'UP_TO_DATE' | 'OUTDATED' | 'MISSING';
+interface ProjectFileStatus {
+    name: string;
+    localPath: string;
+    status: FileStatus;
+    templateContent: string;
+    currentContent?: string;
+}
+export declare function getProjectStatus(): Promise<ProjectFileStatus[]>;
+export {};

package/dist/lib/migrations.js

@@ -0,0 +1,34 @@
+import fs from 'fs-extra';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CORE_FILES = [{ name: 'CONTRIBUTING.md', path: 'CONTRIBUTING.md' }];
+export function getTemplatesDir() {
+    const possiblePaths = [join(__dirname, '../templates'), join(__dirname, '../../src/templates')];
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    throw new Error('Templates directory not found.');
+}
+export async function getProjectStatus() {
+    const cwd = process.cwd();
+    const templatesDir = getTemplatesDir();
+    const results = [];
+    for (const file of CORE_FILES) {
+        const localPath = join(cwd, file.path);
+        const templatePath = join(templatesDir, file.name);
+        if (!fs.existsSync(templatePath))
+            continue;
+        const templateContent = fs.readFileSync(templatePath, 'utf8');
+        if (!fs.existsSync(localPath)) {
+            results.push({ name: file.name, localPath, status: 'MISSING', templateContent });
+        }
+        else {
+            const currentContent = fs.readFileSync(localPath, 'utf8');
+            const status = currentContent === templateContent ? 'UP_TO_DATE' : 'OUTDATED';
+            results.push({ name: file.name, localPath, status, templateContent, currentContent });
+        }
+    }
+    return results;
+}

package/dist/lib/session.d.ts

@@ -0,0 +1,16 @@
+interface ActiveEntryResult {
+    slug: string;
+    source: 'branch' | 'lockfile' | 'flag';
+    startedAt?: string;
+    prompter?: string;
+}
+/**
+ * Resolves the currently active logbook entry using the following strategy:
+ * 1. If options.id is provided, checks if it matches an entry.
+ * 2. If the current Git branch name contains a ticket reference matching config.jiraPrefix or "LB", auto-resolves that entry.
+ * 3. Falls back to reading the local .logbook-active lockfile.
+ */
+export declare function getActiveEntry(options?: {
+    id?: string;
+}, cwd?: string): Promise<ActiveEntryResult | undefined>;
+export {};

package/dist/lib/session.js

@@ -0,0 +1,74 @@
+import fs from 'fs-extra';
+import { join } from 'node:path';
+import { getConfig } from './config.js';
+import { getCurrentBranch } from './git-helpers.js';
+import { LOCKFILE_NAME } from './lockfile.js';
+import { getLogbookEntries } from '../utils/fs.js';
+/**
+ * Resolves the currently active logbook entry using the following strategy:
+ * 1. If options.id is provided, checks if it matches an entry.
+ * 2. If the current Git branch name contains a ticket reference matching config.jiraPrefix or "LB", auto-resolves that entry.
+ * 3. Falls back to reading the local .logbook-active lockfile.
+ */
+export async function getActiveEntry(options = {}, cwd = process.cwd()) {
+    const config = getConfig(cwd);
+    const logbookDir = join(cwd, config.logbookDir);
+    // 1. Early lockfile check
+    const lockfilePath = join(cwd, LOCKFILE_NAME);
+    if (await fs.pathExists(lockfilePath)) {
+        try {
+            const lock = await fs.readJson(lockfilePath);
+            return { slug: lock.slug, source: 'lockfile', startedAt: lock.startedAt, prompter: lock.prompter };
+        }
+        catch {
+            // ignore corrupt lockfile
+        }
+    }
+    // 2. Load logbook entries
+    let entries = [];
+    try {
+        entries = await getLogbookEntries(logbookDir);
+    }
+    catch {
+        entries = [];
+    }
+    const availableSlugs = entries.map((e) => e.slug);
+    // 1. Explicit ID flag
+    if (options.id) {
+        const resolvedId = options.id;
+        // Find entry matching ID prefix (e.g. "LB-35" or "19")
+        // Resolve short number to full prefix-number if possible
+        const fullId = /^\d+$/.test(resolvedId) && config.jiraPrefix ? `${config.jiraPrefix}-${resolvedId}` : resolvedId;
+        const matchingDir = availableSlugs.find((slug) => {
+            const prefix = slug.split('-').slice(0, fullId.split('-').length).join('-');
+            return prefix.toLowerCase() === fullId.toLowerCase();
+        });
+        if (matchingDir) {
+            return {
+                slug: matchingDir,
+                source: 'flag',
+            };
+        }
+    }
+    // 2. Git Branch Resolution
+    const branchName = getCurrentBranch(cwd);
+    if (branchName) {
+        const jiraPrefix = config.jiraPrefix || 'LB';
+        const regex = new RegExp(`(?:^|\\/)(${jiraPrefix}-\\d+)(?:-|$)`, 'i');
+        const match = branchName.match(regex);
+        if (match) {
+            const id = match[1].toUpperCase();
+            const matchingDir = availableSlugs.find((slug) => {
+                const prefix = slug.split('-').slice(0, id.split('-').length).join('-');
+                return prefix.toLowerCase() === id.toLowerCase();
+            });
+            if (matchingDir) {
+                return {
+                    slug: matchingDir,
+                    source: 'branch',
+                };
+            }
+        }
+    }
+    return undefined;
+}

package/dist/lib/styles.d.ts

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

package/dist/lib/styles.js

@@ -0,0 +1,21 @@
+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 getStyles(primaryColor) {
+    const cssPath = join(__dirname, '../templates/styles.css');
+    const staticCss = readFileSync(cssPath, 'utf8');
+    const root = `:root {
+    --primary: ${primaryColor};
+    --primary-soft: ${primaryColor}15;
+    --bg: #fdfdfd;
+    --text: #1a1a1a;
+    --text-muted: #666666;
+    --border: #eeeeee;
+    --card-bg: #ffffff;
+    --max-width: 800px;
+}
+
+`;
+    return root + staticCss;
+}