gitforest 0.1.0

package/src/db/index.ts

@@ -0,0 +1,147 @@
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { join } from "path";
+import { homedir } from "os";
+import * as schema from "./schema.ts";
+
+/**
+ * Database instance type for dependency injection
+ */
+export type DbInstance = ReturnType<typeof drizzle>;
+
+let db: DbInstance | null = null;
+let sqliteDb: Database | null = null;
+
+/**
+ * Get the database file path
+ */
+export function getDbPath(): string {
+  const xdg = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+  return join(xdg, "gitforest", "cache.db");
+}
+
+/**
+ * Initialize the database connection and create tables if needed
+ */
+export async function initDb(): Promise<ReturnType<typeof drizzle>> {
+  if (db) return db;
+
+  const dbPath = getDbPath();
+  const dbDir = join(dbPath, "..");
+
+  // Ensure directory exists
+  await Bun.$`mkdir -p ${dbDir}`.quiet();
+
+  // Create SQLite connection
+  sqliteDb = new Database(dbPath);
+
+  // Enable WAL mode for better concurrent access
+  sqliteDb.exec("PRAGMA journal_mode = WAL");
+
+  // Create tables if they don't exist
+  sqliteDb.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL UNIQUE,
+      type TEXT NOT NULL,
+      project_marker TEXT,
+      status_json TEXT,
+      submodule_json TEXT,
+      last_scanned INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS remote_status (
+      project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+      last_fetched INTEGER,
+      unpulled_commits INTEGER,
+      remote_last_activity INTEGER,
+      remote_url TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS github_repos (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      full_name TEXT NOT NULL UNIQUE,
+      owner TEXT NOT NULL,
+      description TEXT,
+      html_url TEXT,
+      ssh_url TEXT,
+      clone_url TEXT,
+      is_private INTEGER,
+      is_archived INTEGER,
+      is_fork INTEGER,
+      pushed_at INTEGER,
+      updated_at INTEGER,
+      default_branch TEXT,
+      language TEXT,
+      size INTEGER,
+      stargazers_count INTEGER,
+      forks_count INTEGER,
+      open_issues_count INTEGER,
+      watchers_count INTEGER,
+      topics TEXT,
+      license TEXT,
+      has_issues INTEGER,
+      has_wiki INTEGER,
+      has_discussions INTEGER,
+      last_fetched INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS config_cache (
+      key TEXT PRIMARY KEY,
+      value TEXT,
+      updated_at INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_projects_path ON projects(path);
+    CREATE INDEX IF NOT EXISTS idx_projects_type ON projects(type);
+    CREATE INDEX IF NOT EXISTS idx_github_repos_owner ON github_repos(owner);
+    CREATE INDEX IF NOT EXISTS idx_github_repos_fetched ON github_repos(last_fetched);
+  `);
+
+  // Create Drizzle instance
+  db = drizzle(sqliteDb, { schema });
+
+  return db;
+}
+
+/**
+ * Close the database connection
+ */
+export function closeDb(): void {
+  if (sqliteDb) {
+    sqliteDb.close();
+    sqliteDb = null;
+    db = null;
+  }
+}
+
+/**
+ * Get the database instance (must call initDb first)
+ */
+export function getDb(): ReturnType<typeof drizzle> {
+  if (!db) {
+    throw new Error("Database not initialized. Call initDb() first.");
+  }
+  return db;
+}
+
+/**
+ * Clear all cached data
+ */
+export async function clearCache(): Promise<void> {
+  try {
+    const database = await initDb();
+    
+    // Run both deletes in parallel for better performance
+    await Promise.all([
+      database.delete(schema.projects).run(),
+      database.delete(schema.remoteStatus).run()
+    ]);
+  } catch (error) {
+    throw new Error(`Failed to clear cache: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export { schema };

package/src/db/schema.ts

@@ -0,0 +1,70 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+
+/**
+ * Projects table - caches scanned project information
+ */
+export const projects = sqliteTable("projects", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  path: text("path").notNull().unique(),
+  type: text("type").notNull(), // 'git' | 'git-submodule' | 'non-git'
+  projectMarker: text("project_marker"), // e.g., 'package.json', 'Cargo.toml'
+  statusJson: text("status_json"), // JSON serialized GitStatus
+  submoduleJson: text("submodule_json"), // JSON serialized SubmoduleInfo
+  lastScanned: integer("last_scanned", { mode: "timestamp" }),
+});
+
+/**
+ * Remote status table - caches GitHub/remote info separately
+ * (updated less frequently via background fetch)
+ */
+export const remoteStatus = sqliteTable("remote_status", {
+  projectId: text("project_id")
+    .primaryKey()
+    .references(() => projects.id, { onDelete: "cascade" }),
+  lastFetched: integer("last_fetched", { mode: "timestamp" }),
+  unpulledCommits: integer("unpulled_commits"),
+  remoteLastActivity: integer("remote_last_activity", { mode: "timestamp" }),
+  remoteUrl: text("remote_url"),
+});
+
+/**
+ * GitHub repos cache - stores fetched GitHub repository data
+ */
+export const githubRepos = sqliteTable("github_repos", {
+  id: integer("id").primaryKey(),
+  name: text("name").notNull(),
+  fullName: text("full_name").notNull().unique(),
+  owner: text("owner").notNull(),
+  description: text("description"),
+  htmlUrl: text("html_url"),
+  sshUrl: text("ssh_url"),
+  cloneUrl: text("clone_url"),
+  isPrivate: integer("is_private", { mode: "boolean" }),
+  isArchived: integer("is_archived", { mode: "boolean" }),
+  isFork: integer("is_fork", { mode: "boolean" }),
+  pushedAt: integer("pushed_at", { mode: "timestamp" }),
+  updatedAt: integer("updated_at", { mode: "timestamp" }),
+  defaultBranch: text("default_branch"),
+  language: text("language"),
+  size: integer("size"),
+  stargazersCount: integer("stargazers_count"),
+  forksCount: integer("forks_count"),
+  openIssuesCount: integer("open_issues_count"),
+  watchersCount: integer("watchers_count"),
+  topics: text("topics"), // JSON array
+  license: text("license"), // License name or null
+  hasIssues: integer("has_issues", { mode: "boolean" }),
+  hasWiki: integer("has_wiki", { mode: "boolean" }),
+  hasDiscussions: integer("has_discussions", { mode: "boolean" }),
+  lastFetched: integer("last_fetched", { mode: "timestamp" }),
+});
+
+/**
+ * Config cache - stores last known config hash to detect changes
+ */
+export const configCache = sqliteTable("config_cache", {
+  key: text("key").primaryKey(),
+  value: text("value"),
+  updatedAt: integer("updated_at", { mode: "timestamp" }),
+});

package/src/git/commands.ts

@@ -0,0 +1,283 @@
+import { $ } from "bun";
+import { debugError } from "../utils/debug.ts";
+
+/**
+ * Check if a directory is a git repository
+ */
+export async function isGitRepo(path: string): Promise<boolean> {
+  try {
+    await $`git -C ${path} rev-parse --is-inside-work-tree`.quiet();
+    return true;
+  } catch (error) {
+    debugError("git/commands", `isGitRepo failed for ${path}`, error);
+    return false;
+  }
+}
+
+/**
+ * Get the root directory of a git repository
+ */
+export async function getGitRoot(path: string): Promise<string | null> {
+  try {
+    const result = await $`git -C ${path} rev-parse --show-toplevel`.quiet().text();
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get porcelain status output (machine-parseable)
+ */
+export async function getGitStatusPorcelain(path: string): Promise<string> {
+  try {
+    return await $`git -C ${path} status --porcelain`.quiet().text();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Get the current branch name
+ */
+export async function getCurrentBranch(path: string): Promise<string> {
+  try {
+    const result = await $`git -C ${path} rev-parse --abbrev-ref HEAD`.quiet().text();
+    return result.trim();
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Get the tracking branch (upstream)
+ */
+export async function getTrackingBranch(path: string): Promise<string | null> {
+  try {
+    const result = await $`git -C ${path} rev-parse --abbrev-ref @{u}`.quiet().text();
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Count unpushed commits
+ */
+export async function countUnpushedCommits(path: string): Promise<number> {
+  try {
+    const result = await $`git -C ${path} rev-list --count @{u}..HEAD`.quiet().text();
+    return parseInt(result.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Count unpulled commits
+ */
+export async function countUnpulledCommits(path: string): Promise<number> {
+  try {
+    const result = await $`git -C ${path} rev-list --count HEAD..@{u}`.quiet().text();
+    return parseInt(result.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Get the remote origin URL
+ */
+export async function getRemoteUrl(path: string, remote = "origin"): Promise<string | null> {
+  try {
+    const result = await $`git -C ${path} config --get remote.${remote}.url`.quiet().text();
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the last commit date
+ */
+export async function getLastCommitDate(path: string): Promise<Date | null> {
+  try {
+    const result = await $`git -C ${path} log -1 --format=%ai`.quiet().text();
+    const dateStr = result.trim();
+    if (!dateStr) return null;
+    return new Date(dateStr);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the last commit date from a remote branch (after fetch)
+ */
+export async function getRemoteLastCommitDate(
+  path: string,
+  remoteBranch = "origin/main"
+): Promise<Date | null> {
+  try {
+    const result = await $`git -C ${path} log -1 --format=%ai ${remoteBranch}`.quiet().text();
+    const dateStr = result.trim();
+    if (!dateStr) return null;
+    return new Date(dateStr);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Initialize a new git repository
+ */
+export async function initGit(path: string): Promise<boolean> {
+  try {
+    await $`git -C ${path} init`.quiet();
+    return true;
+  } catch (error) {
+    debugError("git/commands", `initGit failed for ${path}`, error);
+    return false;
+  }
+}
+
+/**
+ * Add a remote
+ */
+export async function addRemote(path: string, url: string, name = "origin"): Promise<boolean> {
+  try {
+    await $`git -C ${path} remote add ${name} ${url}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Fetch from remote
+ */
+export async function fetchRemote(path: string, remote = "origin"): Promise<boolean> {
+  try {
+    await $`git -C ${path} fetch ${remote}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Fetch all remotes
+ */
+export async function fetchAll(path: string): Promise<boolean> {
+  try {
+    await $`git -C ${path} fetch --all`.quiet();
+    return true;
+  } catch (error) {
+    debugError("git/commands", `fetchAll failed for ${path}`, error);
+    return false;
+  }
+}
+
+/**
+ * Pull from remote (fast-forward only)
+ */
+export async function pull(path: string): Promise<boolean> {
+  try {
+    await $`git -C ${path} pull --ff-only`.quiet();
+    return true;
+  } catch (error) {
+    debugError("git/commands", `pull failed for ${path}`, error);
+    return false;
+  }
+}
+
+/**
+ * Push to remote
+ */
+export async function push(path: string, setUpstream = false): Promise<boolean> {
+  try {
+    if (setUpstream) {
+      const branch = await getCurrentBranch(path);
+      await $`git -C ${path} push -u origin ${branch}`.quiet();
+    } else {
+      await $`git -C ${path} push`.quiet();
+    }
+    return true;
+  } catch (error) {
+    debugError("git/commands", `push failed for ${path}`, error);
+    return false;
+  }
+}
+
+/**
+ * List submodules with their status
+ */
+export async function listSubmodules(path: string): Promise<
+  Array<{
+    path: string;
+    commit: string;
+    status: "-" | "+" | " " | "U";
+  }>
+> {
+  try {
+    const result = await $`git -C ${path} submodule status`.quiet().text();
+    const lines = result.trim().split("\n").filter(Boolean);
+
+    return lines.map((line) => {
+      // Format: [-+U ]<commit> <path> [(describe)]
+      const statusChar = line[0] as "-" | "+" | " " | "U";
+      const rest = line.slice(1).trim();
+      const parts = rest.split(" ");
+      const commit = parts[0] || "";
+      const subPath = parts[1] || "";
+
+      return {
+        path: subPath,
+        commit: commit,
+        status: statusChar,
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if path is a submodule
+ */
+export async function isSubmodule(path: string): Promise<boolean> {
+  try {
+    const result = await $`git -C ${path} rev-parse --show-superproject-working-tree`
+      .quiet()
+      .text();
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the parent repository path for a submodule
+ */
+export async function getSubmoduleParent(path: string): Promise<string | null> {
+  try {
+    const result = await $`git -C ${path} rev-parse --show-superproject-working-tree`
+      .quiet()
+      .text();
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if repository has any commits
+ */
+export async function hasCommits(path: string): Promise<boolean> {
+  try {
+    const result = await $`git -C ${path} rev-parse HEAD`.quiet();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}

package/src/git/index.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./service.js";

package/src/git/operations.ts

@@ -0,0 +1,93 @@
+import type { OperationResult, BatchResult, Project } from "../types/index.ts";
+import type { GitService } from "../services/git.ts";
+import { bunGitService } from "../services/git.ts";
+import { getGitStatus } from "./status.ts";
+import { errorToString } from "../utils/errors.ts";
+import { chunk } from "../utils/array.ts";
+
+/**
+ * Initialize git in a directory
+ */
+export async function initGitInProject(
+  path: string,
+  gitService: GitService = bunGitService
+): Promise<OperationResult> {
+  return await gitService.init(path);
+}
+
+/**
+ * Pull changes for a single project
+ */
+export async function pullProject(
+  path: string,
+  gitService: GitService = bunGitService
+): Promise<OperationResult> {
+  return await gitService.pull(path);
+}
+
+/**
+ * Push changes for a single project
+ */
+export async function pushProject(
+  path: string,
+  setUpstream = false,
+  gitService: GitService = bunGitService
+): Promise<OperationResult> {
+  return await gitService.push(path, setUpstream);
+}
+
+/**
+ * Fetch all remotes for a single project
+ */
+export async function fetchProject(
+  path: string,
+  gitService: GitService = bunGitService
+): Promise<OperationResult> {
+  return await gitService.fetchAll(path);
+}
+
+/**
+ * Add a remote to a project
+ */
+export async function addRemoteToProject(
+  path: string,
+  url: string,
+  name = "origin",
+  gitService: GitService = bunGitService
+): Promise<OperationResult> {
+  return await gitService.addRemote(path, url, name);
+}
+
+
+/**
+ * Refresh status for multiple projects
+ */
+export async function refreshProjectStatuses(
+  projects: Project[],
+  concurrency = 10,
+  gitService: GitService = bunGitService
+): Promise<Map<string, Project>> {
+  const gitProjects = projects.filter((p) => p.type !== "non-git");
+  const results = new Map<string, Project>();
+
+  const batches = chunk(gitProjects, concurrency);
+
+  for (const batch of batches) {
+    const updates = await Promise.all(
+      batch.map(async (p) => {
+        try {
+          const status = await getGitStatus(p.path, gitService);
+          return { ...p, status, lastScanned: new Date() };
+        } catch {
+          return p;
+        }
+      })
+    );
+
+    for (const p of updates) {
+      results.set(p.id, p);
+    }
+  }
+
+  return results;
+}