feat(glob): add regex-based glob pattern matching

Implement more robust glob pattern matching by converting patterns to regular expressions. This supports *, ?, and [] syntax for more flexible file matching.

refactor(chained): support loading prompts from individual files

Extend chained prompt loading functionality to handle both directories and individual .md files, improving flexibility in prompt organization.

Author: moazbuilds

src/agents/runner/chained.ts

@@ -87,6 +87,34 @@ function filenameToName(filename: string): string {
   return filename.replace(/\.md$/i, '');
 }
 
+/**
+ * Load a single chained prompt from a file
+ */
+async function loadPromptFromFile(
+  filePath: string,
+  projectRoot: string
+): Promise<ChainedPrompt | null> {
+  const absolutePath = path.isAbsolute(filePath)
+    ? filePath
+    : path.resolve(projectRoot, filePath);
+
+  try {
+    const rawContent = await fs.readFile(absolutePath, 'utf-8');
+    const { frontmatter, body } = parseFrontmatter(rawContent);
+    const filename = path.basename(absolutePath);
+
+    debug(`Loaded chained prompt from file: ${absolutePath}`);
+    return {
+      name: frontmatter.name || filenameToName(filename),
+      label: frontmatter.description || filenameToLabel(filename),
+      content: body.trim(),
+    };
+  } catch (err) {
+    debug(`Failed to read chained prompt file ${absolutePath}: ${err}`);
+    return null;
+  }
+}
+
 /**
  * Load chained prompts from a single folder
  */
@@ -144,6 +172,37 @@ async function loadPromptsFromFolder(
   return prompts;
 }
 
+/**
+ * Load chained prompts from a path (file or folder)
+ */
+async function loadPromptsFromPath(
+  inputPath: string,
+  projectRoot: string
+): Promise<ChainedPrompt[]> {
+  const absolutePath = path.isAbsolute(inputPath)
+    ? inputPath
+    : path.resolve(projectRoot, inputPath);
+
+  try {
+    const stat = await fs.stat(absolutePath);
+
+    if (stat.isFile() && absolutePath.endsWith('.md')) {
+      // Single file
+      const prompt = await loadPromptFromFile(absolutePath, projectRoot);
+      return prompt ? [prompt] : [];
+    } else if (stat.isDirectory()) {
+      // Folder
+      return loadPromptsFromFolder(absolutePath, projectRoot);
+    } else {
+      debug(`chainedPromptsPath is neither a .md file nor directory: ${absolutePath}`);
+      return [];
+    }
+  } catch {
+    debug(`chainedPromptsPath does not exist: ${absolutePath}`);
+    return [];
+  }
+}
+
 /**
  * Type guard for conditional path entry
  */
@@ -168,11 +227,11 @@ function getPath(entry: ChainedPathEntry): string {
 }
 
 /**
- * Load chained prompts from one or more folders
+ * Load chained prompts from one or more paths (files or folders)
  * Files are sorted by filename within each folder (01-first.md, 02-second.md, etc.)
- * When multiple folders are provided, prompts are loaded in folder order
+ * When multiple paths are provided, prompts are loaded in path order
  *
- * @param chainedPromptsPath - Path or array of paths to folder(s) containing .md files
+ * @param chainedPromptsPath - Path or array of paths to file(s) or folder(s) containing .md files
  * @param projectRoot - Project root for resolving relative paths
  * @param selectedConditions - User-selected conditions for filtering conditional paths
  * @returns Array of ChainedPrompt objects sorted by filename within each folder
@@ -193,8 +252,8 @@ export async function loadChainedPrompts(
       continue;
     }
 
-    const folderPath = getPath(entry);
-    const prompts = await loadPromptsFromFolder(folderPath, projectRoot);
+    const inputPath = getPath(entry);
+    const prompts = await loadPromptsFromPath(inputPath, projectRoot);
     allPrompts.push(...prompts);
   }
 

src/shared/prompts/content/glob.ts

@@ -9,6 +9,46 @@ export function isGlobPattern(filePath: string): boolean {
   return filePath.includes('*') || filePath.includes('?') || filePath.includes('[');
 }
 
+/**
+ * Converts a glob pattern to a RegExp
+ * Supports: * (any chars), ? (single char), [abc] (char class)
+ * Examples:
+ *   *.md -> matches file.md
+ *   product-brief-*.md -> matches product-brief-2025-12-11.md
+ *   file?.txt -> matches file1.txt
+ */
+function globToRegex(pattern: string): RegExp {
+  let regex = '';
+  let i = 0;
+
+  while (i < pattern.length) {
+    const char = pattern[i];
+
+    if (char === '*') {
+      regex += '.*';
+    } else if (char === '?') {
+      regex += '.';
+    } else if (char === '[') {
+      // Find closing bracket
+      const closeIdx = pattern.indexOf(']', i);
+      if (closeIdx !== -1) {
+        regex += pattern.slice(i, closeIdx + 1);
+        i = closeIdx;
+      } else {
+        regex += '\\[';
+      }
+    } else if ('.^$+{}()|\\'.includes(char)) {
+      // Escape regex special chars
+      regex += '\\' + char;
+    } else {
+      regex += char;
+    }
+    i++;
+  }
+
+  return new RegExp(`^${regex}$`);
+}
+
 /**
  * Matches files against a glob pattern
  * Returns an array of absolute file paths sorted alphabetically
@@ -28,6 +68,7 @@ export async function matchGlobPattern(
   try {
     const files = await readdir(directory);
     const matchedFiles: string[] = [];
+    const regex = globToRegex(filePattern);
 
     for (const file of files) {
       const fullPath = path.join(directory, file);
@@ -40,13 +81,8 @@ export async function matchGlobPattern(
         continue;
       }
 
-      // Simple pattern matching for *.ext patterns
-      if (filePattern.startsWith('*')) {
-        const extension = filePattern.substring(1); // e.g., ".md"
-        if (file.endsWith(extension)) {
-          matchedFiles.push(fullPath);
-        }
-      } else if (filePattern === file) {
+      // Match against glob pattern regex
+      if (regex.test(file)) {
         matchedFiles.push(fullPath);
       }
     }