Add working directory and staging area support (#11)

* Add working directory and staging area support with pseudo-refs

Implement WORKDIR/WORKTREE and STAGED/INDEX pseudo-refs across the
extension, enabling queries against uncommitted changes:

- New git_status() table function for querying working tree status
- RefKind enum in GitContextManager to distinguish commit/workdir/index refs
- git_read() support for reading files from disk (@workdir) or index (@StaGeD)
- git_tree() support for listing files from workdir/index with untracked param
- git:// filesystem protocol support for read_text/read_csv with pseudo-refs
- @Shorthand syntax (e.g. git_tree('@workdir')) for convenience

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Address PR review feedback for dirty checks support

- Fix staged/unstaged semantics: use flag-based checks instead of pointer
  presence to avoid marking untracked files as unstaged
- Add path traversal protection via SafeWorkdirPath/GetWorkdirRoot using
  realpath canonicalization
- Check git_index_read return values at all 5 callsites
- Fix LATERAL git_status_each to return NEED_MORE_INPUT on zero rows
- Use GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH for exact path filtering
- Add binary detection for untracked files in git_tree via NUL byte sampling

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix code formatting to pass CI format check

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: teaguesterling

CMakeLists.txt

@@ -15,7 +15,7 @@ set(LOADABLE_EXTENSION_NAME ${TARGET_NAME}_loadable_extension)
 project(${TARGET_NAME})
 include_directories(src/include)
 
-set(EXTENSION_SOURCES src/duck_tails_extension.cpp src/git_filesystem.cpp src/git_functions.cpp src/git_log.cpp src/git_path.cpp src/git_utils.cpp src/git_context_manager.cpp src/git_tree.cpp src/git_parents.cpp src/git_branches.cpp src/git_tags.cpp src/git_read.cpp src/git_uri.cpp src/text_diff.cpp src/git_history.cpp)
+set(EXTENSION_SOURCES src/duck_tails_extension.cpp src/git_filesystem.cpp src/git_functions.cpp src/git_log.cpp src/git_path.cpp src/git_utils.cpp src/git_context_manager.cpp src/git_tree.cpp src/git_parents.cpp src/git_branches.cpp src/git_tags.cpp src/git_read.cpp src/git_uri.cpp src/text_diff.cpp src/git_history.cpp src/git_status.cpp)
 
 build_static_extension(${TARGET_NAME} ${EXTENSION_SOURCES})
 build_loadable_extension(${TARGET_NAME} " " ${EXTENSION_SOURCES})

src/git_context_manager.cpp

@@ -8,13 +8,14 @@ namespace duckdb {
 // GitContext Implementation
 //===--------------------------------------------------------------------===//
 
-GitContextManager::GitContext::GitContext(git_object *obj, const string &rp, const string &fp, const string &ref)
-    : resolved_object(obj), repo_path(rp), file_path(fp), final_ref(ref) {
+GitContextManager::GitContext::GitContext(git_object *obj, const string &rp, const string &fp, const string &ref,
+                                          RefKind kind)
+    : resolved_object(obj), repo_path(rp), file_path(fp), final_ref(ref), ref_kind(kind) {
 }
 
 GitContextManager::GitContext::GitContext(GitContext &&other) noexcept
     : resolved_object(other.resolved_object), repo_path(std::move(other.repo_path)),
-      file_path(std::move(other.file_path)), final_ref(std::move(other.final_ref)) {
+      file_path(std::move(other.file_path)), final_ref(std::move(other.final_ref)), ref_kind(other.ref_kind) {
 	other.resolved_object = nullptr;
 }
 
@@ -40,6 +41,11 @@ GitContextManager::GitContext GitContextManager::ProcessGitUri(const string &uri
 	try {
 		if (StringUtil::StartsWith(uri_or_path, "git://")) {
 			git_path = GitPath::Parse(uri_or_path);
+		} else if (StringUtil::StartsWith(uri_or_path, "@")) {
+			// Shorthand: @WORKDIR, @STAGED, etc. → current dir with pseudo-ref
+			string ref_part = uri_or_path.substr(1);
+			string constructed_uri = "git://.@" + ref_part;
+			git_path = GitPath::Parse(constructed_uri);
 		} else {
 			// Filesystem path - construct git URI for uniform processing
 			string constructed_uri = "git://" + uri_or_path + "@" + fallback_ref;
@@ -49,11 +55,22 @@ GitContextManager::GitContext GitContextManager::ProcessGitUri(const string &uri
 		throw IOException("GitContextManager: Failed to parse URI '%s': %s", uri_or_path, e.what());
 	}
 
-	// Phase 2: Reference Resolution (opens repo temporarily, validates, then closes)
+	// Phase 2: Reference Resolution
 	string final_ref = git_path.revision.empty() ? fallback_ref : git_path.revision;
+
+	// Check for pseudo-refs (WORKDIR/WORKTREE, STAGED/INDEX) before git_revparse
+	string upper_ref = StringUtil::Upper(final_ref);
+	if (upper_ref == "WORKDIR" || upper_ref == "WORKTREE") {
+		return GitContext(nullptr, git_path.repository_path, git_path.file_path, final_ref, RefKind::WORKDIR);
+	}
+	if (upper_ref == "STAGED" || upper_ref == "INDEX") {
+		return GitContext(nullptr, git_path.repository_path, git_path.file_path, final_ref, RefKind::INDEX);
+	}
+
+	// Normal commit ref: opens repo temporarily, validates, then closes
 	git_object *resolved_object = ValidateAndResolveReference(git_path.repository_path, final_ref);
 
-	return GitContext(resolved_object, git_path.repository_path, git_path.file_path, final_ref);
+	return GitContext(resolved_object, git_path.repository_path, git_path.file_path, final_ref, RefKind::COMMIT);
 }
 
 git_object *GitContextManager::ValidateAndResolveReference(const string &repo_path, const string &ref) {

src/git_filesystem.cpp

@@ -1,4 +1,6 @@
 #include "git_filesystem.hpp"
+#include "git_context_manager.hpp"
+#include "git_utils.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/local_file_system.hpp"
@@ -216,6 +218,70 @@ bool GitFileSystem::CanHandleFile(const string &fpath) {
 	return StringUtil::StartsWith(fpath, "git://");
 }
 
+// Check if a revision string is a pseudo-ref
+static bool IsPseudoRef(const string &revision, RefKind &out_kind) {
+	string upper = StringUtil::Upper(revision);
+	if (upper == "WORKDIR" || upper == "WORKTREE") {
+		out_kind = RefKind::WORKDIR;
+		return true;
+	}
+	if (upper == "STAGED" || upper == "INDEX") {
+		out_kind = RefKind::INDEX;
+		return true;
+	}
+	return false;
+}
+
+// Safe workdir path — delegates to shared SafeWorkdirPath for traversal protection
+// For Glob which needs the workdir root separately, use GetWorkdirRoot
+
+// Get blob content from the git index
+static string GetIndexBlobContent(const string &repo_path, const string &file_path) {
+	git_repository *repo = nullptr;
+	int error = git_repository_open_ext(&repo, repo_path.c_str(), GIT_REPOSITORY_OPEN_NO_SEARCH, nullptr);
+	if (error != 0) {
+		throw IOException("Failed to open repository '%s'", repo_path);
+	}
+
+	git_index *index = nullptr;
+	error = git_repository_index(&index, repo);
+	if (error != 0) {
+		git_repository_free(repo);
+		throw IOException("Failed to get index for repository '%s'", repo_path);
+	}
+
+	error = git_index_read(index, 0);
+	if (error != 0) {
+		git_index_free(index);
+		git_repository_free(repo);
+		throw IOException("Failed to read index for repository '%s'", repo_path);
+	}
+
+	const git_index_entry *entry = git_index_get_bypath(index, file_path.c_str(), 0);
+	if (!entry) {
+		git_index_free(index);
+		git_repository_free(repo);
+		throw IOException("File '%s' not found in staging area", file_path);
+	}
+
+	git_blob *blob = nullptr;
+	error = git_blob_lookup(&blob, repo, &entry->id);
+	if (error != 0) {
+		git_index_free(index);
+		git_repository_free(repo);
+		throw IOException("Failed to load blob from index for '%s'", file_path);
+	}
+
+	const void *content = git_blob_rawcontent(blob);
+	git_off_t size = git_blob_rawsize(blob);
+	string result(static_cast<const char *>(content), size);
+
+	git_blob_free(blob);
+	git_index_free(index);
+	git_repository_free(repo);
+	return result;
+}
+
 unique_ptr<FileHandle> GitFileSystem::OpenFile(const string &path, FileOpenFlags flags,
                                                optional_ptr<FileOpener> opener) {
 	if (flags.OpenForWriting()) {
@@ -224,6 +290,30 @@ unique_ptr<FileHandle> GitFileSystem::OpenFile(const string &path, FileOpenFlags
 
 	try {
 		auto git_path = GitPath::Parse(path);
+
+		// Check for pseudo-refs
+		RefKind ref_kind;
+		if (IsPseudoRef(git_path.revision, ref_kind)) {
+			if (ref_kind == RefKind::WORKDIR) {
+				// Delegate to LocalFileSystem
+				string abs_path = SafeWorkdirPath(git_path.repository_path, git_path.file_path);
+				LocalFileSystem local_fs;
+				auto local_handle = local_fs.OpenFile(abs_path, flags, opener);
+				int64_t file_size = local_fs.GetFileSize(*local_handle);
+				auto content = make_shared_ptr<string>();
+				content->resize(static_cast<size_t>(file_size));
+				if (file_size > 0) {
+					local_fs.Read(*local_handle, const_cast<char *>(content->data()), file_size);
+				}
+				return make_uniq<GitFileHandle>(*this, path, content, flags);
+			} else {
+				// INDEX: read from staging area
+				auto content = GetIndexBlobContent(git_path.repository_path, git_path.file_path);
+				auto content_ptr = make_shared_ptr<string>(std::move(content));
+				return make_uniq<GitFileHandle>(*this, path, content_ptr, flags);
+			}
+		}
+
 		try {
 			auto repo = OpenRepository(git_path.repository_path);
 			auto commit_obj = ResolveRevision(repo, git_path.revision);
@@ -253,6 +343,68 @@ vector<OpenFileInfo> GitFileSystem::Glob(const string &pattern, FileOpener *open
 	try {
 		auto git_path = GitPath::Parse(pattern);
 
+		RefKind ref_kind;
+		if (IsPseudoRef(git_path.revision, ref_kind)) {
+			vector<OpenFileInfo> results;
+			if (ref_kind == RefKind::WORKDIR) {
+				// Delegate glob to local filesystem within workdir
+				try {
+					string workdir_root = GetWorkdirRoot(git_path.repository_path);
+					string abs_pattern = workdir_root + git_path.file_path;
+					LocalFileSystem local_fs;
+					auto local_results = local_fs.Glob(abs_pattern, opener);
+					// Convert back to git:// URIs
+					string workdir_prefix = workdir_root;
+					for (auto &info : local_results) {
+						string rel_path = info.path;
+						if (StringUtil::StartsWith(rel_path, workdir_prefix)) {
+							rel_path = rel_path.substr(workdir_prefix.length());
+						}
+						results.emplace_back(
+						    OpenFileInfo {"git://" + git_path.repository_path + "/" + rel_path + "@WORKDIR"});
+					}
+				} catch (...) {
+					// Return empty on error
+				}
+			} else {
+				// INDEX: enumerate index entries matching pattern
+				try {
+					git_repository *repo_ptr = nullptr;
+					int error = git_repository_open_ext(&repo_ptr, git_path.repository_path.c_str(),
+					                                    GIT_REPOSITORY_OPEN_NO_SEARCH, nullptr);
+					if (error == 0) {
+						git_index *index = nullptr;
+						error = git_repository_index(&index, repo_ptr);
+						if (error == 0) {
+							if (git_index_read(index, 0) != 0) {
+								git_index_free(index);
+								git_repository_free(repo_ptr);
+								return results;
+							}
+							size_t entry_count = git_index_entrycount(index);
+							for (size_t i = 0; i < entry_count; i++) {
+								const git_index_entry *entry = git_index_get_byindex(index, i);
+								if (entry && entry->path) {
+									string entry_path(entry->path);
+									// Simple prefix match for now
+									if (git_path.file_path.empty() ||
+									    StringUtil::StartsWith(entry_path, git_path.file_path)) {
+										results.emplace_back(OpenFileInfo {"git://" + git_path.repository_path + "/" +
+										                                   entry_path + "@STAGED"});
+									}
+								}
+							}
+							git_index_free(index);
+						}
+						git_repository_free(repo_ptr);
+					}
+				} catch (...) {
+					// Return empty on error
+				}
+			}
+			return results;
+		}
+
 		try {
 			auto repo = OpenRepository(git_path.repository_path);
 			auto commit_obj = ResolveRevision(repo, git_path.revision);
@@ -275,6 +427,47 @@ bool GitFileSystem::FileExists(const string &filename, optional_ptr<FileOpener>
 	try {
 		auto git_path = GitPath::Parse(filename);
 
+		RefKind ref_kind;
+		if (IsPseudoRef(git_path.revision, ref_kind)) {
+			if (ref_kind == RefKind::WORKDIR) {
+				try {
+					string abs_path = SafeWorkdirPath(git_path.repository_path, git_path.file_path);
+					LocalFileSystem local_fs;
+					return local_fs.FileExists(abs_path);
+				} catch (...) {
+					return false;
+				}
+			} else {
+				// INDEX: check via git_index_get_bypath
+				try {
+					git_repository *repo = nullptr;
+					int error = git_repository_open_ext(&repo, git_path.repository_path.c_str(),
+					                                    GIT_REPOSITORY_OPEN_NO_SEARCH, nullptr);
+					if (error != 0) {
+						return false;
+					}
+					git_index *index = nullptr;
+					error = git_repository_index(&index, repo);
+					if (error != 0) {
+						git_repository_free(repo);
+						return false;
+					}
+					if (git_index_read(index, 0) != 0) {
+						git_index_free(index);
+						git_repository_free(repo);
+						return false;
+					}
+					const git_index_entry *entry = git_index_get_bypath(index, git_path.file_path.c_str(), 0);
+					bool exists = (entry != nullptr);
+					git_index_free(index);
+					git_repository_free(repo);
+					return exists;
+				} catch (...) {
+					return false;
+				}
+			}
+		}
+
 		try {
 			auto repo = OpenRepository(git_path.repository_path);
 			auto commit_obj = ResolveRevision(repo, git_path.revision);
@@ -287,8 +480,6 @@ bool GitFileSystem::FileExists(const string &filename, optional_ptr<FileOpener>
 			return false;
 		}
 	} catch (const IOException &e) {
-		// For repository discovery errors, we still return false for FileExists
-		// but this maintains consistency with other methods
 		return false;
 	}
 }

src/git_functions.cpp

@@ -27,6 +27,7 @@ void RegisterGitTreeFunction(ExtensionLoader &loader);
 void RegisterGitParentsFunction(ExtensionLoader &loader);
 void RegisterGitReadFunction(ExtensionLoader &loader);
 void RegisterGitUriFunction(ExtensionLoader &loader);
+void RegisterGitStatusFunction(ExtensionLoader &loader);
 
 void RegisterGitFunctions(ExtensionLoader &loader) {
 	RegisterGitLogFunction(loader);
@@ -36,6 +37,7 @@ void RegisterGitFunctions(ExtensionLoader &loader) {
 	RegisterGitParentsFunction(loader);
 	RegisterGitReadFunction(loader);
 	RegisterGitUriFunction(loader);
+	RegisterGitStatusFunction(loader);
 }
 
 } // namespace duckdb