pi-crew 0.5.1 → 0.5.2

package/src/utils/project-detector.ts

@@ -0,0 +1,160 @@
+import { createHash } from "node:crypto";
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/**
+ * Information about a detected project.
+ */
+export interface ProjectInfo {
+	projectId: string;
+	projectName: string;
+}
+
+/**
+ * Create a SHA256 hash of a string, returning the first 16 characters.
+ */
+function hashPath(input: string): string {
+	return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+
+/**
+ * Extract the repository name from a git remote URL.
+ * Handles formats like:
+ *   - https://github.com/user/repo.git
+ *   - https://github.com/user/repo
+ *   - git@github.com:user/repo.git
+ *   - ssh://git@github.com/user/repo.git
+ */
+function extractRepoName(remoteUrl: string): string | null {
+	// Remove .git suffix
+	const withoutGit = remoteUrl.replace(/\.git$/, "");
+
+	// Handle SSH format: git@github.com:user/repo
+	const sshMatch = withoutGit.match(/^git@[^:]+:(.+)$/);
+	if (sshMatch) {
+		const parts = sshMatch[1].split("/");
+		return parts[parts.length - 1] ?? null;
+	}
+
+	// Handle HTTPS/HTTP/SSH URL format
+	try {
+		const url = new URL(withoutGit);
+		const pathParts = url.pathname.split("/").filter(Boolean);
+		return pathParts[pathParts.length - 1] ?? null;
+	} catch {
+		// Not a valid URL, try to extract from path-like string
+		const parts = withoutGit.split("/").filter(Boolean);
+		return parts[parts.length - 1] ?? null;
+	}
+}
+
+/**
+ * Try to get the repository name from git remote origin.
+ */
+function tryGitRemote(cwd: string): string | null {
+	try {
+		const remoteUrl = execSync("git remote get-url origin", {
+			cwd,
+			encoding: "utf-8",
+			stdio: ["pipe", "pipe", "ignore"],
+		}).trim();
+
+		if (!remoteUrl) return null;
+
+		const repoName = extractRepoName(remoteUrl);
+		if (!repoName) return null;
+
+		// Verify it's a valid directory name (no path traversal attempts)
+		if (repoName.includes("..") || repoName.includes("/")) return null;
+
+		return repoName;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Try to get the directory name from git toplevel.
+ */
+function tryGitToplevel(cwd: string): string | null {
+	try {
+		const toplevel = execSync("git rev-parse --show-toplevel", {
+			cwd,
+			encoding: "utf-8",
+			stdio: ["pipe", "pipe", "ignore"],
+		}).trim();
+
+		if (!toplevel || !fs.existsSync(toplevel)) return null;
+
+		const dirName = path.basename(toplevel);
+		// Verify it's a valid directory name
+		if (!dirName || dirName.includes("..") || dirName.includes("/")) return null;
+
+		return dirName;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Detect project information from a working directory.
+ * Uses a hierarchy of detection methods, falling through on failure.
+ *
+ * Detection hierarchy (first successful wins):
+ * 1. CLAUDE_PROJECT_DIR env var → hash the path, use dir name as name
+ * 2. git remote get-url origin → extract repo name from URL
+ * 3. git rev-parse --show-toplevel → use dir name
+ * 4. Fallback: hash(cwd) for projectId, path.basename(cwd) for name
+ */
+export function detectProjectId(cwd: string): ProjectInfo {
+	// Normalize the cwd path
+	const normalizedCwd = path.resolve(cwd);
+
+	// Method 1: Check CLAUDE_PROJECT_DIR env var
+	const claudeProjectDir = process.env.CLAUDE_PROJECT_DIR;
+	if (claudeProjectDir && claudeProjectDir.trim()) {
+		const resolvedPath = path.resolve(claudeProjectDir.trim());
+		const projectName = path.basename(resolvedPath);
+		const projectId = hashPath(resolvedPath);
+		return { projectId, projectName };
+	}
+
+	// Method 2: Try git remote origin
+	const repoName = tryGitRemote(normalizedCwd);
+	if (repoName) {
+		const projectId = hashPath(normalizedCwd);
+		return { projectId, projectName: repoName };
+	}
+
+	// Method 3: Try git toplevel
+	const toplevelName = tryGitToplevel(normalizedCwd);
+	if (toplevelName) {
+		const projectId = hashPath(normalizedCwd);
+		return { projectId, projectName: toplevelName };
+	}
+
+	// Method 4: Fallback - hash the cwd and use basename
+	const projectId = hashPath(normalizedCwd);
+	const projectName = path.basename(normalizedCwd) || "unknown";
+	return { projectId, projectName };
+}
+
+/**
+ * Get the storage directory for a specific project's instincts.
+ * @param projectId - The project identifier (from detectProjectId)
+ * @param crewRoot - The crew root directory (e.g., from projectCrewRoot)
+ * @returns The path to the project's storage directory
+ */
+export function getProjectStorageDir(projectId: string, crewRoot: string): string {
+	return path.join(crewRoot, "instincts", "projects", projectId);
+}
+
+/**
+ * Get the global storage directory for instincts.
+ * @param crewRoot - The crew root directory
+ * @returns The path to the global storage directory
+ */
+export function getGlobalStorageDir(crewRoot: string): string {
+	return path.join(crewRoot, "instincts", "global");
+}

package/test-bugs-all.mjs

@@ -70,7 +70,7 @@ if (completedIdsFix) {
 // Check dist file
 console.log("\n=== Checking dist/index.mjs ===");
 const distContent = fs.readFileSync("dist/index.mjs", "utf-8");
-const distNeedsAttention = distContent.includes('status === "completed" || t.status === "needs_attention"');
+const distNeedsAttention = distContent.includes('t2.status === "completed" || t2.status === "needs_attention"');
 if (distNeedsAttention) {
     console.log("  ✅ Bug #20 fix is in dist/index.mjs");
 } else {

package/skills/REFERENCE.md

@@ -1,136 +0,0 @@
-# pi-crew Skills Reference
-
-## Skill Chains
-
-### Bug Investigation
-
-```
-systematic-debugging (4 phases with refuse gate)
-    ↓
-verification-before-done (evidence before claim)
-    ↓
-post-mortem (RCA documentation)
-```
-
-### Multi-phase Work
-
-```
-orchestration (phase coordination)
-    ↓
-delegation-patterns (task splitting)
-    ↓
-verification-before-done (after each phase)
-```
-
-### Code Review (Quick)
-
-```
-scrutinize (outsider perspective + simpler alternative)
-```
-
-### Code Review (Deep)
-
-```
-scrutinize (outsider perspective)
-    ↓
-multi-perspective-review (8-pass deep review)
-    ↓
-secure-agent-orchestration-review (security focus)
-```
-
----
-
-## When to Invoke
-
-| Situation | Skill |
-|-----------|-------|
-| Bug / test failure / crash | `systematic-debugging` |
-| Before claiming done | `verification-before-done` |
-| Code review (quick) | `scrutinize` |
-| Code review (deep) | `multi-perspective-review` |
-| Task delegation | `delegation-patterns` |
-| Complex multi-phase work | `orchestration` |
-| After bug is fixed | `post-mortem` |
-| Security review | `secure-agent-orchestration-review` |
-| Workspace safety | `workspace-isolation` |
-| Bash safety | `safe-bash` |
-
----
-
-## Skills Inventory
-
-### Core Discipline
-
-| Skill | Description |
-|-------|-------------|
-| `systematic-debugging` | Four-phase debugging with refuse gates, falsify-first discipline |
-| `verification-before-done` | Evidence before claims |
-| `orchestration` | Multi-phase coordination, 8 rules including "respawn not absorb" |
-
-### Review
-
-| Skill | Description |
-|-------|-------------|
-| `scrutinize` | Outsider-perspective review questioning intent |
-| `multi-perspective-review` | 8-pass deep code review |
-| `secure-agent-orchestration-review` | Security-focused review |
-
-### Documentation
-
-| Skill | Description |
-|-------|-------------|
-| `post-mortem` | Engineering RCA record |
-
-### Delegation
-
-| Skill | Description |
-|-------|-------------|
-| `delegation-patterns` | Task splitting patterns |
-| `requirements-to-task-packet` | Task packet creation |
-
-### Runtime/Safety
-
-| Skill | Description |
-|-------|-------------|
-| `workspace-isolation` | Security boundary enforcement |
-| `worktree-isolation` | Git worktree safety |
-| `safe-bash` | Bash command safety |
-| `state-mutation-locking` | State mutation protection |
-
-### Observability
-
-| Skill | Description |
-|-------|-------------|
-| `event-log-tracing` | JSONL event log analysis |
-| `runtime-state-reader` | Runtime state inspection |
-| `observability-reliability` | Reliability patterns |
-
----
-
-## Anti-patterns
-
-| Anti-pattern | Skill | Rule |
-|--------------|-------|------|
-| Proposing fix before reproducing | `systematic-debugging` | Refuse Gate |
-| Running proof before disproof | `systematic-debugging` | Phase 3 |
-| Claiming "tests pass" without fresh run | `verification-before-done` | Gate Function |
-| Reviewing diff-local without tracing path | `scrutinize` | Trace step |
-| Skipping simpler-alternative pass | `multi-perspective-review` | Pre-review |
-| Editing files yourself as orchestrator | `orchestration` | Rule 1 |
-| Dispatching serially when parallel possible | `orchestration` | Rule 3 |
-| Committing a red tree | `orchestration` | Rule 6 |
-| Absorbing subagent's broken work | `orchestration` | Rule 7 |
-| Rubber-stamp review | `multi-perspective-review` | Rules |
-
----
-
-## Key Enforcement Patterns (from 9arm)
-
-| Pattern | Implemented In |
-|---------|---------------|
-| **Refuse Gate** | `systematic-debugging` |
-| **Recite Ritual** | `systematic-debugging` (Invocation) |
-| **Falsify Before Proof** | `systematic-debugging` (Phase 3) |
-| **Simpler Alternative Pass** | `scrutinize`, `multi-perspective-review` |
-| **Required Inputs Gate** | `post-mortem` |
-| **Respawn Not Absorb** | `orchestration` (Rule 7) |