engrm 0.1.0

package/src/storage/projects.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from "bun:test";
+import {
+  normaliseGitRemoteUrl,
+  projectNameFromCanonicalId,
+  detectProject,
+} from "./projects.js";
+
+describe("normaliseGitRemoteUrl", () => {
+  test("SSH-style git@github.com", () => {
+    expect(normaliseGitRemoteUrl("git@github.com:unimpossible/aimy-agent.git")).toBe(
+      "github.com/unimpossible/aimy-agent"
+    );
+  });
+
+  test("HTTPS with .git suffix", () => {
+    expect(
+      normaliseGitRemoteUrl("https://github.com/unimpossible/aimy-agent.git")
+    ).toBe("github.com/unimpossible/aimy-agent");
+  });
+
+  test("HTTPS without .git suffix", () => {
+    expect(
+      normaliseGitRemoteUrl("https://github.com/unimpossible/aimy-agent")
+    ).toBe("github.com/unimpossible/aimy-agent");
+  });
+
+  test("HTTPS with auth credentials", () => {
+    expect(
+      normaliseGitRemoteUrl(
+        "https://david@github.com/unimpossible/aimy-agent"
+      )
+    ).toBe("github.com/unimpossible/aimy-agent");
+  });
+
+  test("SSH protocol URL", () => {
+    expect(
+      normaliseGitRemoteUrl(
+        "ssh://git@github.com/unimpossible/aimy-agent.git"
+      )
+    ).toBe("github.com/unimpossible/aimy-agent");
+  });
+
+  test("all forms normalise to the same canonical ID", () => {
+    const forms = [
+      "git@github.com:unimpossible/aimy-agent.git",
+      "https://github.com/unimpossible/aimy-agent.git",
+      "https://david@github.com/unimpossible/aimy-agent",
+      "ssh://git@github.com/unimpossible/aimy-agent.git",
+    ];
+    const ids = forms.map(normaliseGitRemoteUrl);
+    const unique = new Set(ids);
+    expect(unique.size).toBe(1);
+    expect(ids[0]).toBe("github.com/unimpossible/aimy-agent");
+  });
+
+  test("lowercase host", () => {
+    expect(normaliseGitRemoteUrl("git@GitHub.COM:Org/Repo.git")).toBe(
+      "github.com/Org/Repo"
+    );
+  });
+
+  test("preserves path case", () => {
+    expect(
+      normaliseGitRemoteUrl("https://github.com/MyOrg/MyRepo.git")
+    ).toBe("github.com/MyOrg/MyRepo");
+  });
+
+  test("strips trailing slashes", () => {
+    expect(
+      normaliseGitRemoteUrl("https://github.com/org/repo/")
+    ).toBe("github.com/org/repo");
+  });
+
+  test("handles git:// protocol", () => {
+    expect(
+      normaliseGitRemoteUrl("git://github.com/org/repo.git")
+    ).toBe("github.com/org/repo");
+  });
+
+  test("does not replace port-like colons", () => {
+    // github.com:443/org/repo should NOT treat :443 as SSH-style
+    expect(
+      normaliseGitRemoteUrl("https://github.com:443/org/repo")
+    ).toBe("github.com:443/org/repo");
+  });
+
+  test("handles whitespace", () => {
+    expect(
+      normaliseGitRemoteUrl("  https://github.com/org/repo.git  ")
+    ).toBe("github.com/org/repo");
+  });
+
+  test("non-GitHub hosts work", () => {
+    expect(
+      normaliseGitRemoteUrl("git@gitlab.com:team/project.git")
+    ).toBe("gitlab.com/team/project");
+  });
+
+  test("self-hosted GitLab", () => {
+    expect(
+      normaliseGitRemoteUrl("git@git.internal.company.com:team/project.git")
+    ).toBe("git.internal.company.com/team/project");
+  });
+});
+
+describe("projectNameFromCanonicalId", () => {
+  test("extracts repo name from canonical ID", () => {
+    expect(
+      projectNameFromCanonicalId("github.com/unimpossible/aimy-agent")
+    ).toBe("aimy-agent");
+  });
+
+  test("handles single-segment ID", () => {
+    expect(projectNameFromCanonicalId("my-project")).toBe("my-project");
+  });
+
+  test("handles local/ prefix", () => {
+    expect(projectNameFromCanonicalId("local/my-dir")).toBe("my-dir");
+  });
+});
+
+describe("detectProject", () => {
+  test("detects current repo (candengo-mem)", () => {
+    const result = detectProject("/Volumes/Data/devs/candengo-mem");
+    // This repo has a git remote
+    expect(result.canonical_id).toContain("candengo-mem");
+    expect(result.name).toBe("candengo-mem");
+    expect(result.local_path).toBe("/Volumes/Data/devs/candengo-mem");
+  });
+
+  test("falls back to directory name for non-git directory", () => {
+    const result = detectProject("/tmp");
+    expect(result.canonical_id).toBe("local/tmp");
+    expect(result.name).toBe("tmp");
+    expect(result.remote_url).toBeNull();
+  });
+});

package/src/storage/projects.ts

@@ -0,0 +1,184 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+/**
+ * Normalise a git remote URL to a canonical project ID.
+ *
+ * All of these resolve to the same canonical ID:
+ *   git@github.com:unimpossible/aimy-agent.git     → github.com/unimpossible/aimy-agent
+ *   https://github.com/unimpossible/aimy-agent.git  → github.com/unimpossible/aimy-agent
+ *   https://david@github.com/unimpossible/aimy-agent → github.com/unimpossible/aimy-agent
+ *   ssh://git@github.com/unimpossible/aimy-agent.git → github.com/unimpossible/aimy-agent
+ *
+ * Rules (from SPEC §1):
+ *   1. Strip protocol (https://, git@, ssh://)
+ *   2. Replace : with / (for SSH-style URLs)
+ *   3. Strip .git suffix
+ *   4. Strip auth credentials (user@)
+ *   5. Lowercase the host
+ */
+export function normaliseGitRemoteUrl(remoteUrl: string): string {
+  let url = remoteUrl.trim();
+
+  // Strip protocol
+  url = url.replace(/^(?:https?|ssh|git):\/\//, "");
+
+  // Strip auth credentials (anything before @ in host part)
+  // Handle: git@github.com:... and david@github.com/...
+  url = url.replace(/^[^@]+@/, "");
+
+  // Replace : with / for SSH-style URLs (github.com:org/repo → github.com/org/repo)
+  // But only if it looks like host:path (not a port like github.com:443/...)
+  url = url.replace(/^([^/:]+):(?!\d)/, "$1/");
+
+  // Strip .git suffix
+  url = url.replace(/\.git$/, "");
+
+  // Strip trailing slashes
+  url = url.replace(/\/+$/, "");
+
+  // Lowercase the host portion (everything before the first /)
+  const slashIndex = url.indexOf("/");
+  if (slashIndex !== -1) {
+    const host = url.substring(0, slashIndex).toLowerCase();
+    const path = url.substring(slashIndex);
+    url = host + path;
+  } else {
+    url = url.toLowerCase();
+  }
+
+  return url;
+}
+
+/**
+ * Extract a human-readable project name from a canonical ID.
+ * github.com/unimpossible/aimy-agent → aimy-agent
+ */
+export function projectNameFromCanonicalId(canonicalId: string): string {
+  const parts = canonicalId.split("/");
+  return parts[parts.length - 1] ?? canonicalId;
+}
+
+/**
+ * Try to get the git remote origin URL for a directory.
+ * Returns null if not a git repo or no remote configured.
+ */
+function getGitRemoteUrl(directory: string): string | null {
+  try {
+    const url = execSync("git remote get-url origin", {
+      cwd: directory,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    return url || null;
+  } catch {
+    // Not a git repo, or no origin remote
+    // Try any remote
+    try {
+      const remotes = execSync("git remote", {
+        cwd: directory,
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      })
+        .trim()
+        .split("\n")
+        .filter(Boolean);
+
+      if (remotes.length === 0) return null;
+
+      const url = execSync(`git remote get-url ${remotes[0]}`, {
+        cwd: directory,
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      return url || null;
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Project config file (.engrm.json) for non-git projects or overrides.
+ */
+interface ProjectConfigFile {
+  project_id: string;
+  name?: string;
+}
+
+function readProjectConfigFile(directory: string): ProjectConfigFile | null {
+  const configPath = join(directory, ".engrm.json");
+  if (!existsSync(configPath)) return null;
+
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+
+    if (typeof parsed["project_id"] !== "string" || !parsed["project_id"]) {
+      return null;
+    }
+
+    return {
+      project_id: parsed["project_id"],
+      name: typeof parsed["name"] === "string" ? parsed["name"] : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect the project identity for a given directory.
+ *
+ * Resolution order (from SPEC §1):
+ *   1. Git remote origin URL → normalised
+ *   2. Git remote (any remote if origin doesn't exist)
+ *   3. Manual project_id in .engrm.json
+ *   4. Last resort: directory name
+ *
+ * Returns { canonicalId, name, remoteUrl, localPath }
+ */
+export interface DetectedProject {
+  canonical_id: string;
+  name: string;
+  remote_url: string | null;
+  local_path: string;
+}
+
+export function detectProject(directory: string): DetectedProject {
+  // Try git remote first (covers fallback #1 and #2)
+  const remoteUrl = getGitRemoteUrl(directory);
+  if (remoteUrl) {
+    const canonicalId = normaliseGitRemoteUrl(remoteUrl);
+    return {
+      canonical_id: canonicalId,
+      name: projectNameFromCanonicalId(canonicalId),
+      remote_url: remoteUrl,
+      local_path: directory,
+    };
+  }
+
+  // Try .engrm.json config file
+  const configFile = readProjectConfigFile(directory);
+  if (configFile) {
+    return {
+      canonical_id: configFile.project_id,
+      name: configFile.name ?? projectNameFromCanonicalId(configFile.project_id),
+      remote_url: null,
+      local_path: directory,
+    };
+  }
+
+  // Last resort: directory name
+  const dirName = basename(directory);
+  return {
+    canonical_id: `local/${dirName}`,
+    name: dirName,
+    remote_url: null,
+    local_path: directory,
+  };
+}