gsd-pi 2.29.0 → 2.30.0-dev.7e1bbce

package/dist/resources/extensions/gsd/workflow-templates.ts

@@ -0,0 +1,241 @@
+/**
+ * GSD Workflow Templates — Registry & Resolution
+ *
+ * Loads the workflow template registry and resolves templates by name,
+ * alias, or trigger-keyword matching against user input.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __extensionDir = dirname(fileURLToPath(import.meta.url));
+const registryPath = join(__extensionDir, "workflow-templates", "registry.json");
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface TemplateEntry {
+  name: string;
+  description: string;
+  file: string;
+  phases: string[];
+  triggers: string[];
+  artifact_dir: string | null;
+  estimated_complexity: string;
+  requires_project: boolean;
+}
+
+export interface TemplateRegistry {
+  version: number;
+  templates: Record<string, TemplateEntry>;
+}
+
+export interface TemplateMatch {
+  id: string;
+  template: TemplateEntry;
+  confidence: "exact" | "high" | "medium" | "low";
+  matchedTrigger?: string;
+}
+
+// ─── Registry Cache ──────────────────────────────────────────────────────────
+
+let cachedRegistry: TemplateRegistry | null = null;
+
+/**
+ * Load and cache the workflow template registry.
+ */
+export function loadRegistry(): TemplateRegistry {
+  if (cachedRegistry) return cachedRegistry;
+
+  const content = readFileSync(registryPath, "utf-8");
+  cachedRegistry = JSON.parse(content) as TemplateRegistry;
+  return cachedRegistry;
+}
+
+/**
+ * Resolve a template by exact name or alias.
+ * Returns null if no match found.
+ */
+export function resolveByName(nameOrAlias: string): TemplateMatch | null {
+  const registry = loadRegistry();
+  const normalized = nameOrAlias.toLowerCase().trim();
+
+  // Exact key match
+  if (registry.templates[normalized]) {
+    return {
+      id: normalized,
+      template: registry.templates[normalized],
+      confidence: "exact",
+    };
+  }
+
+  // Match by template name (case-insensitive)
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    if (entry.name.toLowerCase() === normalized) {
+      return { id, template: entry, confidence: "exact" };
+    }
+  }
+
+  // Fuzzy: prefix match on id
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    if (id.startsWith(normalized) || normalized.startsWith(id)) {
+      return { id, template: entry, confidence: "high" };
+    }
+  }
+
+  // Common aliases
+  const aliases: Record<string, string> = {
+    "bug": "bugfix",
+    "fix": "bugfix",
+    "feature": "small-feature",
+    "feat": "small-feature",
+    "research": "spike",
+    "investigate": "spike",
+    "hot": "hotfix",
+    "urgent": "hotfix",
+    "security": "security-audit",
+    "audit": "security-audit",
+    "upgrade": "dep-upgrade",
+    "deps": "dep-upgrade",
+    "update-deps": "dep-upgrade",
+    "migration": "refactor",
+    "project": "full-project",
+    "full": "full-project",
+  };
+
+  const aliasMatch = aliases[normalized];
+  if (aliasMatch && registry.templates[aliasMatch]) {
+    return {
+      id: aliasMatch,
+      template: registry.templates[aliasMatch],
+      confidence: "high",
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Auto-detect the best template based on user description text.
+ * Returns ranked matches sorted by confidence.
+ */
+export function autoDetect(description: string): TemplateMatch[] {
+  const registry = loadRegistry();
+  const lower = description.toLowerCase();
+  const words = lower.split(/\s+/);
+  const matches: TemplateMatch[] = [];
+
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    let bestScore = 0;
+    let bestTrigger = "";
+
+    for (const trigger of entry.triggers) {
+      const triggerLower = trigger.toLowerCase();
+
+      // Exact phrase match in description
+      if (lower.includes(triggerLower)) {
+        const score = triggerLower.split(/\s+/).length * 2; // multi-word triggers score higher
+        if (score > bestScore) {
+          bestScore = score;
+          bestTrigger = trigger;
+        }
+        continue;
+      }
+
+      // Single-word trigger match against description words
+      if (!triggerLower.includes(" ") && words.includes(triggerLower)) {
+        if (1 > bestScore) {
+          bestScore = 1;
+          bestTrigger = trigger;
+        }
+      }
+    }
+
+    if (bestScore > 0) {
+      const confidence = bestScore >= 4 ? "high" : bestScore >= 2 ? "medium" : "low";
+      matches.push({
+        id,
+        template: entry,
+        confidence,
+        matchedTrigger: bestTrigger,
+      });
+    }
+  }
+
+  // Sort by confidence (high > medium > low), then alphabetically
+  const order = { exact: 0, high: 1, medium: 2, low: 3 };
+  matches.sort((a, b) => order[a.confidence] - order[b.confidence] || a.id.localeCompare(b.id));
+
+  return matches;
+}
+
+/**
+ * List all templates as formatted text for display.
+ */
+export function listTemplates(): string {
+  const registry = loadRegistry();
+  const lines: string[] = ["Workflow Templates\n"];
+
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    const phases = entry.phases.join(" → ");
+    const complexity = entry.estimated_complexity;
+    lines.push(`  ${id.padEnd(16)} ${entry.name}`);
+    lines.push(`  ${"".padEnd(16)} ${entry.description}`);
+    lines.push(`  ${"".padEnd(16)} Phases: ${phases}  |  Complexity: ${complexity}`);
+    lines.push("");
+  }
+
+  lines.push("Usage: /gsd start <template> [description]");
+  lines.push("       /gsd templates info <name>");
+
+  return lines.join("\n");
+}
+
+/**
+ * Get detailed info about a specific template.
+ */
+export function getTemplateInfo(name: string): string | null {
+  const match = resolveByName(name);
+  if (!match) return null;
+
+  const { id, template: t } = match;
+  const lines = [
+    `Template: ${t.name} (${id})`,
+    "",
+    `Description: ${t.description}`,
+    `Complexity:  ${t.estimated_complexity}`,
+    `Requires .gsd/: ${t.requires_project ? "yes" : "no"}`,
+    "",
+    "Phases:",
+    ...t.phases.map((p, i) => `  ${i + 1}. ${p}`),
+    "",
+    "Triggers:",
+    `  ${t.triggers.join(", ")}`,
+  ];
+
+  if (t.artifact_dir) {
+    lines.push("", `Artifacts: ${t.artifact_dir}`);
+  }
+
+  const templateFilePath = join(__extensionDir, "workflow-templates", t.file);
+  if (existsSync(templateFilePath)) {
+    lines.push("", "Template file: loaded");
+  } else {
+    lines.push("", "Template file: not yet created");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Load the raw content of a workflow template .md file.
+ */
+export function loadWorkflowTemplate(templateId: string): string | null {
+  const match = resolveByName(templateId);
+  if (!match) return null;
+
+  const filePath = join(__extensionDir, "workflow-templates", match.template.file);
+  if (!existsSync(filePath)) return null;
+
+  return readFileSync(filePath, "utf-8");
+}

package/dist/resources/extensions/gsd/worktree-command.ts

@@ -50,7 +50,7 @@ export function getWorktreeOriginalCwd(): string | null {
 export function getActiveWorktreeName(): string | null {
   if (!originalCwd) return null;
   const cwd = process.cwd();
-  const wtDir = join(originalCwd, ".gsd", "worktrees");
+  const wtDir = join(gsdRoot(originalCwd), "worktrees");
   if (!cwd.startsWith(wtDir)) return null;
   const rel = cwd.slice(wtDir.length + 1);
   const name = rel.split("/")[0] ?? rel.split("\\")[0];
@@ -633,16 +633,6 @@ async function handleMerge(
     const commitType = inferCommitType(name);
     const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
 
-    // Reconcile worktree DB into main DB before squash merge
-    const wtDbPath = join(worktreePath(basePath, name), ".gsd", "gsd.db");
-    const mainDbPath = join(basePath, ".gsd", "gsd.db");
-    if (existsSync(wtDbPath) && existsSync(mainDbPath)) {
-      try {
-        const { reconcileWorktreeDb } = await import("./gsd-db.js");
-        reconcileWorktreeDb(mainDbPath, wtDbPath);
-      } catch { /* non-fatal */ }
-    }
-
     try {
       mergeWorktreeToMain(basePath, name, commitMessage);
       ctx.ui.notify(

package/dist/resources/extensions/gsd/worktree-manager.ts

@@ -17,6 +17,7 @@
 
 import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
+import { gsdRoot } from "./paths.js";
 import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
 import {
   nativeBranchDelete,
@@ -100,7 +101,7 @@ export function resolveGitDir(basePath: string): string {
 }
 
 export function worktreesDir(basePath: string): string {
-  return join(basePath, ".gsd", "worktrees");
+  return join(gsdRoot(basePath), "worktrees");
 }
 
 export function worktreePath(basePath: string, name: string): string {
@@ -193,7 +194,7 @@ export function listWorktrees(basePath: string): WorktreeInfo[] {
   const seenRoots = new Set<string>();
   const worktreeRoots = baseVariants
     .map(baseVariant => {
-      const path = join(baseVariant, ".gsd", "worktrees");
+      const path = join(gsdRoot(baseVariant), "worktrees");
       return {
         normalized: normalizePathForComparison(path),
       };

package/dist/resources/extensions/gsd/worktree.ts

@@ -12,7 +12,7 @@
  * SLICE_BRANCH_RE) remain for backwards compatibility with legacy branches.
  */
 
-import { existsSync, readFileSync, utimesSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, utimesSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 
 import { GitServiceImpl, writeIntegrationBranch, type TaskCommitContext } from "./git-service.js";
@@ -72,6 +72,25 @@ export function captureIntegrationBranch(basePath: string, milestoneId: string,
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
  */
 export function detectWorktreeName(basePath: string): string | null {
+  // Primary: use git metadata — .git file with gitdir: pointer
+  const gitPath = join(basePath, ".git");
+  try {
+    const stat = lstatSync(gitPath);
+    if (stat.isFile()) {
+      const content = readFileSync(gitPath, "utf-8").trim();
+      if (content.startsWith("gitdir:")) {
+        const gitdir = content.slice(7).trim();
+        // Git worktree gitdir format: <repo>/.git/worktrees/<name>
+        const parts = gitdir.replace(/\\/g, "/").split("/");
+        const wtIdx = parts.lastIndexOf("worktrees");
+        if (wtIdx !== -1 && wtIdx < parts.length - 1) {
+          return parts[wtIdx + 1] || null;
+        }
+      }
+    }
+  } catch { /* fall through */ }
+
+  // Fallback: path-based detection for legacy setups
   const normalizedPath = basePath.replaceAll("\\", "/");
   const marker = "/.gsd/worktrees/";
   const idx = normalizedPath.indexOf(marker);
@@ -90,14 +109,32 @@ export function detectWorktreeName(basePath: string): string | null {
  * operate against the real project root, not a worktree subdirectory.
  */
 export function resolveProjectRoot(basePath: string): string {
+  // Primary: use git metadata to resolve the main worktree root
+  const gitPath = join(basePath, ".git");
+  try {
+    const stat = lstatSync(gitPath);
+    if (stat.isFile()) {
+      const content = readFileSync(gitPath, "utf-8").trim();
+      if (content.startsWith("gitdir:")) {
+        const gitdir = resolve(basePath, content.slice(7).trim());
+        // Git worktree gitdir: <repo>/.git/worktrees/<name>
+        // Walk up to <repo>
+        const parts = gitdir.replace(/\\/g, "/").split("/");
+        const wtIdx = parts.lastIndexOf("worktrees");
+        if (wtIdx >= 2 && parts[wtIdx - 1] === ".git") {
+          return parts.slice(0, wtIdx - 1).join("/");
+        }
+      }
+    }
+  } catch { /* fall through */ }
+
+  // Fallback: legacy path-based detection
   const normalizedPath = basePath.replaceAll("\\", "/");
   const marker = "/.gsd/worktrees/";
   const idx = normalizedPath.indexOf(marker);
   if (idx === -1) return basePath;
-  // Return the original path up to the .gsd/ marker (un-normalized)
-  // Account for potential OS-specific separators
-  const sep = basePath.includes("\\") ? "\\" : "/";
-  const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
+  const osSep = basePath.includes("\\") ? "\\" : "/";
+  const markerOs = `${osSep}.gsd${osSep}worktrees${osSep}`;
   const idxOs = basePath.indexOf(markerOs);
   if (idxOs !== -1) return basePath.slice(0, idxOs);
   return basePath.slice(0, idx);

package/dist/resources/extensions/mac-tools/extension-manifest.json

@@ -0,0 +1,16 @@
+{
+  "id": "mac-tools",
+  "name": "Mac Tools",
+  "version": "1.0.0",
+  "description": "macOS automation via Accessibility API — screenshots, UI inspection, clicks, and typing",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": [
+      "mac_check_permissions", "mac_list_apps", "mac_launch_app", "mac_activate_app",
+      "mac_quit_app", "mac_list_windows", "mac_screenshot", "mac_find",
+      "mac_get_tree", "mac_click", "mac_type", "mac_read"
+    ],
+    "hooks": ["before_agent_start"]
+  }
+}