bunki 0.17.0 → 0.18.0

package/dist/index.js

@@ -30961,6 +30961,20 @@ function detectFileConflicts(files) {
   }
   return errors;
 }
+async function parseMarkdownFiles(filePaths, cdnConfig) {
+  const resultsPromises = filePaths.map((filePath) => parseMarkdownFile(filePath, cdnConfig).then((result) => ({
+    result,
+    filePath
+  })));
+  const results = await Promise.all(resultsPromises);
+  const postsWithPaths = [];
+  for (const { result, filePath } of results) {
+    if (result.post) {
+      postsWithPaths.push({ post: result.post, filePath });
+    }
+  }
+  return postsWithPaths;
+}
 async function parseMarkdownDirectory(contentDir, strictMode = false, cdnConfig) {
   try {
     const markdownFiles = await findFilesByPattern("**/*.md", contentDir, true);
@@ -31319,7 +31333,7 @@ async function startServer(outputDir = DEFAULT_OUTPUT_DIR, port = 3000) {
 // src/site-generator.ts
 var import_nunjucks2 = __toESM(require_nunjucks(), 1);
 var import_slugify = __toESM(require_slugify(), 1);
-import path8 from "path";
+import path9 from "path";
 
 // src/utils/json-ld.ts
 function generateOrganizationSchema(site) {
@@ -31485,6 +31499,165 @@ function generateHomePageSchemas(options2) {
   return schemas;
 }
 
+// src/utils/build-cache.ts
+var {hash } = globalThis.Bun;
+import path5 from "path";
+var CACHE_VERSION = "2.0.0";
+var CACHE_FILENAME = ".bunki-cache.json";
+async function hashFile(filePath) {
+  try {
+    const file = Bun.file(filePath);
+    const content = await file.arrayBuffer();
+    return hash(content).toString(36);
+  } catch (error) {
+    return "";
+  }
+}
+async function getFileMtime(filePath) {
+  try {
+    const stat = await Bun.file(filePath).stat();
+    return stat?.mtime?.getTime() || 0;
+  } catch (error) {
+    return 0;
+  }
+}
+async function loadCache(cwd) {
+  const cachePath = path5.join(cwd, CACHE_FILENAME);
+  const cacheFile = Bun.file(cachePath);
+  try {
+    if (await cacheFile.exists()) {
+      const content = await cacheFile.text();
+      const cache = JSON.parse(content);
+      if (cache.version !== CACHE_VERSION) {
+        console.log(`Cache version mismatch (${cache.version} vs ${CACHE_VERSION}), rebuilding...`);
+        return createEmptyCache();
+      }
+      return cache;
+    }
+  } catch (error) {
+    console.warn("Error loading cache, rebuilding:", error);
+  }
+  return createEmptyCache();
+}
+async function saveCache(cwd, cache) {
+  const cachePath = path5.join(cwd, CACHE_FILENAME);
+  try {
+    await Bun.write(cachePath, JSON.stringify(cache, null, 2));
+  } catch (error) {
+    console.warn("Error saving cache:", error);
+  }
+}
+function createEmptyCache() {
+  return {
+    version: CACHE_VERSION,
+    files: {}
+  };
+}
+async function hasFileChanged(filePath, cache) {
+  const cached = cache.files[filePath];
+  if (!cached) {
+    return true;
+  }
+  const currentMtime = await getFileMtime(filePath);
+  if (currentMtime !== cached.mtime) {
+    const currentHash = await hashFile(filePath);
+    return currentHash !== cached.hash;
+  }
+  return false;
+}
+async function updateCacheEntry(filePath, cache, options2) {
+  const currentHash = await hashFile(filePath);
+  const currentMtime = await getFileMtime(filePath);
+  cache.files[filePath] = {
+    hash: currentHash,
+    mtime: currentMtime,
+    post: options2?.post,
+    outputs: options2?.outputs
+  };
+}
+async function hasConfigChanged(configPath, cache) {
+  const currentHash = await hashFile(configPath);
+  if (!cache.configHash) {
+    cache.configHash = currentHash;
+    return true;
+  }
+  if (currentHash !== cache.configHash) {
+    cache.configHash = currentHash;
+    return true;
+  }
+  return false;
+}
+function loadCachedPosts(cache, filePaths) {
+  const posts = [];
+  for (const filePath of filePaths) {
+    const entry = cache.files[filePath];
+    if (entry?.post) {
+      posts.push(entry.post);
+    }
+  }
+  return posts;
+}
+
+// src/utils/change-detector.ts
+async function detectChanges(currentFiles, cache, options2 = {}) {
+  const changes = {
+    changedPosts: [],
+    deletedPosts: [],
+    stylesChanged: false,
+    configChanged: false,
+    templatesChanged: false,
+    fullRebuild: false
+  };
+  if (options2.configPath) {
+    const configChanged = await hasFileChanged(options2.configPath, cache);
+    if (configChanged) {
+      changes.configChanged = true;
+      changes.fullRebuild = true;
+      return changes;
+    }
+  }
+  if (options2.templatePaths && options2.templatePaths.length > 0) {
+    for (const templatePath of options2.templatePaths) {
+      const changed = await hasFileChanged(templatePath, cache);
+      if (changed) {
+        changes.templatesChanged = true;
+        changes.fullRebuild = true;
+        return changes;
+      }
+    }
+  }
+  if (options2.stylesPaths && options2.stylesPaths.length > 0) {
+    for (const stylePath of options2.stylesPaths) {
+      const changed = await hasFileChanged(stylePath, cache);
+      if (changed) {
+        changes.stylesChanged = true;
+        break;
+      }
+    }
+  }
+  for (const filePath of currentFiles) {
+    const changed = await hasFileChanged(filePath, cache);
+    if (changed) {
+      changes.changedPosts.push(filePath);
+    }
+  }
+  const cachedFiles = Object.keys(cache.files).filter((f) => f.endsWith(".md"));
+  for (const cachedFile of cachedFiles) {
+    if (!currentFiles.includes(cachedFile)) {
+      changes.deletedPosts.push(cachedFile);
+    }
+  }
+  if (changes.deletedPosts.length > 0) {
+    changes.fullRebuild = true;
+  }
+  return changes;
+}
+function estimateTimeSaved(totalPosts, changedPosts) {
+  const avgTimePerPost = 6;
+  const skippedPosts = totalPosts - changedPosts;
+  return skippedPosts * avgTimePerPost;
+}
+
 // src/utils/xml-builder.ts
 function escapeXml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
@@ -31717,14 +31890,14 @@ Sitemap: ${config.baseUrl}/sitemap.xml
 
 // src/generators/pages.ts
 var import_nunjucks = __toESM(require_nunjucks(), 1);
-import path5 from "path";
+import path6 from "path";
 function getSortedTags(tags, limit) {
   const sorted = Object.values(tags).sort((a, b2) => b2.count - a.count);
   return limit ? sorted.slice(0, limit) : sorted;
 }
 async function writeHtmlFile(outputDir, relativePath, content) {
-  const fullPath = path5.join(outputDir, relativePath);
-  const dir = path5.dirname(fullPath);
+  const fullPath = path6.join(outputDir, relativePath);
+  const dir = path6.dirname(fullPath);
   await ensureDir(dir);
   await Bun.write(fullPath, content);
 }
@@ -31900,12 +32073,12 @@ async function generateMapPage(site, config, outputDir) {
 
 // src/generators/assets.ts
 var {Glob: Glob2 } = globalThis.Bun;
-import path7 from "path";
+import path8 from "path";
 
 // src/utils/css-processor.ts
 import { spawn } from "child_process";
-var {hash } = globalThis.Bun;
-import path6 from "path";
+var {hash: hash2 } = globalThis.Bun;
+import path7 from "path";
 async function processCSS(options2) {
   const {
     css,
@@ -31920,14 +32093,14 @@ async function processCSS(options2) {
     }
     return { outputPath: "" };
   }
-  const inputPath = path6.resolve(projectRoot, css.input);
-  const tempOutputPath = path6.resolve(outputDir, css.output);
-  const postcssConfigPath = css.postcssConfig ? path6.resolve(projectRoot, css.postcssConfig) : path6.resolve(projectRoot, "postcss.config.js");
+  const inputPath = path7.resolve(projectRoot, css.input);
+  const tempOutputPath = path7.resolve(outputDir, css.output);
+  const postcssConfigPath = css.postcssConfig ? path7.resolve(projectRoot, css.postcssConfig) : path7.resolve(projectRoot, "postcss.config.js");
   const inputFile = Bun.file(inputPath);
   if (!await inputFile.exists()) {
     throw new Error(`CSS input file not found: ${inputPath}`);
   }
-  const outputDirPath = path6.dirname(tempOutputPath);
+  const outputDirPath = path7.dirname(tempOutputPath);
   await ensureDir(outputDirPath);
   if (verbose) {
     console.log("\uD83C\uDFA8 Building CSS with PostCSS...");
@@ -31939,12 +32112,12 @@ async function processCSS(options2) {
   if (enableHashing) {
     const cssFile = Bun.file(tempOutputPath);
     const cssContent = await cssFile.arrayBuffer();
-    const contentHash = hash(cssContent).toString(36).slice(0, 8);
-    const ext = path6.extname(tempOutputPath);
-    const basename = path6.basename(tempOutputPath, ext);
-    const dir = path6.dirname(tempOutputPath);
+    const contentHash = hash2(cssContent).toString(36).slice(0, 8);
+    const ext = path7.extname(tempOutputPath);
+    const basename = path7.basename(tempOutputPath, ext);
+    const dir = path7.dirname(tempOutputPath);
     const hashedFilename = `${basename}.${contentHash}${ext}`;
-    const hashedOutputPath = path6.join(dir, hashedFilename);
+    const hashedOutputPath = path7.join(dir, hashedFilename);
     await Bun.write(hashedOutputPath, cssFile);
     if (verbose) {
       console.log(`\u2705 CSS hashed: ${hashedFilename}`);
@@ -32020,15 +32193,15 @@ async function generateStylesheet(config, outputDir) {
   }
 }
 async function fallbackCSSGeneration(cssConfig, outputDir) {
-  const cssFilePath = path7.resolve(process.cwd(), cssConfig.input);
+  const cssFilePath = path8.resolve(process.cwd(), cssConfig.input);
   const cssFile = Bun.file(cssFilePath);
   if (!await cssFile.exists()) {
     console.warn(`CSS input file not found: ${cssFilePath}`);
     return;
   }
   try {
-    const outputPath = path7.resolve(outputDir, cssConfig.output);
-    const outputDirPath = path7.dirname(outputPath);
+    const outputPath = path8.resolve(outputDir, cssConfig.output);
+    const outputDirPath = path8.dirname(outputPath);
     await ensureDir(outputDirPath);
     await Bun.write(outputPath, cssFile);
     console.log("\u2705 CSS file copied successfully (fallback mode)");
@@ -32037,19 +32210,19 @@ async function fallbackCSSGeneration(cssConfig, outputDir) {
   }
 }
 async function copyStaticAssets(templatesDir, outputDir) {
-  const assetsDir = path7.join(templatesDir, "assets");
-  const publicDir = path7.join(process.cwd(), "public");
+  const assetsDir = path8.join(templatesDir, "assets");
+  const publicDir = path8.join(process.cwd(), "public");
   if (await isDirectory(assetsDir)) {
     const assetGlob = new Glob2("**/*.*");
-    const assetsOutputDir = path7.join(outputDir, "assets");
+    const assetsOutputDir = path8.join(outputDir, "assets");
     await ensureDir(assetsOutputDir);
     for await (const file of assetGlob.scan({
       cwd: assetsDir,
       absolute: true
     })) {
-      const relativePath = path7.relative(assetsDir, file);
-      const targetPath = path7.join(assetsOutputDir, relativePath);
-      const targetDir = path7.dirname(targetPath);
+      const relativePath = path8.relative(assetsDir, file);
+      const targetPath = path8.join(assetsOutputDir, relativePath);
+      const targetDir = path8.dirname(targetPath);
       await ensureDir(targetDir);
       await copyFile(file, targetPath);
     }
@@ -32063,9 +32236,9 @@ async function copyStaticAssets(templatesDir, outputDir) {
     })) {
       if (await isDirectory(file))
         continue;
-      const relativePath = path7.relative(publicDir, file);
-      const destPath = path7.join(outputDir, relativePath);
-      const targetDir = path7.dirname(destPath);
+      const relativePath = path8.relative(publicDir, file);
+      const destPath = path8.join(outputDir, relativePath);
+      const targetDir = path8.dirname(destPath);
       await ensureDir(targetDir);
       await copyFile(file, destPath);
     }
@@ -32147,6 +32320,8 @@ class SiteGenerator {
   options;
   site;
   metrics;
+  cache = null;
+  incrementalMode = false;
   constructor(options2) {
     this.options = options2;
     this.site = {
@@ -32158,8 +32333,7 @@ class SiteGenerator {
     this.metrics = new MetricsCollector;
     const env = import_nunjucks2.default.configure(this.options.templatesDir, {
       autoescape: true,
-      watch: false,
-      noCache: false
+      watch: false
     });
     env.addFilter("date", (date, format) => {
       const d2 = toPacificTime(date);
@@ -32192,6 +32366,9 @@ class SiteGenerator {
       }
     });
   }
+  enableIncrementalMode() {
+    this.incrementalMode = true;
+  }
   async initialize() {
     this.metrics.startStage("initialization");
     console.log("Initializing site generator...");
@@ -32200,7 +32377,7 @@ class SiteGenerator {
       setNoFollowExceptions(this.options.config.noFollowExceptions);
     }
     let tagDescriptions = {};
-    const tagsTomlPath = path8.join(process.cwd(), "src", "tags.toml");
+    const tagsTomlPath = path9.join(process.cwd(), "src", "tags.toml");
     const tagsTomlFile = Bun.file(tagsTomlPath);
     if (await tagsTomlFile.exists()) {
       try {
@@ -32210,8 +32387,10 @@ class SiteGenerator {
         console.warn("Error loading tag descriptions:", error);
       }
     }
-    const strictMode = this.options.config.strictMode ?? false;
-    const posts = await parseMarkdownDirectory(this.options.contentDir, strictMode, this.options.config.cdn);
+    if (this.incrementalMode) {
+      this.cache = await loadCache(process.cwd());
+    }
+    const posts = await this.parseContent();
     const tags = {};
     posts.forEach((post) => {
       post.tagSlugs = {};
@@ -32249,7 +32428,21 @@ class SiteGenerator {
     console.log("Generating static site...");
     await ensureDir(this.options.outputDir);
     this.metrics.startStage("cssProcessing");
-    await generateStylesheet(this.options.config, this.options.outputDir);
+    let cssChanged = true;
+    if (this.cache && this.incrementalMode && this.options.config.css) {
+      const cssInputPath = path9.resolve(process.cwd(), this.options.config.css.input);
+      const cssOutputPath = path9.join(this.options.outputDir, this.options.config.css.output);
+      const cssOutputExists = await Bun.file(cssOutputPath).exists();
+      cssChanged = await hasFileChanged(cssInputPath, this.cache);
+      if (!cssChanged && cssOutputExists) {
+        console.log("\u23ED\uFE0F  Skipping CSS (unchanged)");
+      } else {
+        await generateStylesheet(this.options.config, this.options.outputDir);
+        await updateCacheEntry(cssInputPath, this.cache);
+      }
+    } else {
+      await generateStylesheet(this.options.config, this.options.outputDir);
+    }
     this.metrics.startStage("pageGeneration");
     await Promise.all([
       generateIndexPages(this.site, this.options.config, this.options.outputDir),
@@ -32266,25 +32459,75 @@ class SiteGenerator {
     const outputStats = await this.calculateOutputStats();
     const buildMetrics = this.metrics.getMetrics(outputStats);
     displayMetrics(buildMetrics);
+    if (this.cache) {
+      await saveCache(process.cwd(), this.cache);
+    }
   }
   async generateFeeds() {
     const pageSize = 10;
     const rssContent = generateRSSFeed(this.site, this.options.config);
-    await Bun.write(path8.join(this.options.outputDir, "feed.xml"), rssContent);
+    await Bun.write(path9.join(this.options.outputDir, "feed.xml"), rssContent);
     const sitemapContent = generateSitemap(this.site, this.options.config, pageSize);
-    await Bun.write(path8.join(this.options.outputDir, "sitemap.xml"), sitemapContent);
+    await Bun.write(path9.join(this.options.outputDir, "sitemap.xml"), sitemapContent);
     console.log("Generated sitemap.xml");
     const urlCount = this.site.posts.length + Object.keys(this.site.tags).length + 10;
     const sitemapSize = sitemapContent.length;
     if (urlCount > 1000 || sitemapSize > 40000) {
       const sitemapIndexContent = generateSitemapIndex(this.options.config);
-      await Bun.write(path8.join(this.options.outputDir, "sitemap_index.xml"), sitemapIndexContent);
+      await Bun.write(path9.join(this.options.outputDir, "sitemap_index.xml"), sitemapIndexContent);
       console.log("Generated sitemap_index.xml");
     }
     const robotsTxtContent = generateRobotsTxt(this.options.config);
-    await Bun.write(path8.join(this.options.outputDir, "robots.txt"), robotsTxtContent);
+    await Bun.write(path9.join(this.options.outputDir, "robots.txt"), robotsTxtContent);
     console.log("Generated robots.txt");
   }
+  async parseContent() {
+    const strictMode = this.options.config.strictMode ?? false;
+    if (!this.incrementalMode || !this.cache) {
+      const posts = await parseMarkdownDirectory(this.options.contentDir, strictMode, this.options.config.cdn);
+      if (this.cache) {
+        const allFiles2 = await findFilesByPattern("**/*.md", this.options.contentDir, true);
+        const postsByPath = new Map(posts.map((p) => [p.url, p]));
+        for (let i = 0;i < allFiles2.length; i++) {
+          const filePath = allFiles2[i];
+          const post = posts[i];
+          await updateCacheEntry(filePath, this.cache, { post });
+        }
+      }
+      return posts;
+    }
+    const allFiles = await findFilesByPattern("**/*.md", this.options.contentDir, true);
+    const configPath = path9.join(process.cwd(), "bunki.config.ts");
+    const configChanged = await hasConfigChanged(configPath, this.cache);
+    if (configChanged) {
+      console.log("Config changed, full rebuild required");
+      return this.parseContent();
+    }
+    const changes = await detectChanges(allFiles, this.cache);
+    if (changes.fullRebuild) {
+      console.log("Full rebuild required");
+      this.incrementalMode = false;
+      return this.parseContent();
+    }
+    if (changes.changedPosts.length === 0) {
+      console.log("No content changes detected, using cached posts");
+      const cachedPosts2 = loadCachedPosts(this.cache, allFiles);
+      console.log(`\u2728 Loaded ${cachedPosts2.length} posts from cache (0ms parsing)`);
+      return cachedPosts2;
+    }
+    const timeSaved = estimateTimeSaved(allFiles.length, changes.changedPosts.length);
+    console.log(`\uD83D\uDCE6 Incremental build: ${changes.changedPosts.length}/${allFiles.length} files changed (~${timeSaved}ms saved)`);
+    const changedPostsWithPaths = await parseMarkdownFiles(changes.changedPosts, this.options.config.cdn);
+    const unchangedFiles = allFiles.filter((f) => !changes.changedPosts.includes(f));
+    const cachedPosts = loadCachedPosts(this.cache, unchangedFiles);
+    console.log(`   Parsed: ${changedPostsWithPaths.length} new/changed, loaded: ${cachedPosts.length} from cache`);
+    const changedPosts = changedPostsWithPaths.map((p) => p.post);
+    const allPosts = [...changedPosts, ...cachedPosts].sort((a, b2) => new Date(b2.date).getTime() - new Date(a.date).getTime());
+    for (const { post, filePath } of changedPostsWithPaths) {
+      await updateCacheEntry(filePath, this.cache, { post });
+    }
+    return allPosts;
+  }
   groupPostsByYear(posts) {
     const postsByYear = {};
     for (const post of posts) {
@@ -32324,11 +32567,11 @@ class SiteGenerator {
   }
 }
 // src/utils/image-uploader.ts
-import path10 from "path";
+import path11 from "path";
 
 // src/utils/s3-uploader.ts
 var {S3Client } = globalThis.Bun;
-import path9 from "path";
+import path10 from "path";
 
 class S3Uploader {
   s3Config;
@@ -32451,8 +32694,8 @@ class S3Uploader {
       let failedCount = 0;
       const uploadTasks = imageFiles.map((imageFile) => async () => {
         try {
-          const imagePath = path9.join(imagesDir, imageFile);
-          const filename = path9.basename(imagePath);
+          const imagePath = path10.join(imagesDir, imageFile);
+          const filename = path10.basename(imagePath);
           const file = Bun.file(imagePath);
           const contentType = file.type;
           if (process.env.BUNKI_DRY_RUN === "true") {} else {
@@ -32486,10 +32729,10 @@ function createUploader(config) {
 }
 
 // src/utils/image-uploader.ts
-var DEFAULT_IMAGES_DIR = path10.join(process.cwd(), "assets");
+var DEFAULT_IMAGES_DIR = path11.join(process.cwd(), "assets");
 async function uploadImages(options2 = {}) {
   try {
-    const imagesDir = path10.resolve(options2.images || DEFAULT_IMAGES_DIR);
+    const imagesDir = path11.resolve(options2.images || DEFAULT_IMAGES_DIR);
     if (!await fileExists(imagesDir)) {
       console.log(`Creating images directory at ${imagesDir}...`);
       await ensureDir(imagesDir);
@@ -32526,7 +32769,7 @@ async function uploadImages(options2 = {}) {
     const uploader = createUploader(s3Config);
     const imageUrlMap = await uploader.uploadImages(imagesDir, options2.minYear);
     if (options2.outputJson) {
-      const outputFile = path10.resolve(options2.outputJson);
+      const outputFile = path11.resolve(options2.outputJson);
       await Bun.write(outputFile, JSON.stringify(imageUrlMap, null, 2));
       console.log(`Image URL mapping saved to ${outputFile}`);
     }

package/dist/parser.d.ts

@@ -4,4 +4,12 @@ export interface ParseResult {
     posts: Post[];
     errors: ParseError[];
 }
+/**
+ * Parse specific markdown files (for incremental builds)
+ * Returns both posts and their file paths for cache updates
+ */
+export declare function parseMarkdownFiles(filePaths: string[], cdnConfig?: CDNConfig): Promise<Array<{
+    post: Post;
+    filePath: string;
+}>>;
 export declare function parseMarkdownDirectory(contentDir: string, strictMode?: boolean, cdnConfig?: CDNConfig): Promise<Post[]>;

package/dist/site-generator.d.ts

@@ -7,7 +7,13 @@ export declare class SiteGenerator {
     private options;
     private site;
     private metrics;
+    private cache;
+    private incrementalMode;
     constructor(options: GeneratorOptions);
+    /**
+     * Enable incremental builds
+     */
+    enableIncrementalMode(): void;
     /**
      * Initialize site data - parse markdown and prepare site structure
      */
@@ -20,6 +26,10 @@ export declare class SiteGenerator {
      * Generate all feed files (RSS, sitemap, robots.txt)
      */
     private generateFeeds;
+    /**
+     * Parse content (full or incremental)
+     */
+    private parseContent;
     /**
      * Group posts by year (Pacific timezone)
      * @param posts - Array of posts

package/dist/utils/build-cache.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Build cache for incremental builds
+ * Tracks file hashes, modification times, parsed post data, and build outputs
+ */
+import type { Post } from "../types";
+export interface CacheEntry {
+    /** Content hash of the file */
+    hash: string;
+    /** Last modification time (ms since epoch) */
+    mtime: number;
+    /** Cached parsed post data */
+    post?: Post;
+    /** Generated output files */
+    outputs?: string[];
+}
+export interface BuildCache {
+    /** Version of cache format */
+    version: string;
+    /** File cache entries */
+    files: Record<string, CacheEntry>;
+    /** Config file hash */
+    configHash?: string;
+    /** Last full build timestamp */
+    lastFullBuild?: number;
+}
+/**
+ * Calculate content hash for a file
+ */
+export declare function hashFile(filePath: string): Promise<string>;
+/**
+ * Get file modification time
+ */
+export declare function getFileMtime(filePath: string): Promise<number>;
+/**
+ * Load build cache from disk
+ */
+export declare function loadCache(cwd: string): Promise<BuildCache>;
+/**
+ * Save build cache to disk
+ */
+export declare function saveCache(cwd: string, cache: BuildCache): Promise<void>;
+/**
+ * Create empty build cache
+ */
+export declare function createEmptyCache(): BuildCache;
+/**
+ * Check if a file has changed since last build
+ */
+export declare function hasFileChanged(filePath: string, cache: BuildCache): Promise<boolean>;
+/**
+ * Update cache entry for a file
+ */
+export declare function updateCacheEntry(filePath: string, cache: BuildCache, options?: {
+    post?: Post;
+    outputs?: string[];
+}): Promise<void>;
+/**
+ * Remove cache entry for a file
+ */
+export declare function removeCacheEntry(filePath: string, cache: BuildCache): void;
+/**
+ * Check if config file has changed
+ */
+export declare function hasConfigChanged(configPath: string, cache: BuildCache): Promise<boolean>;
+/**
+ * Mark full build timestamp
+ */
+export declare function markFullBuild(cache: BuildCache): void;
+/**
+ * Check if full rebuild is needed
+ */
+export declare function needsFullRebuild(cache: BuildCache, maxAge: number): boolean;
+/**
+ * Load cached posts for files that haven't changed
+ */
+export declare function loadCachedPosts(cache: BuildCache, filePaths: string[]): Post[];

package/dist/utils/change-detector.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Change detection for incremental builds
+ * Determines which files have changed and what needs to be rebuilt
+ */
+import type { BuildCache } from "./build-cache";
+import type { Post } from "../types";
+export interface ChangeSet {
+    /** Posts that were added or modified */
+    changedPosts: string[];
+    /** Posts that were deleted */
+    deletedPosts: string[];
+    /** Whether any CSS/style files changed */
+    stylesChanged: boolean;
+    /** Whether config file changed */
+    configChanged: boolean;
+    /** Whether template files changed */
+    templatesChanged: boolean;
+    /** Whether a full rebuild is required */
+    fullRebuild: boolean;
+}
+/**
+ * Detect changes since last build
+ */
+export declare function detectChanges(currentFiles: string[], cache: BuildCache, options?: {
+    configPath?: string;
+    stylesPaths?: string[];
+    templatePaths?: string[];
+}): Promise<ChangeSet>;
+/**
+ * Determine affected tags from changed posts
+ */
+export declare function getAffectedTags(changedPosts: Post[], allPosts: Post[]): Set<string>;
+/**
+ * Check if index pages need regeneration
+ */
+export declare function needsIndexRegeneration(changes: ChangeSet): boolean;
+/**
+ * Estimate time saved by incremental build
+ */
+export declare function estimateTimeSaved(totalPosts: number, changedPosts: number): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunki",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "An opinionated static site generator built with Bun featuring PostCSS integration and modern web development workflows",
   "main": "dist/index.js",
   "module": "dist/index.mjs",