@aramassa/ai-rules 0.1.1-npmjs.20250910072942 → 0.1.5

package/dist/cli.js

@@ -10,6 +10,7 @@ import require$$3 from 'node:fs';
 import require$$4 from 'node:process';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
+import { homedir } from 'os';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -10042,6 +10043,53 @@ class VariableResolver {
     }
 }
 
+/**
+ * Path expansion utility that supports tilde (~) and environment variable expansion
+ *
+ * Features:
+ * - Tilde expansion: ~/path -> /Users/username/path (Unix-like systems only)
+ * - Environment variable expansion: $HOME/path -> /Users/username/path
+ * - Environment variable expansion: ${VAR}/path -> /value/path
+ * - Complex combinations: ~/projects/${PROJECT_NAME}/file.md
+ *
+ * @param inputPath - Path to expand and resolve
+ * @returns Expanded and resolved absolute path
+ * @throws Error if required environment variables are missing
+ */
+function resolvePath(inputPath) {
+    if (!inputPath || typeof inputPath !== 'string') {
+        throw new Error('Path must be a non-empty string');
+    }
+    let expandedPath = inputPath;
+    // 1. Handle tilde expansion first (Unix-like systems only)
+    if (expandedPath.startsWith('~/')) {
+        // Check if we're on Windows
+        if (process.platform === 'win32') {
+            throw new Error('Tilde (~) expansion is not supported on Windows. Use %USERPROFILE% or environment variables instead.');
+        }
+        const homeDir = homedir();
+        expandedPath = path.join(homeDir, expandedPath.slice(2));
+    }
+    else if (expandedPath === '~') {
+        if (process.platform === 'win32') {
+            throw new Error('Tilde (~) expansion is not supported on Windows. Use %USERPROFILE% or environment variables instead.');
+        }
+        expandedPath = homedir();
+    }
+    // 2. Handle environment variable expansion
+    // Support both $VAR and ${VAR} syntax
+    expandedPath = expandedPath.replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (match, bracedVar, simpleVar) => {
+        const varName = bracedVar || simpleVar;
+        const envValue = process.env[varName];
+        if (envValue === undefined) {
+            throw new Error(`Environment variable '${varName}' is not defined`);
+        }
+        return envValue;
+    });
+    // 3. Resolve to absolute path
+    return path.resolve(expandedPath);
+}
+
 const EXCLUDED_STATS_ATTRS = new Set(["human-instruction", "title"]);
 const MAX_IMPORT_DEPTH = 10;
 /**
@@ -10094,7 +10142,7 @@ class ContentTracker {
      * Checks if the same content has already been written to the file
      */
     hasContent(outputFile, content) {
-        const resolvedFile = path.resolve(outputFile);
+        const resolvedFile = resolvePath(outputFile);
         const contentHash = this.generateContentHash(content);
         const fileHashes = this.fileContentHashes.get(resolvedFile);
         return fileHashes ? fileHashes.has(contentHash) : false;
@@ -10103,7 +10151,7 @@ class ContentTracker {
      * Records that content has been written to a file
      */
     addContent(outputFile, content) {
-        const resolvedFile = path.resolve(outputFile);
+        const resolvedFile = resolvePath(outputFile);
         const contentHash = this.generateContentHash(content);
         if (!this.fileContentHashes.has(resolvedFile)) {
             this.fileContentHashes.set(resolvedFile, new Set());
@@ -10114,7 +10162,7 @@ class ContentTracker {
      * Checks if a file has been written to (for auto-append logic)
      */
     hasFile(outputFile) {
-        const resolvedFile = path.resolve(outputFile);
+        const resolvedFile = resolvePath(outputFile);
         return this.fileContentHashes.has(resolvedFile);
     }
     /**
@@ -10160,8 +10208,56 @@ function resolveDefaultSrcDir(providedSrc) {
     return path.join(packageRoot, 'artifact');
 }
 /**
- * Resolves recipe path, supporting package presets with colon syntax
+ * Resolves output path with baseDir support following priority order:
+ * 1. CLI baseDir option (highest priority)
+ * 2. Import-level baseDir (new priority level)
+ * 3. Recipe config.baseDir
+ * 4. Existing behavior (relative to recipe file or current directory)
  */
+function resolveOutputPath(itemOut, cliBaseDir, importBaseDir, recipeBaseDir, recipePath) {
+    // Check if the itemOut contains environment variables or tilde - if so, try to expand
+    let processedItemOut = itemOut;
+    if (itemOut.includes('$') || itemOut.startsWith('~')) {
+        try {
+            processedItemOut = resolvePath(itemOut);
+            // If expansion resulted in an absolute path, use it as-is (ignore baseDir)
+            if (path.isAbsolute(processedItemOut)) {
+                return processedItemOut;
+            }
+        }
+        catch (error) {
+            // If expansion fails, continue with original itemOut
+            processedItemOut = itemOut;
+        }
+    }
+    // If output path is already absolute, use it as-is (ignore baseDir)
+    if (path.isAbsolute(processedItemOut)) {
+        return processedItemOut;
+    }
+    // Determine effective baseDir with priority: CLI > Import > Recipe > undefined
+    const effectiveBaseDir = cliBaseDir || importBaseDir || recipeBaseDir;
+    if (effectiveBaseDir) {
+        // Use baseDir + relative path
+        const expandedBaseDir = resolvePath(effectiveBaseDir);
+        return path.resolve(expandedBaseDir, processedItemOut);
+    }
+    // Existing behavior: resolve relative to recipe file directory or current directory
+    // For preset files (located in presets/ directory), resolve relative to project root instead
+    let baseDirectory = '.';
+    if (recipePath) {
+        const packageRoot = findPackageRoot();
+        const presetsDir = path.join(packageRoot, 'presets');
+        // If the recipe is in the presets directory, use project root as base
+        if (path.dirname(recipePath) === presetsDir) {
+            baseDirectory = process.cwd();
+        }
+        else {
+            // For regular recipe files, use recipe file directory as base
+            baseDirectory = path.dirname(recipePath);
+        }
+    }
+    return path.resolve(baseDirectory, processedItemOut);
+}
 function resolveRecipePath(recipePath) {
     // If recipe starts with ':', resolve to package preset
     if (recipePath.startsWith(':')) {
@@ -10260,11 +10356,26 @@ async function expandRecipeImports(items, currentPath, debugLogger, visited = ne
                     throw new Error(`Invalid imported recipe file '${importPath}': 'recipe' array not found`);
                 }
                 debugLogger?.log(`Import contains ${importData.recipe.length} items`);
+                // Check if this import item has an import-level baseDir
+                const importLevelBaseDir = item.baseDir;
+                if (importLevelBaseDir) {
+                    debugLogger?.log(`Import has baseDir: ${importLevelBaseDir}`);
+                }
                 // Recursively expand imports in the imported recipe
                 debugLogger?.time(`Expanding nested imports in: ${resolvedImportPath}`);
                 const expandedImported = await expandRecipeImports(importData.recipe, resolvedImportPath, debugLogger, newVisited, imported, depth + 1);
                 debugLogger?.timeEnd(`Expanding nested imports in: ${resolvedImportPath}`);
                 debugLogger?.log(`Nested expansion yielded ${expandedImported.length} items`);
+                // If import has baseDir, tag all expanded items with it
+                if (importLevelBaseDir) {
+                    expandedImported.forEach(expandedItem => {
+                        // Only set _importBaseDir if not already set (to preserve nested import baseDir priority)
+                        if (!expandedItem._importBaseDir) {
+                            expandedItem._importBaseDir = importLevelBaseDir;
+                            debugLogger?.log(`Tagged item '${expandedItem.title || expandedItem.out || 'untitled'}' with import baseDir: ${importLevelBaseDir}`);
+                        }
+                    });
+                }
                 // Add all expanded items from the import
                 expanded.push(...expandedImported);
             }
@@ -10313,13 +10424,14 @@ function setupProgram() {
         .command('extract')
         .description('Extract and merge markdown files')
         .option('--src <path>', 'Source directory')
-        .option('--out <path>', 'Output file', './out/instruction.md')
+        .option('--out <path>', 'Output file')
         .option('--type <types>', 'Filter by type (comma-separated)')
         .option('--language <languages>', 'Filter by language (comma-separated)')
         .option('--attr <attributes>', 'Filter by attributes (comma-separated)')
         .option('--title <title>', 'Title for the output')
         .option('--mode <mode>', 'Write mode: append, prepend, overwrite', 'overwrite')
         .option('--recipe <path>', 'Recipe file path or package preset (e.g., :typescript). Can be specified multiple times or comma-separated.', collectRecipeOptions, [])
+        .option('--base-dir <path>', 'Base directory for output files (supports ~ and environment variable expansion)')
         .option('--vars <variables>', 'Template variables in key=value format (comma-separated)')
         .option('--env-file <path>', 'Path to .env file for template variables')
         .option('--debug', 'Enable debug logging')
@@ -10345,6 +10457,33 @@ function setupProgram() {
     });
     return program;
 }
+/**
+ * Recursively scans a directory for YAML files and returns their relative paths
+ */
+async function findYamlFilesRecursively(dir, baseDir = dir) {
+    const yamlFiles = [];
+    try {
+        const items = await fs.readdir(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = path.join(dir, item.name);
+            if (item.isDirectory()) {
+                // Recursively scan subdirectories
+                const subFiles = await findYamlFilesRecursively(fullPath, baseDir);
+                yamlFiles.push(...subFiles);
+            }
+            else if (item.isFile() && (item.name.endsWith('.yaml') || item.name.endsWith('.yml'))) {
+                // Get relative path from base directory
+                const relativePath = path.relative(baseDir, fullPath);
+                yamlFiles.push(relativePath);
+            }
+        }
+    }
+    catch (error) {
+        // Log errors for individual directories/files that can't be read
+        console.warn(`Warning: Could not read directory "${dir}":`, error);
+    }
+    return yamlFiles;
+}
 /**
  * Lists available package presets
  */
@@ -10352,8 +10491,7 @@ async function listPresets() {
     const packageRoot = findPackageRoot();
     const presetsDir = path.join(packageRoot, 'presets');
     try {
-        const files = await fs.readdir(presetsDir);
-        const yamlFiles = files.filter(file => file.endsWith('.yaml') || file.endsWith('.yml'));
+        const yamlFiles = await findYamlFilesRecursively(presetsDir);
         if (yamlFiles.length === 0) {
             // eslint-disable-next-line no-console
             console.log('No presets found in package.');
@@ -10458,7 +10596,7 @@ async function processContentWithMode(outFile, newContent, mode, debugLogger) {
         return newContent;
     }
     try {
-        const existing = await fs.readFile(path.resolve(outFile), "utf-8");
+        const existing = await fs.readFile(resolvePath(outFile), "utf-8");
         debugLogger?.log(`Existing file found with ${existing.length} characters`);
         if (mode === WriteMode.APPEND) {
             debugLogger?.log('Appending new content to existing content');
@@ -10577,7 +10715,7 @@ async function processSingle(options, debugLogger) {
     debugLogger.time('Content mode processing');
     const finalContent = await processContentWithMode(outFile, contentWithTitle, mode, debugLogger);
     debugLogger.timeEnd('Content mode processing');
-    const resolved = path.resolve(outFile);
+    const resolved = resolvePath(outFile);
     const writer = new MarkdownWriter();
     debugLogger.log(`Writing to output file: ${resolved}`);
     // Build front matter
@@ -10723,7 +10861,7 @@ async function handleExtractCommand(options) {
     });
     const extractOptions = {
         srcDir: resolveDefaultSrcDir(options.src),
-        outFile: options.out,
+        outFile: options.out || './out/instruction.md',
         types: parseCommaSeparated(options.type),
         languages: parseCommaSeparated(options.language),
         attrFilters: parseCommaSeparated(options.attr) || [],
@@ -10740,15 +10878,20 @@ async function handleExtractCommand(options) {
         await validateRecipeFilesExist(options.recipe);
         if (options.recipe.length === 1) {
             // Single recipe - maintain backward compatibility
-            await processRecipe(options.recipe[0], extractOptions, new ContentTracker(), debugLogger);
+            await processRecipe(options.recipe[0], extractOptions, new ContentTracker(), debugLogger, options.baseDir, options.out);
         }
         else {
             // Multiple recipes - process in order with auto-append
-            await processMultipleRecipes(options.recipe, extractOptions, debugLogger);
+            await processMultipleRecipes(options.recipe, extractOptions, debugLogger, options.baseDir, options.out);
         }
     }
     else {
         debugLogger.log('Processing single extraction without recipe');
+        // For single extraction, apply baseDir to outFile if provided
+        if (options.baseDir) {
+            extractOptions.outFile = resolveOutputPath(extractOptions.outFile, options.baseDir, undefined, undefined, undefined);
+            debugLogger.log(`Applied CLI baseDir to output file: ${extractOptions.outFile}`);
+        }
         await processSingle(extractOptions, debugLogger);
     }
 }
@@ -10765,13 +10908,13 @@ async function handleStatsCommand(options) {
 /**
  * Processes multiple recipe files in the specified order
  */
-async function processMultipleRecipes(recipePaths, baseOptions, debugLogger) {
+async function processMultipleRecipes(recipePaths, baseOptions, debugLogger, cliBaseDir, cliOutFile) {
     const contentTracker = new ContentTracker();
     debugLogger.log(`Processing ${recipePaths.length} recipes in order`);
     for (const recipePath of recipePaths) {
         try {
             debugLogger.log(`Starting processing of recipe: ${recipePath}`);
-            await processRecipe(recipePath, baseOptions, contentTracker, debugLogger);
+            await processRecipe(recipePath, baseOptions, contentTracker, debugLogger, cliBaseDir, cliOutFile);
             debugLogger.log(`Completed processing of recipe: ${recipePath}`);
         }
         catch (error) {
@@ -10784,10 +10927,103 @@ async function processMultipleRecipes(recipePaths, baseOptions, debugLogger) {
         }
     }
 }
+/**
+ * Reads template files and extracts frontmatter for inheritance
+ */
+async function loadTemplateFrontmatter(srcDir, types, languages, attrFilters, debugLogger) {
+    debugLogger?.log('Loading template frontmatter for inheritance');
+    const templateFiles = await loadAndFilterFiles(srcDir, types, languages, attrFilters, debugLogger);
+    debugLogger?.log(`Found ${templateFiles.length} template files for frontmatter inheritance`);
+    return templateFiles.map(file => file.attrs);
+}
+/**
+ * Merges frontmatter values from multiple templates according to merge rules:
+ * - Strings: concatenate with newlines, removing duplicates while preserving order
+ * - Arrays: combine all elements
+ * - Objects: later values overwrite
+ */
+function mergeTemplateFrontmatterValues(templateFrontmatters, fieldName) {
+    const values = templateFrontmatters
+        .map(fm => fm[fieldName])
+        .filter(val => val !== undefined && val !== null);
+    if (values.length === 0) {
+        return undefined;
+    }
+    if (values.length === 1) {
+        return values[0];
+    }
+    // Check if all values are strings
+    if (values.every(val => typeof val === 'string')) {
+        // Split each string by newlines, flatten, remove duplicates while preserving order
+        const allLines = [];
+        const seen = new Set();
+        for (const value of values) {
+            const lines = value.split('\n').map(line => line.trim()).filter(line => line.length > 0);
+            for (const line of lines) {
+                if (!seen.has(line)) {
+                    seen.add(line);
+                    allLines.push(line);
+                }
+            }
+        }
+        return allLines.join('\n');
+    }
+    // Check if all values are arrays
+    if (values.every(val => Array.isArray(val))) {
+        return values.flat();
+    }
+    // For objects and mixed types, use the last value
+    return values[values.length - 1];
+}
+/**
+ * Processes @ syntax in frontmatter to inherit from template files
+ */
+async function processFrontmatterInheritance(frontmatter, srcDir, types, languages, attrFilters, debugLogger) {
+    if (!frontmatter || typeof frontmatter !== 'object') {
+        return {};
+    }
+    const result = {};
+    const inheritanceFields = [];
+    // Separate inheritance fields (@ syntax) from regular fields
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (key.startsWith('@') && value === true) {
+            inheritanceFields.push(key.slice(1)); // Remove @ prefix
+            debugLogger?.log(`Found inheritance field: ${key} -> ${key.slice(1)}`);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    // If no inheritance fields, return as-is
+    if (inheritanceFields.length === 0) {
+        debugLogger?.log('No frontmatter inheritance fields found');
+        return result;
+    }
+    debugLogger?.log(`Processing ${inheritanceFields.length} inheritance fields:`, inheritanceFields);
+    // Load template frontmatters
+    const templateFrontmatters = await loadTemplateFrontmatter(srcDir, types, languages, attrFilters, debugLogger);
+    if (templateFrontmatters.length === 0) {
+        debugLogger?.log('No template files found for inheritance');
+        return result;
+    }
+    // Process each inheritance field
+    for (const fieldName of inheritanceFields) {
+        const mergedValue = mergeTemplateFrontmatterValues(templateFrontmatters, fieldName);
+        if (mergedValue !== undefined) {
+            result[fieldName] = mergedValue;
+            debugLogger?.log(`Inherited field ${fieldName}:`, mergedValue);
+        }
+        else {
+            debugLogger?.log(`No value found for inherited field ${fieldName} in templates`);
+        }
+    }
+    debugLogger?.log('Frontmatter after inheritance processing:', Object.keys(result));
+    return result;
+}
 /**
  * Processes a recipe file with multiple extract operations
  */
-async function processRecipe(recipePath, baseOptions, contentTracker, debugLogger) {
+async function processRecipe(recipePath, baseOptions, contentTracker, debugLogger, cliBaseDir, cliOutFile) {
     const resolvedPath = resolveRecipePath(recipePath);
     debugLogger?.log(`Processing recipe at path: ${resolvedPath}`);
     try {
@@ -10799,6 +11035,9 @@ async function processRecipe(recipePath, baseOptions, contentTracker, debugLogge
             throw new Error("Invalid recipe file: 'recipe' array not found");
         }
         debugLogger?.log(`Recipe contains ${data.recipe.length} items`);
+        // Read recipe config for baseDir
+        const recipeBaseDir = data.config?.baseDir;
+        debugLogger?.log('Recipe config:', { baseDir: recipeBaseDir });
         // Expand any imports in the recipe
         debugLogger?.time('Recipe import expansion');
         const expandedRecipe = await expandRecipeImports(data.recipe, resolvedPath, debugLogger);
@@ -10814,8 +11053,17 @@ async function processRecipe(recipePath, baseOptions, contentTracker, debugLogge
                 language: item.language,
                 mode: item.mode
             });
-            const outputFile = item.out || baseOptions.outFile;
-            const resolvedOutputFile = path.resolve(outputFile);
+            // Priority: CLI --out option > recipe item.out > baseOptions.outFile default
+            const itemOut = cliOutFile || item.out || baseOptions.outFile;
+            const outputFile = resolveOutputPath(itemOut, cliBaseDir, item._importBaseDir, recipeBaseDir, resolvedPath);
+            debugLogger?.log(`Resolved output path: ${itemOut} -> ${outputFile}`, {
+                cliOutFile,
+                itemOut: item.out,
+                fallback: baseOptions.outFile,
+                cliBaseDir,
+                importBaseDir: item._importBaseDir,
+                recipeBaseDir
+            });
             // Generate the content that would be written to check for duplicates
             const { srcDir, types, languages, attrFilters, title, attr, vars, envFile } = baseOptions;
             const itemTypes = item.type ? parseCommaSeparated(item.type) : types;
@@ -10867,7 +11115,7 @@ async function processRecipe(recipePath, baseOptions, contentTracker, debugLogge
                 effectiveMode = parseWriteMode(item.mode);
                 debugLogger?.log(`Using explicit mode from recipe item: ${effectiveMode}`);
             }
-            else if (localTracker.hasFile(resolvedOutputFile)) {
+            else if (localTracker.hasFile(outputFile)) {
                 // Auto-append for duplicate output files when no explicit mode
                 effectiveMode = WriteMode.APPEND;
                 debugLogger?.log(`Auto-appending due to existing output file: ${effectiveMode}`);
@@ -10875,6 +11123,10 @@ async function processRecipe(recipePath, baseOptions, contentTracker, debugLogge
             else {
                 debugLogger?.log(`Using base mode: ${effectiveMode}`);
             }
+            // Process frontmatter inheritance (@ syntax)
+            debugLogger?.time(`Frontmatter inheritance processing for item ${index + 1}`);
+            const processedFrontmatter = await processFrontmatterInheritance(item.frontmatter, baseOptions.srcDir, itemTypes, itemLanguages, combinedAttrFilters, debugLogger);
+            debugLogger?.timeEnd(`Frontmatter inheritance processing for item ${index + 1}`);
             const options = {
                 srcDir: baseOptions.srcDir,
                 outFile: outputFile,
@@ -10883,7 +11135,7 @@ async function processRecipe(recipePath, baseOptions, contentTracker, debugLogge
                 attrFilters: combinedAttrFilters,
                 title: itemTitle,
                 mode: effectiveMode,
-                attr: item.frontmatter,
+                attr: processedFrontmatter,
                 debug: baseOptions.debug,
                 vars: itemVars,
                 envFile: envFile,
@@ -10932,3 +11184,5 @@ run().catch((error) => {
     console.error("Unhandled error:", error);
     process.exit(1);
 });
+
+export { findYamlFilesRecursively };

package/dist/utils/pathExpansion.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Path expansion utility that supports tilde (~) and environment variable expansion
+ *
+ * Features:
+ * - Tilde expansion: ~/path -> /Users/username/path (Unix-like systems only)
+ * - Environment variable expansion: $HOME/path -> /Users/username/path
+ * - Environment variable expansion: ${VAR}/path -> /value/path
+ * - Complex combinations: ~/projects/${PROJECT_NAME}/file.md
+ *
+ * @param inputPath - Path to expand and resolve
+ * @returns Expanded and resolved absolute path
+ * @throws Error if required environment variables are missing
+ */
+export declare function resolvePath(inputPath: string): string;
+/**
+ * Safely resolve a path with environment variable expansion, returning the original path
+ * if expansion fails (useful for optional environment variables)
+ *
+ * @param inputPath - Path to expand and resolve
+ * @param fallbackToOriginal - If true, return path.resolve(inputPath) when expansion fails
+ * @returns Expanded and resolved absolute path, or resolved original path on failure
+ */
+export declare function resolvePathSafe(inputPath: string, fallbackToOriginal?: boolean): string;
+//# sourceMappingURL=pathExpansion.d.ts.map

package/dist/utils/pathExpansion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathExpansion.d.ts","sourceRoot":"","sources":["../../src/utils/pathExpansion.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAuCrD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,kBAAkB,GAAE,OAAc,GAAG,MAAM,CAS7F"}

package/dist/utils/pathExpansion.js

@@ -0,0 +1,67 @@
+import { homedir } from "os";
+import path from "path";
+/**
+ * Path expansion utility that supports tilde (~) and environment variable expansion
+ *
+ * Features:
+ * - Tilde expansion: ~/path -> /Users/username/path (Unix-like systems only)
+ * - Environment variable expansion: $HOME/path -> /Users/username/path
+ * - Environment variable expansion: ${VAR}/path -> /value/path
+ * - Complex combinations: ~/projects/${PROJECT_NAME}/file.md
+ *
+ * @param inputPath - Path to expand and resolve
+ * @returns Expanded and resolved absolute path
+ * @throws Error if required environment variables are missing
+ */
+export function resolvePath(inputPath) {
+    if (!inputPath || typeof inputPath !== 'string') {
+        throw new Error('Path must be a non-empty string');
+    }
+    let expandedPath = inputPath;
+    // 1. Handle tilde expansion first (Unix-like systems only)
+    if (expandedPath.startsWith('~/')) {
+        // Check if we're on Windows
+        if (process.platform === 'win32') {
+            throw new Error('Tilde (~) expansion is not supported on Windows. Use %USERPROFILE% or environment variables instead.');
+        }
+        const homeDir = homedir();
+        expandedPath = path.join(homeDir, expandedPath.slice(2));
+    }
+    else if (expandedPath === '~') {
+        if (process.platform === 'win32') {
+            throw new Error('Tilde (~) expansion is not supported on Windows. Use %USERPROFILE% or environment variables instead.');
+        }
+        expandedPath = homedir();
+    }
+    // 2. Handle environment variable expansion
+    // Support both $VAR and ${VAR} syntax
+    expandedPath = expandedPath.replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (match, bracedVar, simpleVar) => {
+        const varName = bracedVar || simpleVar;
+        const envValue = process.env[varName];
+        if (envValue === undefined) {
+            throw new Error(`Environment variable '${varName}' is not defined`);
+        }
+        return envValue;
+    });
+    // 3. Resolve to absolute path
+    return path.resolve(expandedPath);
+}
+/**
+ * Safely resolve a path with environment variable expansion, returning the original path
+ * if expansion fails (useful for optional environment variables)
+ *
+ * @param inputPath - Path to expand and resolve
+ * @param fallbackToOriginal - If true, return path.resolve(inputPath) when expansion fails
+ * @returns Expanded and resolved absolute path, or resolved original path on failure
+ */
+export function resolvePathSafe(inputPath, fallbackToOriginal = true) {
+    try {
+        return resolvePath(inputPath);
+    }
+    catch (error) {
+        if (fallbackToOriginal) {
+            return path.resolve(inputPath);
+        }
+        throw error;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aramassa/ai-rules",
-  "version": "0.1.1-npmjs.20250910072942",
+  "version": "0.1.5",
   "description": "This repository collects guidelines and instructions for developing AI agents. It contains documents covering communication rules, coding standards, testing strategies, and general operational practices.",
   "workspaces": [
     "packages/extract",
@@ -24,8 +24,10 @@
     "start:cli": "node dist/cli.js",
     "start:dev:cli": "tsx src/cli.ts",
     "test": "vitest run --environment node test",
+    "test:ci": "vitest run --environment node",
     "test:all": "npm run test --workspaces",
-    "build": "npm run --ws build && tsc -p tsconfig.build.json",
+    "build": "npm run --ws build && tsc -p tsconfig.build.json && chmod +x dist/cli.js",
+    "build:ci": "npm run --ws build && tsc -p tsconfig.build.json && chmod +x dist/cli.js",
     "build:pkg:clean": "npm run --ws clean",
     "clean": "npm run build:pkg:clean && rm -rf dist",
     "root:build": "npm run build && if [ \"$NODE_ENV\" != \"test\" ]; then rollup -c && chmod +x dist/cli.js; fi"
@@ -51,7 +53,7 @@
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.4",
     "@types/commander": "^2.12.0",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.5.2",
     "fast-glob": "^3.3.3",
     "gray-matter": "^4.0.3",
     "rollup": "^4.45.0",

package/presets/README.md

@@ -62,6 +62,31 @@ npx @aramassa/ai-rules extract --recipe presets/infrastructure-ansible.yaml --sr
 - DevOps・SRE関連プロジェクト
 - 設定管理・自動化プロジェクト
 
+### `chrome-extension.yaml`
+
+Chrome Extension（Manifest V3）開発プロジェクト向けの包括的なinstruction構成です。
+
+**含まれる内容:**
+
+- Chrome Extension Manifest V3 Development Rules - 現代的なChrome Extension開発のベストプラクティス
+- Code Quality Tools - JavaScript/Chrome Extension向けのコード品質管理
+- Package Management Rules - パッケージ管理とビルドプロセス
+- Git Rules - バージョン管理とワークフロー
+- Basic Communication Rules - 基本的なコミュニケーションルール
+
+**使用方法:**
+
+```bash
+npx @aramassa/ai-rules extract --recipe presets/chrome-extension.yaml --src artifact/instructions
+```
+
+**対象プロジェクト:**
+
+- Chrome Extension開発プロジェクト（Manifest V3）
+- JavaScript/TypeScriptベースのブラウザ拡張機能
+- Webブラウザの機能拡張・自動化プロジェクト
+- Service Worker、Content Scripts、Popup UIを含む複合アプリケーション
+
 ### `chatmodes.yaml`
 
 AI対話支援機能（chatmodes）をプロジェクトに統合するための設定です。
@@ -70,6 +95,7 @@ AI対話支援機能（chatmodes）をプロジェクトに統合するための
 
 - Instruction Improve Chatmode - プロジェクト指示の改善支援
 - Planning Chatmode - todo_plans作成支援
+- Bug Reproduce Chatmode - GitHub Issue バグ再現・調査・修正提案支援
 
 **使用方法:**