@vladimirven/openswe 0.1.0

package/src/workspace/detect.ts

@@ -0,0 +1,223 @@
+/**
+ * Workspace detection logic
+ *
+ * Detects the workspace type based on what exists in the current directory:
+ * - existing-project: Has .openswe/ directory (fully initialized)
+ * - existing-repo: Has .git/ but no .openswe/ (can be adopted)
+ * - empty: No relevant markers (needs full setup)
+ */
+
+import { dirname, join, resolve } from "path"
+import { getOpenSWEDir } from "./paths"
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/** Types of workspace states we can detect */
+export type WorkspaceType =
+  | "existing-project"  // Has .openswe/ - load and continue
+  | "existing-repo"     // Has .git/ but no .openswe/ - offer to adopt
+  | "empty"             // Empty or no relevant markers - need setup
+
+/** Result of workspace detection */
+export interface WorkspaceResult {
+  /** The detected workspace type */
+  type: WorkspaceType
+  /** Absolute path to the project root */
+  projectRoot: string
+  /** Git remote URL (only for existing-repo type) */
+  remoteUrl?: string | null
+  /** Repository full name in owner/repo format (only for existing-repo type) */
+  repoFullName?: string | null
+}
+
+// ============================================================================
+// Detection Functions
+// ============================================================================
+
+/**
+ * Check if a directory contains an OpenSWE project
+ * @param path - Directory path to check
+ */
+export async function hasOpenSWEProject(path: string): Promise<boolean> {
+  const opensweDir = getOpenSWEDir(path)
+  // Try to check if it's a directory by checking if state.db exists
+  // or if the directory marker exists
+  try {
+    const { readdir } = await import("fs/promises")
+    await readdir(opensweDir)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if a directory contains a git repository
+ * @param path - Directory path to check
+ */
+export async function hasGitRepo(path: string): Promise<boolean> {
+  const gitDir = join(path, ".git")
+  try {
+    const { readdir } = await import("fs/promises")
+    await readdir(gitDir)
+    return true
+  } catch {
+    // .git might be a file (for worktrees), check if it exists as a file
+    const gitFile = Bun.file(gitDir)
+    return gitFile.exists()
+  }
+}
+
+/**
+ * Check if a directory is empty (or only contains hidden files we can ignore)
+ * @param path - Directory path to check
+ */
+export async function isEmptyDirectory(path: string): Promise<boolean> {
+  try {
+    const { readdir } = await import("fs/promises")
+    const entries = await readdir(path)
+    // Consider empty if no entries or only .DS_Store
+    const significantEntries = entries.filter(
+      (e) => e !== ".DS_Store" && e !== ".gitkeep"
+    )
+    return significantEntries.length === 0
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get the git remote origin URL
+ * @param path - Directory path (must contain .git)
+ * @returns Remote URL or null if not found
+ */
+export async function getGitRemoteUrl(path: string): Promise<string | null> {
+  try {
+    const proc = Bun.spawn(["git", "remote", "get-url", "origin"], {
+      cwd: path,
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const output = await new Response(proc.stdout).text()
+    const exitCode = await proc.exited
+
+    if (exitCode !== 0) {
+      return null
+    }
+
+    return output.trim() || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Parse a git remote URL to extract owner/repo format
+ * Handles both HTTPS and SSH URLs:
+ * - https://github.com/owner/repo.git
+ * - git@github.com:owner/repo.git
+ * - https://github.com/owner/repo
+ * - git@github.com:owner/repo
+ *
+ * @param remoteUrl - Git remote URL
+ * @returns owner/repo string or null if parsing fails
+ */
+export function parseRepoFullName(remoteUrl: string): string | null {
+  // SSH format: git@github.com:owner/repo.git
+  const sshMatch = remoteUrl.match(/git@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/)
+  if (sshMatch?.[1]) {
+    return sshMatch[1]
+  }
+
+  // HTTPS format: https://github.com/owner/repo.git
+  const httpsMatch = remoteUrl.match(/https?:\/\/[^/]+\/([^/]+\/[^/]+?)(?:\.git)?$/)
+  if (httpsMatch?.[1]) {
+    return httpsMatch[1]
+  }
+
+  return null
+}
+
+/**
+ * Main workspace detection function
+ *
+ * Detection logic follows this order:
+ * 1. Check for .openswe/ (existing project) → load and continue
+ * 2. Check for .git/ (existing repo) → offer to adopt
+ * 3. Otherwise → empty directory, need full setup
+ *
+ * @param cwd - Current working directory to detect
+ * @returns Detection result with workspace type and relevant info
+ */
+export async function detectWorkspace(cwd: string): Promise<WorkspaceResult> {
+  let current = resolve(cwd)
+
+  while (true) {
+    // Prefer OpenSWE project if found at this level
+    if (await hasOpenSWEProject(current)) {
+      return {
+        type: "existing-project",
+        projectRoot: current,
+      }
+    }
+
+    // Otherwise see if this level is a git repo
+    if (await hasGitRepo(current)) {
+      const remoteUrl = await getGitRemoteUrl(current)
+      const repoFullName = remoteUrl ? parseRepoFullName(remoteUrl) : null
+
+      return {
+        type: "existing-repo",
+        projectRoot: current,
+        remoteUrl,
+        repoFullName,
+      }
+    }
+
+    const parent = dirname(current)
+    if (parent === current) {
+      break
+    }
+    current = parent
+  }
+
+  return {
+    type: "empty",
+    projectRoot: resolve(cwd),
+  }
+}
+
+// ============================================================================
+// Validation Helpers
+// ============================================================================
+
+/**
+ * Validate that a directory can be used as a workspace
+ * - Must exist
+ * - Must be a directory (not a file)
+ * - Must be readable
+ *
+ * @param path - Path to validate
+ * @throws Error if validation fails
+ */
+export async function validateWorkspaceDirectory(path: string): Promise<void> {
+  const { stat } = await import("fs/promises")
+
+  try {
+    const stats = await stat(path)
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${path}`)
+    }
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new Error(`Directory does not exist: ${path}`)
+    }
+    if ((err as NodeJS.ErrnoException).code === "EACCES") {
+      throw new Error(`Permission denied: ${path}`)
+    }
+    throw err
+  }
+}

package/src/workspace/index.ts

@@ -0,0 +1,71 @@
+/**
+ * Workspace module
+ *
+ * Provides utilities for workspace detection and initialization:
+ * - Path utilities for .openswe/, .worktrees/, etc.
+ * - Workspace type detection (existing-project, existing-repo, empty)
+ * - Project initialization (directory creation)
+ */
+
+// Re-export all path utilities
+export {
+  // Constants
+  OPENSWE_DIR,
+  WORKTREES_DIR,
+  STATE_DB_FILE,
+  LOGS_DIR,
+  // Path resolution
+  getOpenSWEDir,
+  getWorktreesDir,
+  getStateDatabasePath,
+  getLogsDir,
+  getWorktreePath,
+  // Naming utilities
+  sanitizeWorktreeName,
+  generateBranchName,
+  // Path validation
+  ensureAbsolutePath,
+  isPathInside,
+} from "./paths"
+
+// Re-export detection utilities
+export {
+  // Types
+  type WorkspaceType,
+  type WorkspaceResult,
+  // Detection functions
+  detectWorkspace,
+  hasOpenSWEProject,
+  hasGitRepo,
+  isEmptyDirectory,
+  getGitRemoteUrl,
+  parseRepoFullName,
+  validateWorkspaceDirectory,
+} from "./detect"
+
+// Re-export initialization utilities
+export {
+  // Types
+  type RepoInfo,
+  type InitResult,
+  // Initialization functions
+  initProject,
+  createOpenSWEDirectory,
+  createWorktreesDirectory,
+  isProjectInitialized,
+  cleanupProject,
+} from "./init"
+
+// Re-export project config utilities
+export {
+  // Types
+  type ProjectConfig,
+  // Path utilities
+  getProjectConfigPath,
+  // CRUD functions
+  loadProjectConfig,
+  saveProjectConfig,
+  updateLastOpened,
+  createProjectConfig,
+  projectConfigExists,
+} from "./project"

package/src/workspace/init.ts

@@ -0,0 +1,131 @@
+/**
+ * Project initialization
+ *
+ * Handles creating and setting up a new OpenSWE project:
+ * - Create .openswe/ directory structure
+ * - (Database initialization is handled separately)
+ */
+
+import { mkdir } from "fs/promises"
+import {
+  getOpenSWEDir,
+  getWorktreesDir,
+  getLogsDir,
+} from "./paths"
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/** Information about the repository being linked */
+export interface RepoInfo {
+  /** Full repository name in owner/repo format */
+  fullName: string
+  /** Git remote URL (SSH or HTTPS) */
+  remoteUrl: string
+}
+
+/** Result of project initialization */
+export interface InitResult {
+  /** Absolute path to the project root */
+  projectRoot: string
+  /** Path to .openswe directory */
+  opensweDir: string
+  /** Path to .worktrees directory */
+  worktreesDir: string
+}
+
+// ============================================================================
+// Directory Creation
+// ============================================================================
+
+/**
+ * Create the .openswe directory structure
+ * @param projectRoot - Absolute path to the project root
+ */
+export async function createOpenSWEDirectory(projectRoot: string): Promise<void> {
+  const opensweDir = getOpenSWEDir(projectRoot)
+  const logsDir = getLogsDir(projectRoot)
+
+  // Create .openswe/ and .openswe/logs/
+  await mkdir(opensweDir, { recursive: true })
+  await mkdir(logsDir, { recursive: true })
+}
+
+/**
+ * Create the .worktrees directory
+ * @param projectRoot - Absolute path to the project root
+ */
+export async function createWorktreesDirectory(projectRoot: string): Promise<void> {
+  const worktreesDir = getWorktreesDir(projectRoot)
+  await mkdir(worktreesDir, { recursive: true })
+}
+
+// ============================================================================
+// Full Initialization
+// ============================================================================
+
+/**
+ * Initialize a new OpenSWE project
+ *
+ * This creates the necessary directory structure.
+ * Note: Database initialization is handled separately.
+ *
+ * @param projectRoot - Absolute path to the project root
+ * @param repoInfo - Information about the repository (optional, for logging)
+ * @returns Initialization result
+ */
+export async function initProject(
+  projectRoot: string,
+  repoInfo?: RepoInfo
+): Promise<InitResult> {
+  const opensweDir = getOpenSWEDir(projectRoot)
+  const worktreesDir = getWorktreesDir(projectRoot)
+
+  // Create directory structure
+  await createOpenSWEDirectory(projectRoot)
+  await createWorktreesDirectory(projectRoot)
+
+  return {
+    projectRoot,
+    opensweDir,
+    worktreesDir,
+  }
+}
+
+/**
+ * Check if a project is fully initialized
+ * (has .openswe directory with required structure)
+ *
+ * @param projectRoot - Absolute path to the project root
+ */
+export async function isProjectInitialized(projectRoot: string): Promise<boolean> {
+  const opensweDir = getOpenSWEDir(projectRoot)
+
+  try {
+    const { stat } = await import("fs/promises")
+    const stats = await stat(opensweDir)
+    return stats.isDirectory()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Clean up a partially initialized project
+ * (removes .openswe and .worktrees directories)
+ *
+ * Use with caution - this is destructive!
+ *
+ * @param projectRoot - Absolute path to the project root
+ */
+export async function cleanupProject(projectRoot: string): Promise<void> {
+  const { rm } = await import("fs/promises")
+
+  const opensweDir = getOpenSWEDir(projectRoot)
+  const worktreesDir = getWorktreesDir(projectRoot)
+
+  // Remove directories (ignore errors if they don't exist)
+  await rm(opensweDir, { recursive: true, force: true })
+  await rm(worktreesDir, { recursive: true, force: true })
+}

package/src/workspace/paths.ts

@@ -0,0 +1,143 @@
+/**
+ * Path utilities for workspace directories
+ *
+ * Provides consistent path resolution for OpenSWE project structure:
+ * - .openswe/        - Project state directory
+ * - .openswe/state.db - SQLite database
+ * - .openswe/logs/   - Log files
+ * - .worktrees/      - Git worktrees for sessions
+ */
+
+import { join, resolve } from "path"
+
+// ============================================================================
+// Directory Names (Constants)
+// ============================================================================
+
+/** Name of the OpenSWE project state directory */
+export const OPENSWE_DIR = ".openswe"
+
+/** Name of the worktrees directory */
+export const WORKTREES_DIR = ".worktrees"
+
+/** Name of the SQLite database file */
+export const STATE_DB_FILE = "state.db"
+
+/** Name of the logs directory within .openswe */
+export const LOGS_DIR = "logs"
+
+// ============================================================================
+// Path Resolution Functions
+// ============================================================================
+
+/**
+ * Resolve the .openswe directory path for a project root
+ * @param projectRoot - Absolute path to the project root
+ */
+export function getOpenSWEDir(projectRoot: string): string {
+  return join(projectRoot, OPENSWE_DIR)
+}
+
+/**
+ * Resolve the .worktrees directory path for a project root
+ * @param projectRoot - Absolute path to the project root
+ */
+export function getWorktreesDir(projectRoot: string): string {
+  return join(projectRoot, WORKTREES_DIR)
+}
+
+/**
+ * Resolve the state.db path for a project root
+ * @param projectRoot - Absolute path to the project root
+ */
+export function getStateDatabasePath(projectRoot: string): string {
+  return join(projectRoot, OPENSWE_DIR, STATE_DB_FILE)
+}
+
+/**
+ * Resolve the logs directory path for a project root
+ * @param projectRoot - Absolute path to the project root
+ */
+export function getLogsDir(projectRoot: string): string {
+  return join(projectRoot, OPENSWE_DIR, LOGS_DIR)
+}
+
+/**
+ * Resolve a worktree path for a specific session/issue
+ * @param projectRoot - Absolute path to the project root
+ * @param name - Session name or issue number (will be sanitized)
+ */
+export function getWorktreePath(projectRoot: string, name: string | number): string {
+  const sanitized = sanitizeWorktreeName(name)
+  return join(projectRoot, WORKTREES_DIR, sanitized)
+}
+
+
+/**
+ * Resolve the log file path for a session
+ * @param projectRoot - Absolute path to the project root
+ * @param sessionId - Session UUID
+ */
+export function getSessionLogPath(projectRoot: string, sessionId: string): string {
+  return join(getLogsDir(projectRoot), `${sessionId}.log`)
+}
+
+// ============================================================================
+// Naming Utilities
+// ============================================================================
+
+/**
+ * Sanitize a name for use as a worktree directory/branch name
+ * - Converts to lowercase
+ * - Replaces spaces and special chars with hyphens
+ * - Removes consecutive hyphens
+ * - Trims leading/trailing hyphens
+ */
+export function sanitizeWorktreeName(name: string | number): string {
+  if (typeof name === "number") {
+    return `issue-${name}`
+  }
+
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, "-") // Replace non-alphanumeric with hyphens
+    .replace(/-+/g, "-")         // Collapse multiple hyphens
+    .replace(/^-|-$/g, "")       // Trim leading/trailing hyphens
+}
+
+/**
+ * Generate a branch name for a session
+ * @param name - Session name or issue number
+ * @param prefix - Branch prefix (default: "openswe")
+ */
+export function generateBranchName(name: string | number, prefix = "openswe"): string {
+  const sanitized = sanitizeWorktreeName(name)
+  return `${prefix}/${sanitized}`
+}
+
+// ============================================================================
+// Path Validation
+// ============================================================================
+
+/**
+ * Ensure a path is absolute
+ * @param path - Path to validate/resolve
+ * @param basePath - Base path for resolution if relative (defaults to cwd)
+ */
+export function ensureAbsolutePath(path: string, basePath?: string): string {
+  if (path.startsWith("/")) {
+    return path
+  }
+  return resolve(basePath ?? process.cwd(), path)
+}
+
+/**
+ * Check if a path is inside another path
+ * @param child - Potential child path
+ * @param parent - Potential parent path
+ */
+export function isPathInside(child: string, parent: string): boolean {
+  const resolvedChild = resolve(child)
+  const resolvedParent = resolve(parent)
+  return resolvedChild.startsWith(resolvedParent + "/") || resolvedChild === resolvedParent
+}