glab-agent 0.1.0

package/src/local-agent/wiki-sync.ts

@@ -0,0 +1,290 @@
+import { mkdir, readdir, stat, copyFile, writeFile, readFile, unlink } from "node:fs/promises";
+import path from "node:path";
+
+export const WIKI_DIR_NAME = "wiki";
+
+const LOCK_FILE_NAME = ".lock";
+const LOCK_STALE_MS = 5 * 60 * 1000; // 5 minutes
+
+interface LockEntry {
+  pid: number;
+  timestamp: number;
+}
+
+export interface WikiSyncLogger {
+  info(msg: string): void;
+  warn(msg: string): void;
+}
+
+/**
+ * Returns the path to the wiki directory inside .glab-agent/.
+ */
+export function wikiPath(repoRoot: string): string {
+  return path.join(repoRoot, ".glab-agent", WIKI_DIR_NAME);
+}
+
+// ---------------------------------------------------------------------------
+// Lock helpers
+// ---------------------------------------------------------------------------
+
+async function acquireLock(wikiDir: string): Promise<boolean> {
+  const lockFile = path.join(wikiDir, LOCK_FILE_NAME);
+  try {
+    // Check for existing lock
+    try {
+      const raw = await readFile(lockFile, "utf8");
+      const entry: LockEntry = JSON.parse(raw);
+      const age = Date.now() - entry.timestamp;
+      if (age <= LOCK_STALE_MS) {
+        // Lock is fresh — not ours to take
+        return false;
+      }
+      // Stale lock — delete it and continue
+      await unlink(lockFile).catch(() => { /* ignore */ });
+    } catch {
+      // No lock file or unreadable — proceed to create
+    }
+
+    const entry: LockEntry = { pid: process.pid, timestamp: Date.now() };
+    await writeFile(lockFile, JSON.stringify(entry), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function releaseLock(wikiDir: string): Promise<void> {
+  const lockFile = path.join(wikiDir, LOCK_FILE_NAME);
+  try {
+    await unlink(lockFile);
+  } catch { /* ignore */ }
+}
+
+// ---------------------------------------------------------------------------
+// Recursive file list helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Recursively collect all file paths under `dir`, returned as paths relative to `dir`.
+ */
+async function listFilesRecursive(dir: string): Promise<string[]> {
+  const results: string[] = [];
+  let entries: string[];
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return results;
+  }
+
+  for (const entry of entries) {
+    if (entry === LOCK_FILE_NAME) continue; // never copy lock file
+    const full = path.join(dir, entry);
+    let s;
+    try {
+      s = await stat(full);
+    } catch {
+      continue;
+    }
+    if (s.isDirectory()) {
+      const sub = await listFilesRecursive(full);
+      for (const rel of sub) {
+        results.push(path.join(entry, rel));
+      }
+    } else {
+      results.push(entry);
+    }
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Pre-run: copy `.glab-agent/wiki/` from main repo into the agent worktree.
+ * Creates the destination wiki directory as needed.
+ * Returns the number of files copied, or 0 if the source wiki dir does not exist.
+ * Never throws — logs warnings on I/O errors.
+ */
+export async function syncWikiToWorktree(
+  repoRoot: string,
+  worktreePath: string,
+  logger?: WikiSyncLogger
+): Promise<number> {
+  const srcDir = wikiPath(repoRoot);
+  const destDir = wikiPath(worktreePath);
+
+  // Check source exists
+  try {
+    const s = await stat(srcDir);
+    if (!s.isDirectory()) return 0;
+  } catch {
+    return 0;
+  }
+
+  let count = 0;
+  try {
+    const files = await listFilesRecursive(srcDir);
+
+    for (const rel of files) {
+      const src = path.join(srcDir, rel);
+      const dest = path.join(destDir, rel);
+      try {
+        await mkdir(path.dirname(dest), { recursive: true });
+        await copyFile(src, dest);
+        count++;
+      } catch (err) {
+        logger?.warn(`wiki-sync: failed to copy ${rel} to worktree: ${String(err)}`);
+      }
+    }
+  } catch (err) {
+    logger?.warn(`wiki-sync: unexpected error during syncWikiToWorktree: ${String(err)}`);
+  }
+
+  if (count > 0) {
+    logger?.info(`wiki-sync: copied ${count} wiki file(s) to worktree`);
+  }
+  return count;
+}
+
+/**
+ * Post-run: copy new/modified wiki files from the agent worktree back to the main repo.
+ * Only copies files whose mtime in the worktree is newer than in the main repo (or absent).
+ * Never deletes files in the main repo.
+ * Uses a lockfile to prevent concurrent writes.
+ * Returns the number of files synced back, or 0 if the worktree wiki dir does not exist.
+ * Never throws — logs warnings on I/O errors.
+ */
+export async function syncWikiFromWorktree(
+  worktreePath: string,
+  repoRoot: string,
+  logger?: WikiSyncLogger
+): Promise<number> {
+  const srcDir = wikiPath(worktreePath);
+  const destDir = wikiPath(repoRoot);
+
+  // Check source exists
+  try {
+    const s = await stat(srcDir);
+    if (!s.isDirectory()) return 0;
+  } catch {
+    return 0;
+  }
+
+  // Ensure destination wiki dir exists before acquiring lock
+  try {
+    await mkdir(destDir, { recursive: true });
+  } catch (err) {
+    logger?.warn(`wiki-sync: failed to create wiki dir in main repo: ${String(err)}`);
+    return 0;
+  }
+
+  // Acquire lock
+  const locked = await acquireLock(destDir);
+  if (!locked) {
+    logger?.warn("wiki-sync: could not acquire lock for wiki sync — skipping");
+    return 0;
+  }
+
+  let count = 0;
+  try {
+    const files = await listFilesRecursive(srcDir);
+
+    for (const rel of files) {
+      const src = path.join(srcDir, rel);
+      const dest = path.join(destDir, rel);
+
+      try {
+        const srcStat = await stat(src);
+
+        // Compare mtime with destination (if it exists)
+        let destMtime = 0;
+        try {
+          const destStat = await stat(dest);
+          destMtime = destStat.mtimeMs;
+        } catch {
+          // Destination does not exist — always copy
+        }
+
+        if (srcStat.mtimeMs > destMtime) {
+          await mkdir(path.dirname(dest), { recursive: true });
+          await copyFile(src, dest);
+          count++;
+        }
+      } catch (err) {
+        logger?.warn(`wiki-sync: failed to sync ${rel} back to main repo: ${String(err)}`);
+      }
+    }
+  } catch (err) {
+    logger?.warn(`wiki-sync: unexpected error during syncWikiFromWorktree: ${String(err)}`);
+  } finally {
+    await releaseLock(destDir);
+  }
+
+  if (count > 0) {
+    logger?.info(`wiki-sync: synced ${count} wiki file(s) back to main repo`);
+  }
+  return count;
+}
+
+/**
+ * Initialize the wiki directory structure in the main repo with scaffold files.
+ * Creates `.glab-agent/wiki/` and subdirs (patterns/, gotchas/, decisions/, runbooks/).
+ * Creates `index.md` and `log.md` only if they do not already exist.
+ */
+export async function initWikiDir(repoRoot: string): Promise<void> {
+  const base = wikiPath(repoRoot);
+  const subdirs = ["patterns", "gotchas", "decisions", "runbooks"];
+
+  try {
+    await mkdir(base, { recursive: true });
+    for (const sub of subdirs) {
+      await mkdir(path.join(base, sub), { recursive: true });
+    }
+  } catch (err) {
+    throw new Error(`wiki-sync: failed to create wiki directory structure: ${String(err)}`);
+  }
+
+  const indexPath = path.join(base, "index.md");
+  const indexContent = `# Knowledge Wiki
+
+> Agent 自动维护的项目知识库。每个条目一行摘要，按需深入。
+
+## Patterns
+
+## Gotchas
+
+## Decisions
+
+## Runbooks
+`;
+
+  try {
+    await stat(indexPath);
+    // File exists — do not overwrite
+  } catch {
+    try {
+      await writeFile(indexPath, indexContent, "utf8");
+    } catch (err) {
+      throw new Error(`wiki-sync: failed to write index.md: ${String(err)}`);
+    }
+  }
+
+  const logPath = path.join(base, "log.md");
+  const logContent = `# Knowledge Log
+
+> 时间线记录，append-only。
+`;
+
+  try {
+    await stat(logPath);
+    // File exists — do not overwrite
+  } catch {
+    try {
+      await writeFile(logPath, logContent, "utf8");
+    } catch (err) {
+      throw new Error(`wiki-sync: failed to write log.md: ${String(err)}`);
+    }
+  }
+}

package/src/local-agent/worktree-manager.ts

@@ -0,0 +1,141 @@
+import { execFile } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export interface WorktreeInfo {
+  branch: string;
+  worktreePath: string;
+}
+
+interface WorktreeManagerOptions {
+  repoPath: string;
+  worktreeRoot: string;
+  execFileImpl?: typeof execFileAsync;
+}
+
+export function slugifyTitle(title: string): string {
+  const slug = title
+    .normalize("NFKD")
+    .replace(/[^\w\s-]/g, "")
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  return (slug || "task").slice(0, 48);
+}
+
+export function branchNameForIssue(issueIid: number, title: string): string {
+  return `agent/issue-${issueIid}-${slugifyTitle(title)}`;
+}
+
+export function worktreePathForIssue(worktreeRoot: string, issueIid: number, title: string): string {
+  return path.join(worktreeRoot, `issue-${issueIid}-${slugifyTitle(title)}`);
+}
+
+export class WorktreeManager {
+  private readonly repoPath: string;
+
+  private readonly worktreeRoot: string;
+
+  private readonly execFileImpl: typeof execFileAsync;
+
+  constructor(options: WorktreeManagerOptions) {
+    this.repoPath = options.repoPath;
+    this.worktreeRoot = options.worktreeRoot;
+    this.execFileImpl = options.execFileImpl ?? execFileAsync;
+  }
+
+  async ensureWorktree(issueIid: number, title: string): Promise<WorktreeInfo> {
+    const branch = branchNameForIssue(issueIid, title);
+    const worktreePath = worktreePathForIssue(this.worktreeRoot, issueIid, title);
+
+    await mkdir(this.worktreeRoot, { recursive: true });
+
+    if (await this.worktreeExists(worktreePath)) {
+      return { branch, worktreePath };
+    }
+
+    const startPoint = await this.resolveStartPoint();
+    const branchExists = await this.branchExists(branch);
+
+    if (branchExists) {
+      await this.runGit(["worktree", "add", worktreePath, branch]);
+    } else {
+      await this.runGit(["worktree", "add", "-b", branch, worktreePath, startPoint]);
+    }
+
+    return { branch, worktreePath };
+  }
+
+  async pushBranch(branch: string): Promise<void> {
+    await this.runGit(["push", "-u", "origin", branch]);
+  }
+
+  async getDefaultBranch(): Promise<string> {
+    try {
+      const ref = await this.runGit(["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+      return ref.trim().replace(/^refs\/remotes\/origin\//, "");
+    } catch {
+      return "main";
+    }
+  }
+
+  async rebaseBranch(branch: string): Promise<void> {
+    await this.runGit(["fetch", "origin"]);
+    const defaultBranch = await this.getDefaultBranch();
+    await this.runGit(["rebase", `origin/${defaultBranch}`, branch]);
+    await this.runGit(["push", "--force-with-lease", "origin", branch]);
+  }
+
+  async hasDiff(branch: string): Promise<boolean> {
+    const defaultBranch = await this.getDefaultBranch();
+    try {
+      const diff = await this.runGit(["diff", `origin/${defaultBranch}...${branch}`, "--stat"]);
+      return diff.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  private async resolveStartPoint(): Promise<string> {
+    try {
+      const remoteHead = await this.runGit(["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+      return remoteHead.trim().replace(/^refs\/remotes\//, "");
+    } catch {
+      const currentBranch = await this.runGit(["branch", "--show-current"]);
+      return currentBranch.trim() || "HEAD";
+    }
+  }
+
+  private async worktreeExists(worktreePath: string): Promise<boolean> {
+    const output = await this.runGit(["worktree", "list", "--porcelain"]);
+    return output
+      .split("\n")
+      .some((line) => line.trim() === `worktree ${worktreePath}`);
+  }
+
+  private async branchExists(branch: string): Promise<boolean> {
+    try {
+      await this.runGit(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async runGit(args: string[]): Promise<string> {
+    try {
+      const { stdout } = await this.execFileImpl("git", ["-C", this.repoPath, ...args], {
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return stdout;
+    } catch (error) {
+      throw new Error(`git command failed (${args.join(" ")}): ${String(error)}`);
+    }
+  }
+}

package/src/text.ts

@@ -0,0 +1,16 @@
+// hello-world
+const DEFAULT_LIMIT = 240;
+
+export function truncate(text: string, limit = DEFAULT_LIMIT): string {
+  const normalized = text.replace(/\s+/g, " ").trim();
+
+  if (normalized.length <= limit) {
+    return normalized;
+  }
+
+  return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+
+export function compactText(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}