fix: support parent directory glob patterns in imports (closes #13)

The ignore package doesn't accept paths starting with "../". When glob
patterns like @../../**/*.rs were used, relative paths were calculated
from the agent file's directory, resulting in paths like "../../target/..."
which the ignore package rejected.

Fix:
- Add extractGlobBaseDir() to determine actual search directory from glob
- Calculate relative paths from glob's base directory, not agent file's
- Load .gitignore from the correct directory

Behavioral change: glob XML path attributes now show paths relative to
the glob's base directory (e.g., "a.ts" instead of "imports/glob-test/a.ts")

Author: johnlindquist

src/__snapshots__/snapshot.test.ts.snap

@@ -67,13 +67,13 @@ Use these to implement the feature."
 exports[`Snapshot Tests Glob imports expands glob patterns to XML format 1`] = `
 "Here are all TypeScript files in the glob-test directory:
 
-<a path="imports/glob-test/a.ts">
+<a path="a.ts">
 // File a.ts
 export const A = "alpha";
 
 </a>
 
-<b path="imports/glob-test/b.ts">
+<b path="b.ts">
 // File b.ts
 export const B = "beta";
 

src/imports.test.ts

@@ -271,6 +271,54 @@ test("expandImports handles glob patterns", async () => {
   expect(result).toContain("<b path=");
 });
 
+test("expandImports handles parent directory glob patterns (issue #13)", async () => {
+  // Create a nested subdirectory structure to test parent directory globs
+  // Structure: testDir/parent-glob-test/subdir/agent.md
+  //            testDir/parent-glob-test/*.rs (files to find)
+  const parentDir = join(testDir, "parent-glob-test");
+  const subDir = join(parentDir, "subdir");
+
+  // Create the Rust files in the parent directory
+  await Bun.write(join(parentDir, "main.rs"), "fn main() {}");
+  await Bun.write(join(parentDir, "lib.rs"), "pub mod lib;");
+
+  // Create dummy file in subdir to ensure it exists
+  await Bun.write(join(subDir, "dummy.md"), "");
+
+  // Run glob from subdir looking at parent with ../*.rs
+  const content = "@../*.rs";
+  const result = await expandImports(content, subDir);
+
+  // Should include both .rs files
+  expect(result).toContain("fn main() {}");
+  expect(result).toContain("pub mod lib;");
+  // Should be formatted as XML
+  expect(result).toContain("main.rs");
+  expect(result).toContain("lib.rs");
+});
+
+test("expandImports handles deep parent directory glob patterns", async () => {
+  // Test ../../**/*.rs pattern (2 levels up)
+  const deepParent = join(testDir, "deep-parent");
+  const level1 = join(deepParent, "level1");
+  const level2 = join(level1, "level2");
+
+  // Create files at the top level
+  await Bun.write(join(deepParent, "top.rs"), "// top level");
+  await Bun.write(join(deepParent, "nested/inner.rs"), "// nested");
+
+  // Create dummy to ensure level2 exists
+  await Bun.write(join(level2, "dummy.md"), "");
+
+  // Run glob from level2 looking 2 levels up with **/*.rs
+  const content = "@../../**/*.rs";
+  const result = await expandImports(content, level2);
+
+  // Should include both .rs files
+  expect(result).toContain("// top level");
+  expect(result).toContain("// nested");
+});
+
 // Canonical path tests
 test("toCanonicalPath resolves symlinks to real path", async () => {
   // Create a real file

src/imports.ts

@@ -652,6 +652,32 @@ function formatFilesAsXml(files: Array<{ path: string; content: string }>): stri
   }).join("\n\n");
 }
 
+/**
+ * Extract the static prefix from a glob pattern (everything before the first wildcard)
+ * Returns the directory portion that can be resolved as a path.
+ */
+function extractGlobBaseDir(pattern: string, currentFileDir: string): string {
+  // Find the first glob character
+  const firstWildcard = Math.min(
+    ...[pattern.indexOf('*'), pattern.indexOf('?'), pattern.indexOf('[')]
+      .filter(i => i !== -1)
+      .concat([pattern.length]) // fallback if no wildcards
+  );
+
+  // Get everything before the wildcard
+  const staticPrefix = pattern.slice(0, firstWildcard);
+
+  // Find the last directory separator in the static prefix
+  const lastSlash = staticPrefix.lastIndexOf('/');
+  const dirPart = lastSlash === -1 ? '' : staticPrefix.slice(0, lastSlash);
+
+  // Resolve the directory part
+  if (pattern.startsWith('/')) {
+    return dirPart || '/';
+  }
+  return resolve(currentFileDir, dirPart || '.');
+}
+
 /**
  * Process a glob import pattern
  */
@@ -661,30 +687,39 @@ async function processGlobImport(
   verbose: boolean
 ): Promise<string> {
   const resolvedPattern = expandTilde(pattern);
-  const baseDir = resolvedPattern.startsWith("/") ? "/" : currentFileDir;
 
-  // For relative patterns, we need to resolve from the current directory
-  const globPattern = resolvedPattern.startsWith("/")
-    ? resolvedPattern
-    : resolve(currentFileDir, resolvedPattern).replace(currentFileDir + "/", "");
+  // Calculate the actual base directory for the glob
+  // This handles patterns like "../../**/*.rs" by resolving the static prefix
+  const globBaseDir = extractGlobBaseDir(resolvedPattern, currentFileDir);
 
   if (verbose) {
-    console.error(`[imports] Glob pattern: ${globPattern} in ${currentFileDir}`);
+    console.error(`[imports] Glob pattern: ${resolvedPattern} (base: ${globBaseDir})`);
   }
 
-  // Load gitignore
-  const ig = await loadGitignore(currentFileDir);
+  // Load gitignore from the glob's base directory, not the agent file's directory
+  const ig = await loadGitignore(globBaseDir);
 
   // Collect matching files
+  // Use the resolved base directory as cwd for proper pattern matching
   const glob = new Glob(resolvedPattern.startsWith("/") ? resolvedPattern : pattern.replace(/^\.\//, ""));
   const files: Array<{ path: string; content: string }> = [];
   let totalChars = 0;
 
   const skippedBinaryFiles: string[] = [];
 
   for await (const file of glob.scan({ cwd: currentFileDir, absolute: true, onlyFiles: true })) {
-    // Check gitignore
-    const relativePath = relative(currentFileDir, file);
+    // Check gitignore - calculate relative path from the glob's base directory
+    // This ensures paths don't start with "../" which the ignore package can't handle
+    const relativePath = relative(globBaseDir, file);
+
+    // Skip paths that are still outside the glob base (shouldn't happen, but safety check)
+    if (relativePath.startsWith('..')) {
+      if (verbose) {
+        console.error(`[imports] Skipping file outside glob base: ${file}`);
+      }
+      continue;
+    }
+
     if (ig.ignores(relativePath)) {
       continue;
     }