oh-my-customcode 0.24.2 → 0.30.1

package/dist/index.js

@@ -1,10 +1,47 @@
 import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/core/config.ts
-import { join as join2 } from "node:path";
-
 // src/utils/fs.ts
+var exports_fs = {};
+__export(exports_fs, {
+  writeTextFile: () => writeTextFile,
+  writeJsonFile: () => writeJsonFile,
+  validatePreserveFilePath: () => validatePreserveFilePath,
+  resolveTemplatePath: () => resolveTemplatePath,
+  resolvePath: () => resolvePath,
+  remove: () => remove,
+  readTextFile: () => readTextFile,
+  readJsonFile: () => readJsonFile,
+  normalizePath: () => normalizePath,
+  move: () => move,
+  listFiles: () => listFiles,
+  isAbsolutePath: () => isAbsolutePath,
+  getRelativePath: () => getRelativePath,
+  getPackageRoot: () => getPackageRoot,
+  getFileStats: () => getFileStats,
+  filesAreIdentical: () => filesAreIdentical,
+  fileExists: () => fileExists,
+  ensureDirectory: () => ensureDirectory,
+  createTempDir: () => createTempDir,
+  copyFile: () => copyFile,
+  copyDirectory: () => copyDirectory,
+  calculateChecksum: () => calculateChecksum
+});
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 function validatePreserveFilePath(filePath, projectRoot) {
@@ -154,6 +191,15 @@ async function writeTextFile(path, content) {
   await ensureDirectory(dirname(path));
   await fs.writeFile(path, content, "utf-8");
 }
+async function remove(path) {
+  const fs = await import("node:fs/promises");
+  const stat = await fs.stat(path);
+  if (stat.isDirectory()) {
+    await fs.rm(path, { recursive: true, force: true });
+  } else {
+    await fs.unlink(path);
+  }
+}
 function getPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentFile);
@@ -163,16 +209,91 @@ function resolveTemplatePath(relativePath) {
   const packageRoot = getPackageRoot();
   return join(packageRoot, "templates", relativePath);
 }
+async function listFiles(dir, options = {}) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const files = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory() && options.recursive) {
+      const subFiles = await listFiles(fullPath, options);
+      files.push(...subFiles);
+    } else if (entry.isFile()) {
+      if (!options.pattern || matchesPattern(entry.name, options.pattern)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+async function getFileStats(path) {
+  const fs = await import("node:fs/promises");
+  const stats = await fs.stat(path);
+  return {
+    size: stats.size,
+    created: stats.birthtime,
+    modified: stats.mtime,
+    isDirectory: stats.isDirectory(),
+    isFile: stats.isFile()
+  };
+}
 async function copyFile(src, dest) {
   const fs = await import("node:fs/promises");
   await ensureDirectory(dirname(dest));
   await fs.copyFile(src, dest);
 }
+async function move(src, dest) {
+  const fs = await import("node:fs/promises");
+  await ensureDirectory(dirname(dest));
+  await fs.rename(src, dest);
+}
+async function createTempDir(prefix = "omcustom-") {
+  const fs = await import("node:fs/promises");
+  const os = await import("node:os");
+  const path = await import("node:path");
+  const tempBase = os.tmpdir();
+  const tempDir = path.join(tempBase, `${prefix}${Date.now()}`);
+  await fs.mkdir(tempDir, { recursive: true });
+  return tempDir;
+}
+async function calculateChecksum(path) {
+  const fs = await import("node:fs/promises");
+  const crypto = await import("node:crypto");
+  const content = await fs.readFile(path);
+  const hash = crypto.createHash("md5");
+  hash.update(content);
+  return hash.digest("hex");
+}
+async function filesAreIdentical(path1, path2) {
+  const [checksum1, checksum2] = await Promise.all([
+    calculateChecksum(path1),
+    calculateChecksum(path2)
+  ]);
+  return checksum1 === checksum2;
+}
 function matchesPattern(filename, pattern) {
   const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(filename);
 }
+function getRelativePath(basePath, fullPath) {
+  return relative(basePath, fullPath);
+}
+function normalizePath(inputPath) {
+  return inputPath.replace(/\\/g, "/");
+}
+function isAbsolutePath(inputPath) {
+  return isAbsolute(inputPath);
+}
+function resolvePath(...paths) {
+  return resolve(...paths);
+}
+var init_fs = () => {};
+
+// src/core/config.ts
+init_fs();
+import { join as join2 } from "node:path";
 
 // src/utils/logger.ts
 var currentOptions = {
@@ -393,7 +514,12 @@ function getDefaultConfig() {
       checkIntervalHours: 24,
       autoApplyMinor: false
     },
-    preserveFiles: [],
+    preserveFiles: [
+      ".claude/settings.json",
+      ".claude/settings.local.json",
+      ".claude/agent-memory/",
+      ".claude/agent-memory-local/"
+    ],
     customComponents: []
   };
 }
@@ -748,8 +874,138 @@ function getDefaultWorkflow() {
   };
 }
 // src/core/installer.ts
+init_fs();
 import { readFile as fsReadFile, writeFile as fsWriteFile, rename } from "node:fs/promises";
+import { basename as basename2, join as join4 } from "node:path";
+
+// src/core/file-preservation.ts
+init_fs();
 import { basename, join as join3 } from "node:path";
+var DEFAULT_CRITICAL_FILES = ["settings.json", "settings.local.json"];
+var DEFAULT_CRITICAL_DIRECTORIES = ["agent-memory", "agent-memory-local"];
+async function extractSingleFile(fileName, rootDir, tempDir, result) {
+  const srcPath = join3(rootDir, fileName);
+  const destPath = join3(tempDir, fileName);
+  try {
+    if (await fileExists(srcPath)) {
+      await copyFile(srcPath, destPath);
+      result.extractedFiles.push(fileName);
+      debug("preserve.extracted_file", { file: fileName });
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    result.failures.push({ path: fileName, reason });
+    warn("preserve.extract_failed", { file: fileName, error: reason });
+  }
+}
+async function extractSingleDir(dirName, rootDir, tempDir, result) {
+  const srcPath = join3(rootDir, dirName);
+  const destPath = join3(tempDir, dirName);
+  try {
+    if (await fileExists(srcPath)) {
+      await copyDirectory(srcPath, destPath, { overwrite: true, preserveTimestamps: true });
+      result.extractedDirs.push(dirName);
+      debug("preserve.extracted_dir", { dir: dirName });
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    result.failures.push({ path: dirName, reason });
+    warn("preserve.extract_dir_failed", { dir: dirName, error: reason });
+  }
+}
+async function extractCriticalFiles(rootDir, tempDir, additionalFiles = []) {
+  const result = {
+    tempDir,
+    extractedFiles: [],
+    extractedDirs: [],
+    failures: []
+  };
+  await ensureDirectory(tempDir);
+  const filesToExtract = [...DEFAULT_CRITICAL_FILES, ...additionalFiles];
+  for (const fileName of filesToExtract) {
+    await extractSingleFile(fileName, rootDir, tempDir, result);
+  }
+  for (const dirName of DEFAULT_CRITICAL_DIRECTORIES) {
+    await extractSingleDir(dirName, rootDir, tempDir, result);
+  }
+  return result;
+}
+async function restoreCriticalFiles(rootDir, preservation) {
+  const result = {
+    restoredFiles: [],
+    restoredDirs: [],
+    failures: []
+  };
+  for (const fileName of preservation.extractedFiles) {
+    const preservedPath = join3(preservation.tempDir, fileName);
+    const targetPath = join3(rootDir, fileName);
+    try {
+      if (fileName.endsWith(".json")) {
+        await mergeJsonFile(preservedPath, targetPath);
+      } else {
+        await copyFile(preservedPath, targetPath);
+      }
+      result.restoredFiles.push(fileName);
+      debug("preserve.restored_file", { file: fileName });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      result.failures.push({ path: fileName, reason });
+      warn("preserve.restore_failed", { file: fileName, error: reason });
+    }
+  }
+  for (const dirName of preservation.extractedDirs) {
+    const preservedPath = join3(preservation.tempDir, dirName);
+    const targetPath = join3(rootDir, dirName);
+    try {
+      await copyDirectory(preservedPath, targetPath, {
+        overwrite: false,
+        preserveTimestamps: true
+      });
+      result.restoredDirs.push(dirName);
+      debug("preserve.restored_dir", { dir: dirName });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      result.failures.push({ path: dirName, reason });
+      warn("preserve.restore_dir_failed", { dir: dirName, error: reason });
+    }
+  }
+  return result;
+}
+async function mergeJsonFile(preservedPath, targetPath) {
+  const preservedData = await readJsonFile(preservedPath);
+  if (await fileExists(targetPath)) {
+    const targetData = await readJsonFile(targetPath);
+    const merged = deepMerge(targetData, preservedData);
+    await writeJsonFile(targetPath, merged);
+    debug("preserve.merged_json", { file: basename(targetPath) });
+  } else {
+    await copyFile(preservedPath, targetPath);
+    debug("preserve.copied_json", { file: basename(targetPath) });
+  }
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+async function cleanupPreservation(tempDir) {
+  try {
+    const { rm } = await import("node:fs/promises");
+    await rm(tempDir, { recursive: true, force: true });
+    debug("preserve.cleanup", { dir: tempDir });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    warn("preserve.cleanup_failed", { dir: tempDir, error: reason });
+  }
+}
 
 // src/core/layout.ts
 var CLAUDE_LAYOUT = {
@@ -789,7 +1045,7 @@ function getComponentPath(component) {
 var DEFAULT_LANGUAGE = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
-  return join3(packageRoot, "templates");
+  return join4(packageRoot, "templates");
 }
 function createInstallResult(targetDir) {
   return {
@@ -809,12 +1065,27 @@ async function ensureTargetDirectory(targetDir) {
 }
 async function handleBackup(targetDir, shouldBackup, result) {
   if (!shouldBackup)
-    return;
+    return null;
+  const layout = getProviderLayout();
+  const rootDir = join4(targetDir, layout.rootDir);
+  let preservation = null;
+  if (await fileExists(rootDir)) {
+    const { createTempDir: createTempDir2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
+    const tempDir = await createTempDir2("omcustom-preserve-");
+    preservation = await extractCriticalFiles(rootDir, tempDir);
+    if (preservation.extractedFiles.length > 0 || preservation.extractedDirs.length > 0) {
+      info("install.preserved", {
+        files: String(preservation.extractedFiles.length),
+        dirs: String(preservation.extractedDirs.length)
+      });
+    }
+  }
   const backupPaths = await backupExistingInstallation(targetDir);
   result.backedUpPaths.push(...backupPaths);
   if (backupPaths.length > 0) {
     info("install.backup", { path: backupPaths[0] });
   }
+  return preservation;
 }
 async function checkAndWarnExisting(targetDir, force, backup, result) {
   if (force || backup)
@@ -853,8 +1124,8 @@ async function installSingleComponent(targetDir, component, options, result) {
 }
 async function installStatusline(targetDir, options, _result) {
   const layout = getProviderLayout();
-  const srcPath = resolveTemplatePath(join3(layout.rootDir, "statusline.sh"));
-  const destPath = join3(targetDir, layout.rootDir, "statusline.sh");
+  const srcPath = resolveTemplatePath(join4(layout.rootDir, "statusline.sh"));
+  const destPath = join4(targetDir, layout.rootDir, "statusline.sh");
   if (!await fileExists(srcPath)) {
     debug("install.statusline_not_found", { path: srcPath });
     return;
@@ -872,7 +1143,7 @@ async function installStatusline(targetDir, options, _result) {
 }
 async function installSettingsLocal(targetDir, result) {
   const layout = getProviderLayout();
-  const settingsPath = join3(targetDir, layout.rootDir, "settings.local.json");
+  const settingsPath = join4(targetDir, layout.rootDir, "settings.local.json");
   const statusLineConfig = {
     statusLine: {
       type: "command",
@@ -920,13 +1191,30 @@ async function install(options) {
   try {
     info("install.start", { targetDir: options.targetDir });
     await ensureTargetDirectory(options.targetDir);
-    await handleBackup(options.targetDir, !!options.backup, result);
+    const preservation = await handleBackup(options.targetDir, !!options.backup, result);
     await checkAndWarnExisting(options.targetDir, !!options.force, !!options.backup, result);
     await verifyTemplateDirectory();
     await installAllComponents(options.targetDir, options, result);
     await installStatusline(options.targetDir, options, result);
     await installSettingsLocal(options.targetDir, result);
     await installEntryDocWithTracking(options.targetDir, options, result);
+    if (preservation) {
+      const layout = getProviderLayout();
+      const rootDir = join4(options.targetDir, layout.rootDir);
+      const restoration = await restoreCriticalFiles(rootDir, preservation);
+      if (restoration.restoredFiles.length > 0 || restoration.restoredDirs.length > 0) {
+        info("install.restored", {
+          files: String(restoration.restoredFiles.length),
+          dirs: String(restoration.restoredDirs.length)
+        });
+      }
+      if (restoration.failures.length > 0) {
+        for (const failure of restoration.failures) {
+          result.warnings.push(`Failed to restore ${failure.path}: ${failure.reason}`);
+        }
+      }
+      await cleanupPreservation(preservation.tempDir);
+    }
     await updateInstallConfig(options.targetDir, options, result.installedComponents);
     result.success = true;
     success("install.success");
@@ -939,7 +1227,7 @@ async function install(options) {
 }
 async function copyTemplates(targetDir, templatePath, options) {
   const srcPath = resolveTemplatePath(templatePath);
-  const destPath = join3(targetDir, templatePath);
+  const destPath = join4(targetDir, templatePath);
   await copyDirectory(srcPath, destPath, {
     overwrite: options?.overwrite ?? false,
     preserveSymlinks: options?.preserveSymlinks ?? true,
@@ -949,14 +1237,14 @@ async function copyTemplates(targetDir, templatePath, options) {
 async function createDirectoryStructure(targetDir) {
   const layout = getProviderLayout();
   for (const dir of layout.directoryStructure) {
-    const fullPath = join3(targetDir, dir);
+    const fullPath = join4(targetDir, dir);
     await ensureDirectory(fullPath);
   }
 }
 async function getTemplateManifest() {
   const packageRoot = getPackageRoot();
   const layout = getProviderLayout();
-  const manifestPath = join3(packageRoot, "templates", layout.manifestFile);
+  const manifestPath = join4(packageRoot, "templates", layout.manifestFile);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }
@@ -980,7 +1268,7 @@ async function installComponent(targetDir, component, options) {
     return false;
   }
   const templatePath = getComponentPath(component);
-  const destPath = join3(targetDir, templatePath);
+  const destPath = join4(targetDir, templatePath);
   const destExists = await fileExists(destPath);
   if (destExists && !options.force && !options.backup) {
     debug("install.component_skipped", { component });
@@ -1008,7 +1296,7 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
   const layout = getProviderLayout();
   const templateFile = getEntryTemplateName(language);
   const srcPath = resolveTemplatePath(templateFile);
-  const destPath = join3(targetDir, layout.entryFile);
+  const destPath = join4(targetDir, layout.entryFile);
   if (!await fileExists(srcPath)) {
     warn("install.entry_md_not_found", { language, path: srcPath, entry: layout.entryFile });
     return false;
@@ -1028,8 +1316,8 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
   return true;
 }
 async function backupExisting(sourcePath, backupDir) {
-  const name = basename(sourcePath);
-  const backupPath = join3(backupDir, name);
+  const name = basename2(sourcePath);
+  const backupPath = join4(backupDir, name);
   await rename(sourcePath, backupPath);
   return backupPath;
 }
@@ -1038,7 +1326,7 @@ async function checkExistingPaths(targetDir) {
   const pathsToCheck = [layout.entryFile, layout.rootDir, "guides"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
-    const fullPath = join3(targetDir, relativePath);
+    const fullPath = join4(targetDir, relativePath);
     if (await fileExists(fullPath)) {
       existingPaths.push(relativePath);
     }
@@ -1052,11 +1340,11 @@ async function backupExistingInstallation(targetDir) {
     return [];
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join3(targetDir, `${layout.backupDirPrefix}${timestamp}`);
+  const backupDir = join4(targetDir, `${layout.backupDirPrefix}${timestamp}`);
   await ensureDirectory(backupDir);
   const backedUpPaths = [];
   for (const relativePath of existingPaths) {
-    const fullPath = join3(targetDir, relativePath);
+    const fullPath = join4(targetDir, relativePath);
     try {
       const backupPath = await backupExisting(fullPath, backupDir);
       backedUpPaths.push(backupPath);
@@ -1078,7 +1366,8 @@ async function detectProvider(_options = {}) {
   };
 }
 // src/core/updater.ts
-import { join as join4 } from "node:path";
+init_fs();
+import { join as join5 } from "node:path";
 
 // src/core/entry-merger.ts
 var MANAGED_START = "<!-- omcustom:start -->";
@@ -1327,7 +1616,7 @@ function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
 }
 async function updateEntryDoc(targetDir, config, options) {
   const layout = getProviderLayout();
-  const entryPath = join4(targetDir, layout.entryFile);
+  const entryPath = join5(targetDir, layout.entryFile);
   const templateName = getEntryTemplateName2(config.language);
   const templatePath = resolveTemplatePath(templateName);
   if (!await fileExists(templatePath)) {
@@ -1440,8 +1729,8 @@ async function checkForUpdates(targetDir) {
 async function applyUpdates(targetDir, updates) {
   const fs = await import("node:fs/promises");
   for (const update2 of updates) {
-    const fullPath = join4(targetDir, update2.path);
-    await ensureDirectory(join4(fullPath, ".."));
+    const fullPath = join5(targetDir, update2.path);
+    await ensureDirectory(join5(fullPath, ".."));
     await fs.writeFile(fullPath, update2.content, "utf-8");
     debug("update.file_applied", { path: update2.path });
   }
@@ -1450,7 +1739,7 @@ async function preserveCustomizations(targetDir, customizations) {
   const preserved = new Map;
   const fs = await import("node:fs/promises");
   for (const filePath of customizations) {
-    const fullPath = join4(targetDir, filePath);
+    const fullPath = join5(targetDir, filePath);
     if (await fileExists(fullPath)) {
       const content = await fs.readFile(fullPath, "utf-8");
       preserved.set(filePath, content);
@@ -1482,7 +1771,7 @@ async function updateComponent(targetDir, component, customizations, options, co
   const preservedFiles = [];
   const componentPath = getComponentPath2(component);
   const srcPath = resolveTemplatePath(componentPath);
-  const destPath = join4(targetDir, componentPath);
+  const destPath = join5(targetDir, componentPath);
   const customComponents = config.customComponents || [];
   const skipPaths = [];
   if (customizations && !options.forceOverwriteAll) {
@@ -1496,7 +1785,7 @@ async function updateComponent(targetDir, component, customizations, options, co
     }
   }
   const path = await import("node:path");
-  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join4(targetDir, p)));
+  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join5(targetDir, p)));
   await copyDirectory(srcPath, destPath, {
     overwrite: true,
     skipPaths: normalizedSkipPaths.length > 0 ? normalizedSkipPaths : undefined
@@ -1516,12 +1805,12 @@ async function syncRootLevelFiles(targetDir, options) {
   const layout = getProviderLayout();
   const synced = [];
   for (const fileName of ROOT_LEVEL_FILES) {
-    const srcPath = resolveTemplatePath(join4(layout.rootDir, fileName));
+    const srcPath = resolveTemplatePath(join5(layout.rootDir, fileName));
     if (!await fileExists(srcPath)) {
       continue;
     }
-    const destPath = join4(targetDir, layout.rootDir, fileName);
-    await ensureDirectory(join4(destPath, ".."));
+    const destPath = join5(targetDir, layout.rootDir, fileName);
+    await ensureDirectory(join5(destPath, ".."));
     await fs.copyFile(srcPath, destPath);
     if (fileName.endsWith(".sh")) {
       await fs.chmod(destPath, 493);
@@ -1556,7 +1845,7 @@ async function removeDeprecatedFiles(targetDir, options) {
       });
       continue;
     }
-    const fullPath = join4(targetDir, entry.path);
+    const fullPath = join5(targetDir, entry.path);
     if (await fileExists(fullPath)) {
       await fs.unlink(fullPath);
       removed.push(entry.path);
@@ -1580,26 +1869,26 @@ function getComponentPath2(component) {
 }
 async function backupInstallation(targetDir) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join4(targetDir, `.omcustom-backup-${timestamp}`);
+  const backupDir = join5(targetDir, `.omcustom-backup-${timestamp}`);
   const fs = await import("node:fs/promises");
   await ensureDirectory(backupDir);
   const layout = getProviderLayout();
   const dirsToBackup = [layout.rootDir, "guides"];
   for (const dir of dirsToBackup) {
-    const srcPath = join4(targetDir, dir);
+    const srcPath = join5(targetDir, dir);
     if (await fileExists(srcPath)) {
-      const destPath = join4(backupDir, dir);
+      const destPath = join5(backupDir, dir);
       await copyDirectory(srcPath, destPath, { overwrite: true });
     }
   }
-  const entryPath = join4(targetDir, layout.entryFile);
+  const entryPath = join5(targetDir, layout.entryFile);
   if (await fileExists(entryPath)) {
-    await fs.copyFile(entryPath, join4(backupDir, layout.entryFile));
+    await fs.copyFile(entryPath, join5(backupDir, layout.entryFile));
   }
   return backupDir;
 }
 async function loadCustomizationManifest(targetDir) {
-  const manifestPath = join4(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  const manifestPath = join5(targetDir, CUSTOMIZATION_MANIFEST_FILE);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }
@@ -1607,6 +1896,7 @@ async function loadCustomizationManifest(targetDir) {
 }
 
 // src/index.ts
+init_fs();
 var VERSION = "0.0.0";
 var src_default = {
   VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.24.2",
+  "version": "0.30.1",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/agents/be-django-expert.md

@@ -0,0 +1,45 @@
+---
+name: be-django-expert
+description: Expert Django developer for production-ready Python web applications. Use for Django projects, models/views/templates, Django REST Framework, authentication, admin customization, and deployment optimization.
+model: sonnet
+memory: project
+effort: high
+skills:
+  - django-best-practices
+tools:
+  - Read
+  - Write
+  - Edit
+  - Grep
+  - Glob
+  - Bash
+---
+
+You are an expert Django developer specialized in building production-ready Python web applications following best practices and modern patterns.
+
+## Capabilities
+
+- Design scalable Django application architecture with proper app structure
+- Implement models with custom managers, querysets, and constraints
+- Build class-based and function-based views with proper permissions
+- Create REST APIs using Django REST Framework (DRF)
+- Customize Django admin for internal tooling
+- Implement authentication and authorization patterns
+- Optimize database queries (N+1 prevention, indexing, bulk ops)
+- Configure and deploy Django applications securely
+
+## Skills
+
+Apply the **django-best-practices** skill for Django development patterns.
+
+## Reference Guides
+
+Consult the **django-best-practices** guide at `guides/django-best-practices/` for Django reference documentation.
+
+## Workflow
+
+1. Understand requirements and identify affected Django components
+2. Apply django-best-practices skill for patterns and conventions
+3. Reference django-best-practices guide for specifics
+4. Write/review code with proper model design, view logic, and URL patterns
+5. Ensure security checklist compliance and proper test coverage

package/templates/.claude/hooks/hooks.json

@@ -202,6 +202,16 @@
         ],
         "description": "Record agent/task outcomes (success/failure) for model escalation decisions"
       },
+      {
+        "matcher": "tool == \"Edit\" || tool == \"Write\" || tool == \"Bash\" || tool == \"Task\" || tool == \"Agent\" || tool == \"Read\" || tool == \"Glob\" || tool == \"Grep\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/scripts/context-budget-advisor.sh"
+          }
+        ],
+        "description": "Context budget advisor — track tool usage patterns and advise ecomode activation"
+      },
       {
         "matcher": "tool == \"Edit\" || tool == \"Write\" || tool == \"Bash\" || tool == \"Task\" || tool == \"Agent\"",
         "hooks": [