opencode-dir 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# opencode-dir
+
+Directory operations for [opencode](https://opencode.ai) sessions.
+
+When working across monorepos or multiple repositories, sessions get stuck in the directory they were started in. This plugin adds `/cd` and `/mv` commands to move sessions between directories.
+
+## Commands
+
+### `/cd <path>`
+
+Change the session's working directory. Updates the session metadata without rewriting message history. Useful when you want the session to continue in a new location but don't need old file references updated.
+
+### `/mv <path>`
+
+Move the session to a new directory. Updates the session metadata **and** rewrites `path.cwd` and `path.root` in all assistant messages to point to the new location. Use this when relocating a session and its full context to a different repo.
+
+## Install
+
+Add to your `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-dir"]
+}
+```
+
+## Requirements
+
+- The **target** directory must be inside a git repository. Moving to a non-git directory is not supported because opencode groups all non-git sessions under a single `"global"` project, making reliable moves impossible.
+- Sessions started in non-git directories can be moved **into** a git repo — this is a valid way to "adopt" a global session into a proper project.
+
+## How it works
+
+1. Resolves the target directory and computes its project ID (the repo's initial commit hash, matching opencode's own logic)
+2. Updates the session's `directory` and `project_id` in the database
+3. For `/mv`, rewrites `path.cwd` and `path.root` in all assistant messages from the old directory to the new one
+4. Intercepts subsequent tool calls (`bash`, `read`, `write`, `edit`, `glob`, `grep`) and rewrites file paths from the old directory to the new one — tools operate in the new directory immediately without a restart
+5. Writes an `external_directory` permission rule on the session so tools can access the new directory without prompts
+
+For a fully clean environment, restart opencode in the target directory after the move.
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,109 @@
+import { type Plugin } from "@opencode-ai/plugin"
+import { mkdirSync, appendFileSync } from "fs"
+import {
+  type Override,
+  type ExecResult,
+  loadOverrides,
+  persistOverrides,
+  execMove,
+  rewritePath,
+  PATH_TOOLS,
+} from "./lib"
+
+const STATE_DIR = `${process.env.XDG_DATA_HOME || process.env.HOME + "/.local/share"}/opencode`
+const LOG_FILE = `${STATE_DIR}/opencode-dir-debug.log`
+const OVERRIDES_FILE = `${STATE_DIR}/opencode-dir-overrides.json`
+const DEBUG = !!process.env.OPENCODE_DIR_DEBUG
+
+function log(...args: unknown[]) {
+  if (!DEBUG) return
+  const ts = new Date().toISOString()
+  const line = args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" ")
+  appendFileSync(LOG_FILE, `[${ts}] ${line}\n`)
+}
+
+const dirOverrides: Map<string, Override> = loadOverrides(OVERRIDES_FILE)
+
+/**
+ * opencode-dir plugin — adds `/cd` and `/mv` commands for moving sessions
+ * between directories at runtime.
+ *
+ * `/cd <path>` changes where tools operate without touching message history.
+ * `/mv <path>` does the same and rewrites historical paths in messages.
+ */
+export const OpencodeDir: Plugin = async ({ client }) => {
+  mkdirSync(STATE_DIR, { recursive: true })
+  log("plugin loaded", { overridesRecovered: dirOverrides.size })
+
+  return {
+    "command.execute.before": async (input, output) => {
+      log("command.execute.before", { command: input.command, sessionID: input.sessionID })
+      if (input.command !== "cd" && input.command !== "mv") return
+
+      const targetPath = input.arguments.trim()
+      if (!targetPath) {
+        output.parts.splice(0)
+        output.parts.push({ type: "text", text: `Usage: /${input.command} <path>` })
+        return
+      }
+
+      let exec: ExecResult
+      try {
+        exec = execMove(input.sessionID, targetPath, input.command === "mv")
+      } catch (e: unknown) {
+        exec = { result: `Error: ${e instanceof Error ? e.message : String(e)}` }
+      }
+
+      output.parts.splice(0)
+      output.parts.push({ type: "text", text: exec.result })
+
+      if (exec.oldDir && exec.newDir) {
+        log("storing override", { sessionID: input.sessionID, oldDir: exec.oldDir, newDir: exec.newDir })
+        dirOverrides.set(input.sessionID, { oldDir: exec.oldDir, newDir: exec.newDir })
+        persistOverrides(OVERRIDES_FILE, dirOverrides)
+
+        await client.tui.showToast({
+          body: {
+            title: "Session directory changed",
+            message: `Now operating in ${exec.newDir}.\nRestart opencode there for a clean slate.`,
+            variant: "info",
+            duration: 8000,
+          },
+        }).catch(() => {})
+      }
+    },
+
+    "tool.execute.before": async (input, output) => {
+      const override = dirOverrides.get(input.sessionID)
+      if (!override) return
+      log("tool.execute.before", { tool: input.tool, sessionID: input.sessionID })
+
+      const { oldDir, newDir } = override
+      const pathKeys = PATH_TOOLS[input.tool]
+      if (pathKeys) {
+        for (const key of pathKeys) {
+          if (typeof output.args[key] === "string") {
+            output.args[key] = rewritePath(output.args[key], oldDir, newDir)
+          }
+        }
+      }
+
+      if (input.tool === "bash") {
+        if (!output.args.workdir) output.args.workdir = newDir
+        if (typeof output.args.command === "string") {
+          output.args.command = output.args.command.replaceAll(oldDir, newDir)
+        }
+      }
+    },
+
+    "shell.env": async (input, output) => {
+      const override = dirOverrides.get(input.sessionID ?? "")
+      if (!override) return
+
+      const { oldDir, newDir } = override
+      if (input.cwd === oldDir || input.cwd.startsWith(oldDir + "/")) {
+        output.env.PWD = rewritePath(input.cwd, oldDir, newDir)
+      }
+    },
+  }
+}

package/lib.ts

@@ -0,0 +1,319 @@
+import { Database } from "bun:sqlite"
+import { resolve } from "path"
+import { existsSync, readFileSync, writeFileSync } from "fs"
+import { execSync } from "child_process"
+
+// ---------------------------------------------------------------------------
+// Overrides
+// ---------------------------------------------------------------------------
+
+export interface Override {
+  oldDir: string
+  newDir: string
+}
+
+/** Loads session directory overrides from a JSON file on disk. */
+export function loadOverrides(path: string): Map<string, Override> {
+  try {
+    const entries = JSON.parse(readFileSync(path, "utf-8")) as [string, Override][]
+    return new Map(entries)
+  } catch {
+    return new Map()
+  }
+}
+
+/** Persists session directory overrides to disk (owner-only). */
+export function persistOverrides(path: string, map: Map<string, Override>) {
+  writeFileSync(path, JSON.stringify([...map.entries()]), { mode: 0o600 })
+}
+
+// ---------------------------------------------------------------------------
+// Git
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolves the initial commit hash for a git repository, matching
+ * opencode's `Project.fromDirectory` logic:
+ * `git rev-list --max-parents=0 --all`, split/filter/sort, take first.
+ */
+export function getInitialCommit(dir: string): string | null {
+  try {
+    const output = execSync("git rev-list --max-parents=0 --all", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+    })
+    return output.split("\n").filter(Boolean).map((x) => x.trim()).sort()[0] ?? null
+  } catch {
+    return null
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Database
+// ---------------------------------------------------------------------------
+
+/** Creates the minimal schema required by the plugin in a fresh database. */
+export function createSchema(db: Database) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS project (
+      id TEXT PRIMARY KEY,
+      worktree TEXT NOT NULL,
+      vcs TEXT NOT NULL,
+      name TEXT,
+      icon_url TEXT,
+      icon_color TEXT,
+      time_created INTEGER NOT NULL,
+      time_updated INTEGER NOT NULL,
+      time_initialized INTEGER,
+      sandboxes TEXT NOT NULL DEFAULT '[]',
+      commands TEXT
+    );
+    CREATE TABLE IF NOT EXISTS session (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES project(id) ON DELETE CASCADE,
+      workspace_id TEXT,
+      parent_id TEXT,
+      slug TEXT NOT NULL,
+      directory TEXT NOT NULL,
+      title TEXT NOT NULL,
+      version TEXT NOT NULL,
+      share_url TEXT,
+      summary_additions INTEGER,
+      summary_deletions INTEGER,
+      summary_files INTEGER,
+      summary_diffs TEXT,
+      revert TEXT,
+      permission TEXT,
+      time_created INTEGER NOT NULL,
+      time_updated INTEGER NOT NULL,
+      time_compacting INTEGER,
+      time_archived INTEGER
+    );
+    CREATE TABLE IF NOT EXISTS message (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES session(id) ON DELETE CASCADE,
+      time_created INTEGER NOT NULL,
+      time_updated INTEGER NOT NULL,
+      data TEXT NOT NULL
+    );
+  `)
+}
+
+/** Creates a project row if one does not already exist. */
+export function ensureProject(db: Database, projectId: string, worktree: string) {
+  if (db.query("SELECT id FROM project WHERE id = ?").get(projectId)) return
+
+  const now = Date.now()
+  db.run(
+    `INSERT INTO project (id, worktree, vcs, name, icon_url, icon_color, time_created, time_updated, time_initialized, sandboxes, commands)
+     VALUES (?, ?, 'git', NULL, NULL, 'blue', ?, ?, NULL, '[]', NULL)`,
+    [projectId, worktree, now, now],
+  )
+}
+
+/**
+ * Updates a session's directory, project, and permission in one statement.
+ *
+ * Writes an `external_directory` allow rule to `session.permission` so
+ * `PermissionNext` auto-allows tool access to the target tree.
+ * `prompt()` loads the session AFTER `command.execute.before` fires,
+ * so the rule is available when tools run.
+ */
+export function updateSession(db: Database, sessionId: string, newDir: string, newProjectId: string): number {
+  const permission = JSON.stringify([
+    { permission: "external_directory", pattern: newDir + "/*", action: "allow" },
+  ])
+  return db.run(
+    `UPDATE session SET directory = ?, project_id = ?, permission = ?, time_updated = ? WHERE id = ?`,
+    [newDir, newProjectId, permission, Date.now(), sessionId],
+  ).changes
+}
+
+/**
+ * Rewrites `path.cwd` and `path.root` in message data from `oldDir` to
+ * `newDir`. Runs inside a transaction for atomicity.
+ */
+export function rewriteMessages(
+  db: Database,
+  sessionId: string,
+  oldDir: string,
+  newDir: string,
+): { total: number; rewritten: number } {
+  const messages = db
+    .query("SELECT id, data FROM message WHERE session_id = ?")
+    .all(sessionId) as { id: string; data: string }[]
+
+  let rewritten = 0
+  const update = db.prepare("UPDATE message SET data = ? WHERE id = ?")
+  const tx = db.transaction(() => {
+    for (const msg of messages) {
+      const data = JSON.parse(msg.data)
+      let changed = false
+
+      if (data.path) {
+        if (data.path.cwd === oldDir) {
+          data.path.cwd = newDir
+          changed = true
+        }
+        if (data.path.root === oldDir) {
+          data.path.root = newDir
+          changed = true
+        }
+      }
+
+      if (changed) {
+        update.run(JSON.stringify(data), msg.id)
+        rewritten++
+      }
+    }
+  })
+  tx()
+
+  return { total: messages.length, rewritten }
+}
+
+/**
+ * Resolves a user-provided path to an absolute directory and its git
+ * project ID. Throws if the path does not exist or is not inside a
+ * git repository.
+ */
+export function resolveTarget(targetPath: string): { dir: string; projectId: string } {
+  const dir = resolve(targetPath.replace(/^~/, process.env.HOME || "/root"))
+
+  if (!existsSync(dir)) {
+    throw new Error(`Directory does not exist: ${dir}`)
+  }
+
+  const projectId = getInitialCommit(dir)
+  if (!projectId) {
+    throw new Error(
+      `Target directory is not inside a git repository.\n` +
+        `/cd and /mv only work with git repos — non-git directories ` +
+        `share a single "global" project in opencode, making session moves unreliable.`,
+    )
+  }
+
+  return { dir, projectId }
+}
+
+/** Reads session directory and project ID from the database. */
+export function getSessionInfo(
+  db: Database,
+  sessionId: string,
+): { directory: string; projectId: string } | null {
+  const row = db
+    .query("SELECT directory, project_id FROM session WHERE id = ?")
+    .get(sessionId) as { directory: string; project_id: string } | null
+  if (!row) return null
+  return { directory: row.directory, projectId: row.project_id }
+}
+
+/**
+ * Scans early assistant messages for `path.cwd` to determine the
+ * directory the session was originally operating in.
+ */
+export function getCurrentDirectory(db: Database, sessionId: string): string | null {
+  const rows = db
+    .query("SELECT data FROM message WHERE session_id = ? ORDER BY rowid ASC LIMIT 10")
+    .all(sessionId) as { data: string }[]
+
+  for (const row of rows) {
+    try {
+      const data = JSON.parse(row.data)
+      if (data.path?.cwd) return data.path.cwd
+    } catch {
+      continue
+    }
+  }
+
+  return null
+}
+
+// ---------------------------------------------------------------------------
+// Core operation
+// ---------------------------------------------------------------------------
+
+export interface ExecResult {
+  result: string
+  oldDir?: string
+  newDir?: string
+}
+
+/**
+ * Moves a session to a new directory.
+ *
+ * @param rewrite - When true (`/mv`), rewrites message history paths.
+ *   When false (`/cd`), leaves history intact.
+ * @param db - Optional database instance (uses default path if omitted).
+ */
+export function execMove(
+  sessionId: string,
+  targetPath: string,
+  rewrite: boolean,
+  db?: Database,
+): ExecResult {
+  const { dir, projectId } = resolveTarget(targetPath)
+  const owned = !db
+  if (!db) {
+    const stateDir = `${process.env.XDG_DATA_HOME || process.env.HOME + "/.local/share"}/opencode`
+    db = new Database(`${stateDir}/opencode.db`)
+  }
+
+  try {
+    const session = getSessionInfo(db, sessionId)
+    if (!session) {
+      return { result: `Error: session ${sessionId} not found in database.` }
+    }
+
+    const currentDir = getCurrentDirectory(db, sessionId) ?? session.directory
+    if (dir === currentDir) {
+      return { result: `Already in ${dir} — no change needed.` }
+    }
+
+    ensureProject(db, projectId, dir)
+    const changes = updateSession(db, sessionId, dir, projectId)
+    if (changes === 0) {
+      return { result: `Error: session ${sessionId} not found in database.` }
+    }
+
+    const lines = rewrite
+      ? (() => {
+          const { total, rewritten } = rewriteMessages(db!, sessionId, currentDir, dir)
+          return [
+            `Session moved: ${currentDir} -> ${dir}`,
+            `Project: ${projectId}`,
+            `Messages: ${rewritten}/${total} rewritten`,
+          ]
+        })()
+      : [`Session directory changed: ${currentDir} -> ${dir}`, `Project: ${projectId}`]
+
+    lines.push("", `Tools will now operate in ${dir} for this session.`)
+    lines.push(`Restart opencode in the new directory for a clean slate.`)
+
+    return { oldDir: currentDir, newDir: dir, result: lines.join("\n") }
+  } finally {
+    if (owned) db.close()
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Path rewriting
+// ---------------------------------------------------------------------------
+
+/** Replaces `oldDir` prefix with `newDir` in a file path. */
+export function rewritePath(filePath: string, oldDir: string, newDir: string): string {
+  if (filePath === oldDir) return newDir
+  if (filePath.startsWith(oldDir + "/")) return newDir + filePath.slice(oldDir.length)
+  return filePath
+}
+
+/** Map of tool IDs to arg keys that carry file paths. */
+export const PATH_TOOLS: Record<string, string[]> = {
+  read: ["filePath"],
+  write: ["filePath"],
+  edit: ["filePath"],
+  glob: ["path"],
+  grep: ["path"],
+  bash: ["workdir"],
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "opencode-dir",
+  "version": "0.1.0",
+  "description": "Directory operations for opencode sessions",
+  "type": "module",
+  "license": "MIT",
+  "main": "index.ts",
+  "files": [
+    "index.ts",
+    "lib.ts"
+  ],
+  "scripts": {
+    "test": "bun test"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "cd",
+    "mv",
+    "directory",
+    "monorepo"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adiled/opencode-dir.git"
+  },
+  "homepage": "https://github.com/adiled/opencode-dir#readme",
+  "bugs": {
+    "url": "https://github.com/adiled/opencode-dir/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.2.0"
+  }
+}