opencode-planpilot 0.1.0

package/src/lib/argv.ts

@@ -0,0 +1,58 @@
+import { invalidInput } from "./errors"
+
+export function parseCommandArgs(input: string): string[] {
+  const args: string[] = []
+  let current = ""
+  let inSingle = false
+  let inDouble = false
+  let escapeNext = false
+
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i]
+
+    if (escapeNext) {
+      current += ch
+      escapeNext = false
+      continue
+    }
+
+    if (ch === "\\" && !inSingle) {
+      escapeNext = true
+      continue
+    }
+
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle
+      continue
+    }
+
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble
+      continue
+    }
+
+    if (!inSingle && !inDouble && /\s/.test(ch)) {
+      if (current.length) {
+        args.push(current)
+        current = ""
+      }
+      continue
+    }
+
+    current += ch
+  }
+
+  if (escapeNext) {
+    current += "\\"
+  }
+
+  if (inSingle || inDouble) {
+    throw invalidInput("unterminated quote in command")
+  }
+
+  if (current.length) {
+    args.push(current)
+  }
+
+  return args
+}

package/src/lib/db.ts

@@ -0,0 +1,108 @@
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { Database } from "bun:sqlite"
+import { xdgConfig } from "xdg-basedir"
+
+export type DatabaseConnection = Database
+
+let cachedDb: Database | null = null
+
+export function resolveConfigRoot(): string {
+  if (process.env.OPENCODE_CONFIG_DIR) {
+    return process.env.OPENCODE_CONFIG_DIR
+  }
+  const base = xdgConfig ?? path.join(os.homedir(), ".config")
+  return path.join(base, "opencode")
+}
+
+export function resolvePlanpilotDir(): string {
+  const override = process.env.OPENCODE_PLANPILOT_DIR || process.env.OPENCODE_PLANPILOT_HOME
+  if (override && override.trim()) return override
+  return path.join(resolveConfigRoot(), ".planpilot")
+}
+
+export function resolveDbPath(): string {
+  return path.join(resolvePlanpilotDir(), "planpilot.db")
+}
+
+export function resolvePlanMarkdownDir(): string {
+  return path.join(resolvePlanpilotDir(), "plans")
+}
+
+export function resolvePlanMarkdownPath(planId: number): string {
+  return path.join(resolvePlanMarkdownDir(), `plan_${planId}.md`)
+}
+
+export function ensureParentDir(filePath: string) {
+  const dir = path.dirname(filePath)
+  fs.mkdirSync(dir, { recursive: true })
+}
+
+export function openDatabase(): Database {
+  if (cachedDb) return cachedDb
+  const dbPath = resolveDbPath()
+  ensureParentDir(dbPath)
+  const db = new Database(dbPath)
+  db.exec("PRAGMA foreign_keys = ON;")
+  ensureSchema(db)
+  cachedDb = db
+  return db
+}
+
+export function ensureSchema(db: Database) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS plans (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL,
+      comment TEXT,
+      last_session_id TEXT,
+      last_cwd TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS steps (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      plan_id INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL,
+      executor TEXT NOT NULL,
+      sort_order INTEGER NOT NULL,
+      comment TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(plan_id) REFERENCES plans(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS goals (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      step_id INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL,
+      comment TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(step_id) REFERENCES steps(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS active_plan (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      plan_id INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      UNIQUE(session_id),
+      UNIQUE(plan_id),
+      FOREIGN KEY(plan_id) REFERENCES plans(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_steps_plan_order ON steps(plan_id, sort_order);
+    CREATE INDEX IF NOT EXISTS idx_goals_step ON goals(step_id);
+  `)
+
+  const columns = db
+    .prepare("PRAGMA table_info(plans)")
+    .all()
+    .map((row: any) => row.name as string)
+  if (!columns.includes("last_cwd")) {
+    db.exec("ALTER TABLE plans ADD COLUMN last_cwd TEXT")
+  }
+}

package/src/lib/errors.ts

@@ -0,0 +1,36 @@
+export type AppErrorKind = "InvalidInput" | "NotFound" | "Db" | "Io" | "Json"
+
+export class AppError extends Error {
+  public readonly kind: AppErrorKind
+  public readonly detail: string
+
+  constructor(kind: AppErrorKind, detail: string) {
+    super(detail)
+    this.kind = kind
+    this.detail = detail
+  }
+
+  toDisplayString(): string {
+    const label = this.kind === "InvalidInput" ? "Invalid input" : this.kind === "NotFound" ? "Not found" : null
+    if (!label) {
+      return this.detail
+    }
+    if (this.detail.includes("\n")) {
+      return `${label}:\n${this.detail}`
+    }
+    return `${label}: ${this.detail}`
+  }
+}
+
+export function invalidInput(message: string): AppError {
+  return new AppError("InvalidInput", message)
+}
+
+export function notFound(message: string): AppError {
+  return new AppError("NotFound", message)
+}
+
+export function wrapDbError(message: string, err: unknown): AppError {
+  const detail = err instanceof Error ? `${message}: ${err.message}` : message
+  return new AppError("Db", detail)
+}

package/src/lib/format.ts

@@ -0,0 +1,239 @@
+import type { GoalRow, PlanRow, StepRow, PlanDetail } from "./models"
+import { formatDateTimeUTC } from "./util"
+
+function hasText(value?: string | null) {
+  return value !== undefined && value !== null && value.trim().length > 0
+}
+
+export function formatStepDetail(step: StepRow, goals: GoalRow[]): string {
+  let output = ""
+  output += `Step ID: ${step.id}\n`
+  output += `Plan ID: ${step.plan_id}\n`
+  output += `Status: ${step.status}\n`
+  output += `Executor: ${step.executor}\n`
+  output += `Content: ${step.content}\n`
+  if (hasText(step.comment)) {
+    output += `Comment: ${step.comment ?? ""}\n`
+  }
+  output += `Created: ${formatDateTimeUTC(step.created_at)}\n`
+  output += `Updated: ${formatDateTimeUTC(step.updated_at)}\n`
+  output += "\n"
+  if (!goals.length) {
+    output += "Goals: (none)"
+    return output.trimEnd()
+  }
+  output += "Goals:\n"
+  for (const goal of goals) {
+    output += `- [${goal.status}] ${goal.content} (goal id ${goal.id})\n`
+    if (hasText(goal.comment)) {
+      output += `  Comment: ${goal.comment ?? ""}\n`
+    }
+  }
+  return output.trimEnd()
+}
+
+export function formatGoalDetail(goal: GoalRow, step: StepRow): string {
+  let output = ""
+  output += `Goal ID: ${goal.id}\n`
+  output += `Step ID: ${goal.step_id}\n`
+  output += `Plan ID: ${step.plan_id}\n`
+  output += `Status: ${goal.status}\n`
+  output += `Content: ${goal.content}\n`
+  if (hasText(goal.comment)) {
+    output += `Comment: ${goal.comment ?? ""}\n`
+  }
+  output += `Created: ${formatDateTimeUTC(goal.created_at)}\n`
+  output += `Updated: ${formatDateTimeUTC(goal.updated_at)}\n`
+  output += "\n"
+  output += `Step Status: ${step.status}\n`
+  output += `Step Executor: ${step.executor}\n`
+  output += `Step Content: ${step.content}\n`
+  if (hasText(step.comment)) {
+    output += `Step Comment: ${step.comment ?? ""}\n`
+  }
+  return output.trimEnd()
+}
+
+export function formatPlanDetail(plan: PlanRow, steps: StepRow[], goals: Map<number, GoalRow[]>): string {
+  let output = ""
+  output += `Plan ID: ${plan.id}\n`
+  output += `Title: ${plan.title}\n`
+  output += `Status: ${plan.status}\n`
+  output += `Content: ${plan.content}\n`
+  if (hasText(plan.comment)) {
+    output += `Comment: ${plan.comment ?? ""}\n`
+  }
+  output += `Created: ${formatDateTimeUTC(plan.created_at)}\n`
+  output += `Updated: ${formatDateTimeUTC(plan.updated_at)}\n`
+  output += "\n"
+  if (!steps.length) {
+    output += "Steps: (none)"
+    return output.trimEnd()
+  }
+  output += "Steps:\n"
+  for (const step of steps) {
+    const stepGoals = goals.get(step.id) ?? []
+    if (stepGoals.length) {
+      const done = stepGoals.filter((goal) => goal.status === "done").length
+      output += `- [${step.status}] ${step.content} (step id ${step.id}, exec ${step.executor}, goals ${done}/${stepGoals.length})\n`
+    } else {
+      output += `- [${step.status}] ${step.content} (step id ${step.id}, exec ${step.executor})\n`
+    }
+    if (hasText(step.comment)) {
+      output += `  Comment: ${step.comment ?? ""}\n`
+    }
+    if (stepGoals.length) {
+      for (const goal of stepGoals) {
+        output += `  - [${goal.status}] ${goal.content} (goal id ${goal.id})\n`
+        if (hasText(goal.comment)) {
+          output += `    Comment: ${goal.comment ?? ""}\n`
+        }
+      }
+    }
+  }
+  return output.trimEnd()
+}
+
+export function formatPlanMarkdown(
+  active: boolean,
+  activeUpdated: number | null,
+  plan: PlanRow,
+  steps: StepRow[],
+  goals: Map<number, GoalRow[]>,
+): string {
+  const lines: string[] = []
+
+  const checkbox = (status: string) => (status === "done" ? "x" : " ")
+
+  const collapseHeading = (text: string) => {
+    const normalized = text.replace(/\r\n/g, "\n")
+    const parts = normalized
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+    if (!parts.length) return "(untitled)"
+    return parts.join(" / ")
+  }
+
+  const splitTaskText = (text: string): [string, string[]] => {
+    const normalized = text.replace(/\r\n/g, "\n")
+    const rawLines = normalized.split("\n")
+    if (!rawLines.length) return ["(empty)", []]
+    let firstIdx = -1
+    for (let i = 0; i < rawLines.length; i += 1) {
+      if (rawLines[i].trim()) {
+        firstIdx = i
+        break
+      }
+    }
+    if (firstIdx === -1) return ["(empty)", []]
+    return [rawLines[firstIdx], rawLines.slice(firstIdx + 1)]
+  }
+
+  const pushLine = (indent: number, text: string) => {
+    lines.push(`${" ".repeat(indent)}${text}`)
+  }
+  const pushBlank = (indent: number) => {
+    lines.push(indent === 0 ? "" : " ".repeat(indent))
+  }
+
+  pushLine(0, "# Plan")
+  pushBlank(0)
+  pushLine(0, `## Plan: ${collapseHeading(plan.title)}`)
+  pushBlank(0)
+  pushLine(0, `- **Active:** \`${active ? "true" : "false"}\``)
+  pushLine(0, `- **Plan ID:** \`${plan.id}\``)
+  pushLine(0, `- **Status:** \`${plan.status}\``)
+  if (hasText(plan.comment)) {
+    pushLine(0, `- **Comment:** ${plan.comment ?? ""}`)
+  }
+  if (activeUpdated) {
+    pushLine(0, `- **Activated:** ${formatDateTimeUTC(activeUpdated)}`)
+  }
+  pushLine(0, `- **Created:** ${formatDateTimeUTC(plan.created_at)}`)
+  pushLine(0, `- **Updated:** ${formatDateTimeUTC(plan.updated_at)}`)
+  const stepsDone = steps.filter((step) => step.status === "done").length
+  pushLine(0, `- **Steps:** ${stepsDone}/${steps.length}`)
+  pushBlank(0)
+
+  pushLine(0, "### Plan Content")
+  pushBlank(0)
+  if (!plan.content.trim()) {
+    pushLine(0, "*No content*")
+  } else {
+    const normalized = plan.content.replace(/\r\n/g, "\n")
+    for (const line of normalized.split("\n")) {
+      if (!line.length) {
+        pushLine(0, ">")
+      } else {
+        pushLine(0, `> ${line}`)
+      }
+    }
+  }
+  pushBlank(0)
+
+  pushLine(0, "### Steps")
+  pushBlank(0)
+  if (!steps.length) {
+    pushLine(0, "*No steps*")
+    return lines.join("\n").trimEnd()
+  }
+
+  steps.forEach((step, idx) => {
+    const [firstLine, restLines] = splitTaskText(step.content)
+    pushLine(0, `- [${checkbox(step.status)}] **${firstLine}** *(id: ${step.id}, exec: ${step.executor}, order: ${step.sort_order})*`)
+
+    let hasRest = false
+    for (const line of restLines) {
+      if (!line.trim()) continue
+      if (!hasRest) {
+        pushBlank(2)
+        hasRest = true
+      } else {
+        pushBlank(2)
+      }
+      pushLine(2, line)
+    }
+
+    pushBlank(2)
+    pushLine(2, `- Created: ${formatDateTimeUTC(step.created_at)}`)
+    pushLine(2, `- Updated: ${formatDateTimeUTC(step.updated_at)}`)
+    if (hasText(step.comment)) {
+      pushLine(2, `- Comment: ${step.comment ?? ""}`)
+    }
+
+    const stepGoals = goals.get(step.id)
+    if (stepGoals && stepGoals.length) {
+      const done = stepGoals.filter((goal) => goal.status === "done").length
+      pushLine(2, `- Goals: ${done}/${stepGoals.length}`)
+      for (const goal of stepGoals) {
+        const [goalFirst, goalRest] = splitTaskText(goal.content)
+        pushBlank(2)
+        pushLine(2, `- [${checkbox(goal.status)}] ${goalFirst} *(id: ${goal.id})*`)
+        for (const line of goalRest) {
+          if (!line.trim()) continue
+          pushBlank(4)
+          pushLine(4, line)
+        }
+        if (hasText(goal.comment)) {
+          pushBlank(4)
+          pushLine(4, `Comment: ${goal.comment ?? ""}`)
+        }
+      }
+    } else {
+      pushLine(2, "- Goals: 0/0")
+      pushBlank(2)
+      pushLine(2, "- (none)")
+    }
+
+    if (idx + 1 < steps.length) {
+      pushBlank(0)
+    }
+  })
+
+  return lines.join("\n").trimEnd()
+}
+
+export function planDetailToMarkdown(detail: PlanDetail, active: boolean, activeUpdated: number | null): string {
+  return formatPlanMarkdown(active, activeUpdated, detail.plan, detail.steps, detail.goals)
+}

package/src/lib/instructions.ts

@@ -0,0 +1,26 @@
+import fs from "fs"
+import path from "path"
+import { fileURLToPath } from "url"
+
+let cached: string | null = null
+
+export function loadPlanpilotInstructions(): string {
+  if (cached !== null) return cached
+  try {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url))
+    const candidates = [
+      path.resolve(moduleDir, "../../docs/planpilot.md"),
+      path.resolve(moduleDir, "../../../docs/planpilot.md"),
+    ]
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        cached = fs.readFileSync(candidate, "utf8")
+        return cached
+      }
+    }
+    cached = ""
+  } catch {
+    cached = ""
+  }
+  return cached
+}

package/src/lib/models.ts

@@ -0,0 +1,144 @@
+export type PlanStatus = "todo" | "done"
+export type StepStatus = "todo" | "done"
+export type GoalStatus = "todo" | "done"
+export type StepExecutor = "ai" | "human"
+
+export interface PlanRow {
+  id: number
+  title: string
+  content: string
+  status: PlanStatus
+  comment: string | null
+  last_session_id: string | null
+  last_cwd: string | null
+  created_at: number
+  updated_at: number
+}
+
+export interface StepRow {
+  id: number
+  plan_id: number
+  content: string
+  status: StepStatus
+  executor: StepExecutor
+  sort_order: number
+  comment: string | null
+  created_at: number
+  updated_at: number
+}
+
+export interface GoalRow {
+  id: number
+  step_id: number
+  content: string
+  status: GoalStatus
+  comment: string | null
+  created_at: number
+  updated_at: number
+}
+
+export interface ActivePlanRow {
+  id: number
+  session_id: string
+  plan_id: number
+  updated_at: number
+}
+
+export interface PlanDetail {
+  plan: PlanRow
+  steps: StepRow[]
+  goals: Map<number, GoalRow[]>
+}
+
+export interface StepDetail {
+  step: StepRow
+  goals: GoalRow[]
+}
+
+export interface GoalDetail {
+  goal: GoalRow
+  step: StepRow
+}
+
+export interface StepInput {
+  content: string
+  executor: StepExecutor
+  goals: string[]
+}
+
+export interface StepStatusChange {
+  step_id: number
+  from: string
+  to: string
+  reason: string
+}
+
+export interface PlanStatusChange {
+  plan_id: number
+  from: string
+  to: string
+  reason: string
+}
+
+export interface ActivePlanCleared {
+  plan_id: number
+  reason: string
+}
+
+export interface StatusChanges {
+  steps: StepStatusChange[]
+  plans: PlanStatusChange[]
+  active_plans_cleared: ActivePlanCleared[]
+}
+
+export interface PlanChanges {
+  title?: string
+  content?: string
+  status?: PlanStatus
+  comment?: string
+}
+
+export interface StepChanges {
+  content?: string
+  status?: StepStatus
+  executor?: StepExecutor
+  comment?: string
+}
+
+export interface GoalChanges {
+  content?: string
+  status?: GoalStatus
+  comment?: string
+}
+
+export type PlanOrder = "id" | "title" | "created" | "updated"
+export type StepOrder = "order" | "id" | "created" | "updated"
+
+export interface StepQuery {
+  status?: StepStatus | null
+  executor?: StepExecutor | null
+  limit?: number
+  offset?: number
+  order?: StepOrder
+  desc?: boolean
+}
+
+export interface GoalQuery {
+  status?: GoalStatus | null
+  limit?: number
+  offset?: number
+}
+
+export function createEmptyStatusChanges(): StatusChanges {
+  return { steps: [], plans: [], active_plans_cleared: [] }
+}
+
+export function mergeStatusChanges(target: StatusChanges, other: StatusChanges) {
+  target.steps.push(...other.steps)
+  target.plans.push(...other.plans)
+  target.active_plans_cleared.push(...other.active_plans_cleared)
+}
+
+export function statusChangesEmpty(changes: StatusChanges) {
+  return !changes.steps.length && !changes.plans.length && !changes.active_plans_cleared.length
+}

package/src/lib/util.ts

@@ -0,0 +1,76 @@
+import fs from "fs"
+import path from "path"
+import { invalidInput } from "./errors"
+
+export function ensureNonEmpty(label: string, value: string) {
+  if (value.trim().length === 0) {
+    throw invalidInput(`${label} cannot be empty`)
+  }
+}
+
+export function formatDateTimeUTC(timestamp: number): string {
+  const date = new Date(timestamp)
+  const yyyy = date.getUTCFullYear()
+  const mm = String(date.getUTCMonth() + 1).padStart(2, "0")
+  const dd = String(date.getUTCDate()).padStart(2, "0")
+  const hh = String(date.getUTCHours()).padStart(2, "0")
+  const min = String(date.getUTCMinutes()).padStart(2, "0")
+  return `${yyyy}-${mm}-${dd} ${hh}:${min}`
+}
+
+export function uniqueIds(ids: number[]): number[] {
+  const seen = new Set<number>()
+  const unique: number[] = []
+  for (const id of ids) {
+    if (!seen.has(id)) {
+      seen.add(id)
+      unique.push(id)
+    }
+  }
+  return unique
+}
+
+export function joinIds(ids: number[]): string {
+  return ids.map((id) => String(id)).join(", ")
+}
+
+export function normalizeCommentEntries(entries: Array<[number, string]>): Array<[number, string]> {
+  const seen = new Map<number, number>()
+  const ordered: Array<[number, string]> = []
+  for (const [id, comment] of entries) {
+    const idx = seen.get(id)
+    if (idx !== undefined) {
+      ordered[idx][1] = comment
+    } else {
+      seen.set(id, ordered.length)
+      ordered.push([id, comment])
+    }
+  }
+  return ordered
+}
+
+export function resolveMaybeRealpath(value: string): string {
+  try {
+    return fs.realpathSync.native(value)
+  } catch {
+    return value
+  }
+}
+
+export function normalizePath(value: string): string {
+  let resolved = resolveMaybeRealpath(value)
+  resolved = path.resolve(resolved)
+  if (process.platform === "win32") {
+    resolved = resolved.toLowerCase()
+  }
+  return resolved.replace(/[\\/]+$/, "")
+}
+
+export function projectMatchesPath(project: string, current: string): boolean {
+  const projectNorm = normalizePath(project)
+  const currentNorm = normalizePath(current)
+  if (projectNorm === currentNorm) return true
+  if (currentNorm.startsWith(projectNorm + path.sep)) return true
+  if (projectNorm.startsWith(currentNorm + path.sep)) return true
+  return false
+}