@otto-assistant/otto 0.1.1 → 0.7.15

package/src/condense-memory.ts

@@ -0,0 +1,36 @@
+// Utility to condense MEMORY.md into a line-numbered table of contents.
+// Separated from otto-opencode-plugin.ts because OpenCode's plugin loader calls
+// every exported function in the module as a plugin initializer — exporting
+// this utility from the plugin entry file caused it to be invoked with a
+// PluginInput object instead of a string, crashing inside marked's Lexer.
+
+import { Lexer } from 'marked'
+
+/**
+ * Condense MEMORY.md into a line-numbered table of contents.
+ * Parses markdown AST with marked's Lexer, emits each heading prefixed by
+ * its source line number, and collapses non-heading content to `...`.
+ * The agent can then use Read with offset/limit to read specific sections.
+ */
+export function condenseMemoryMd(content: string): string {
+  const tokens = new Lexer().lex(content)
+  const lines: string[] = []
+  let charOffset = 0
+  let lastWasEllipsis = false
+
+  for (const token of tokens) {
+    // Compute 1-based line number from character offset
+    const lineNumber = content.slice(0, charOffset).split('\n').length
+    if (token.type === 'heading') {
+      const prefix = '#'.repeat(token.depth)
+      lines.push(`${lineNumber}: ${prefix} ${token.text}`)
+      lastWasEllipsis = false
+    } else if (!lastWasEllipsis) {
+      lines.push('...')
+      lastWasEllipsis = true
+    }
+    charOffset += token.raw.length
+  }
+
+  return lines.join('\n')
+}

package/src/config.ts

@@ -1,362 +1,126 @@
-import fs from "node:fs"
-import path from "node:path"
-import { OPENCODE_CONFIG_DIR } from "./manifest.js"
-
-export interface OttoSubagentThreads {
-  enabled?: boolean
-  askBeforeDelete?: boolean
-  autoDeleteOnComplete?: boolean
+// Runtime configuration for Otto bot (formerly Kimaki).
+// Thin re-export layer over the centralized zustand store (store.ts).
+// Getter/setter functions are kept for backwards compatibility so existing
+// import sites don't need to change. They delegate to store.getState() and
+// store.setState() under the hood.
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { store } from './store.js'
+
+// Default data directory: ~/.otto for new installs, falls back to ~/.otto
+// for existing users to preserve their database and configuration.
+const DEFAULT_DATA_DIR = (() => {
+  const home = os.homedir()
+  const ottoDirr = path.join(home, '.otto')
+  const ottoDir = path.join(home, '.otto')
+  // If ~/.otto already exists, use it. If ~/.otto exists (legacy), use it.
+  // Otherwise default to ~/.otto for fresh installs.
+  if (fs.existsSync(ottoDirr)) {
+    return ottoDirr
+  }
+  if (fs.existsSync(ottoDir)) {
+    return ottoDir
+  }
+  return ottoDirr
+})()
+
+/**
+ * Get the data directory path.
+ * Falls back to ~/.otto (or ~/.otto for legacy installs) if not explicitly set.
+ * Under vitest (OTTO_VITEST / OTTO_VITEST env var), auto-creates an isolated
+ * temp dir so tests never touch the real data directory. Tests that need a
+ * specific dir can still call setDataDir() before any DB access to override.
+ */
+export function getDataDir(): string {
+  const current = store.getState().dataDir
+  if (current) {
+    return current
+  }
+  if (process.env.OTTO_VITEST || process.env.OTTO_VITEST) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'otto-test-'))
+    store.setState({ dataDir: tmpDir })
+    return tmpDir
+  }
+  store.setState({ dataDir: DEFAULT_DATA_DIR })
+  return DEFAULT_DATA_DIR
 }
 
-export interface OttoConfig {
-  subagentThreads: {
-    enabled: boolean
-    askBeforeDelete: boolean
-    autoDeleteOnComplete: boolean
-  }
-}
-
-/** Defaults used when otto.json is missing or partial. */
-export const OTTO_DEFAULTS: OttoConfig = {
-  subagentThreads: {
-    enabled: true,
-    askBeforeDelete: true,
-    autoDeleteOnComplete: false,
-  },
-}
+/**
+ * Set the data directory path.
+ * Creates the directory if it doesn't exist.
+ * Must be called before any database or path-dependent operations.
+ */
+export function setDataDir(dir: string): void {
+  const resolvedDir = path.resolve(dir)
 
-export interface OpenCodeConfig {
-  $schema?: string
-  model?: string
-  plugin?: string[]
-  provider?: Record<string, unknown>
-  agent?: Record<string, unknown>
-  [key: string]: unknown
-}
-
-export function mergePlugins(config: OpenCodeConfig, pluginToAdd: string): OpenCodeConfig {
-  const plugins = config.plugin ?? []
-  if (plugins.includes(pluginToAdd)) {
-    return config
+  if (!fs.existsSync(resolvedDir)) {
+    fs.mkdirSync(resolvedDir, { recursive: true })
   }
-  return { ...config, plugin: [...plugins, pluginToAdd] }
-}
-
-// ---------------------------------------------------------------------------
-// Otto's own config (stored in ~/.config/opencode/otto.json, NOT opencode.json)
-// opencode rejects unknown keys in its config — Otto must not pollute it.
-// ---------------------------------------------------------------------------
 
-export type OttoConfigReadStatus = "missing" | "ok" | "invalid"
-
-export function readOttoConfig(dir?: string): OttoConfig {
-  const configDir = dir ?? OPENCODE_CONFIG_DIR()
-  const configPath = path.join(configDir, "otto.json")
-  try {
-    const raw = fs.readFileSync(configPath, "utf-8")
-    const parsed = JSON.parse(raw) as Partial<OttoConfig>
-    return {
-      subagentThreads: {
-        enabled: parsed.subagentThreads?.enabled ?? OTTO_DEFAULTS.subagentThreads.enabled,
-        askBeforeDelete: parsed.subagentThreads?.askBeforeDelete ?? OTTO_DEFAULTS.subagentThreads.askBeforeDelete,
-        autoDeleteOnComplete: parsed.subagentThreads?.autoDeleteOnComplete ?? OTTO_DEFAULTS.subagentThreads.autoDeleteOnComplete,
-      },
-    }
-  } catch {
-    return { ...OTTO_DEFAULTS }
-  }
+  store.setState({ dataDir: resolvedDir })
 }
 
-export function writeOttoConfig(config: OttoConfig, dir?: string): boolean {
-  const configDir = dir ?? OPENCODE_CONFIG_DIR()
-  const configPath = path.join(configDir, "otto.json")
-
-  let existing: string | null = null
-  try {
-    existing = fs.readFileSync(configPath, "utf-8")
-  } catch {
-    // file doesn't exist
+/**
+ * Get the projects directory path (for /create-new-project command).
+ * Returns the custom --projects-dir if set, otherwise <dataDir>/projects.
+ */
+export function getProjectsDir(): string {
+  const custom = store.getState().projectsDir
+  if (custom) {
+    return custom
   }
-
-  const newContent = JSON.stringify(config, null, 2) + "\n"
-  if (existing === newContent) {
-    return false
-  }
-
-  fs.mkdirSync(configDir, { recursive: true })
-  fs.writeFileSync(configPath, newContent, "utf-8")
-  return true
+  return path.join(getDataDir(), 'projects')
 }
 
-export function buildSubagentThreadPolicy(ottoConfig: OttoConfig): string {
-  const policy = ottoConfig.subagentThreads
-  const enabled = policy.enabled
-  const askBeforeDelete = policy.askBeforeDelete
-  const autoDeleteOnComplete = policy.autoDeleteOnComplete
-
-  const lines = [
-    "Otto subagent policy (must follow):",
-    `- subagent_threads_enabled: ${enabled}`,
-    `- subagent_threads_ask_before_delete: ${askBeforeDelete}`,
-    `- subagent_threads_auto_delete_on_complete: ${autoDeleteOnComplete}`,
-  ]
-
-  if (!enabled) {
-    lines.push(
-      "- subagent_threads_enabled is false — you may spawn subagents normally (Task tool or otherwise) without creating Discord threads.",
-    )
-    return lines.join("\n")
-  }
-
-  lines.push(
-    "",
-    "## Spawning subagents with Discord threads",
-    "",
-    "When you need to spawn a subagent (parallel task, background investigation, etc.), do NOT use the Task tool directly.",
-    "Instead, create a visible Discord thread using `kimaki send` via Bash:",
-    "",
-    "```bash",
-    'kimaki send --channel <channel_id> --prompt "detailed task description" --user "<username>"',
-    "```",
-    "",
-    "The channel_id and username are in your system prompt (\"Your current Discord channel ID\" / \"Discord\" user field).",
-    "",
-    "For sequential tasks where you need the result before continuing, use --wait (set Bash timeout to 1_500_000+):",
-    "```bash",
-    'kimaki send --channel <channel_id> --prompt "task" --user "<username>" --wait',
-    "```",
-    "",
-    "## After subagent completes",
-    "",
-  )
+/**
+ * Set a custom projects directory path (from --projects-dir CLI flag).
+ * Creates the directory if it doesn't exist.
+ */
+export function setProjectsDir(dir: string): void {
+  const resolvedDir = path.resolve(dir)
 
-  if (autoDeleteOnComplete) {
-    lines.push(
-      "- subagent_threads_auto_delete_on_complete is true → automatically archive the thread after the subagent finishes:",
-      "  ```bash",
-      '  kimaki session archive --session <session_id>',
-      "  ```",
-    )
-  } else if (askBeforeDelete) {
-    lines.push(
-      "- subagent_threads_ask_before_delete is true → after the subagent finishes, ask the user:",
-      '  "Subagent thread created. Should I archive it or keep it open?"',
-      "  If user says archive → `kimaki session archive --session <session_id>`",
-    )
-  } else {
-    lines.push(
-      "- Keep the subagent thread open after completion (no auto-archive, no prompt).",
-    )
+  if (!fs.existsSync(resolvedDir)) {
+    fs.mkdirSync(resolvedDir, { recursive: true })
   }
 
-  lines.push(
-    "",
-    "## Required: load skills before subagent execution",
-    "",
-    "Before dispatching any subagent, load the skill: `otto-subagent-threads`.",
-    "This ensures the subagent follows the same thread creation rules if it spawns further subagents.",
-  )
-
-  return lines.join("\n")
+  store.setState({ projectsDir: resolvedDir })
 }
 
-export function mergeAgentPrompts(config: OpenCodeConfig, policyText: string): OpenCodeConfig {
-  const marker = "Otto subagent policy (must follow):"
-  const agent = (config.agent ?? {}) as Record<string, unknown>
-  const entries = Object.entries(agent)
-
-  if (entries.length === 0) {
-    return {
-      ...config,
-      agent: {
-        build: { prompt: policyText },
-      },
+export type { RegisteredUserCommand } from './store.js'
+
+const DEFAULT_LOCK_PORT = 29988
+
+/**
+ * Derive a lock port from the data directory path.
+ * Reads OTTO_LOCK_PORT or OTTO_LOCK_PORT (in that order of preference).
+ * Returns a stable port for the default data directories.
+ * For custom data dirs, uses a hash to generate a port in the range 30000-39999.
+ */
+export function getLockPort(): number {
+  const envPortRaw = process.env['OTTO_LOCK_PORT'] || process.env['OTTO_LOCK_PORT']
+  if (envPortRaw) {
+    const envPort = Number.parseInt(envPortRaw, 10)
+    if (Number.isInteger(envPort) && envPort >= 1 && envPort <= 65535) {
+      return envPort
     }
   }
 
-  const nextAgent: Record<string, unknown> = {}
-  for (const [name, value] of entries) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      const typed = value as Record<string, unknown>
-      const existingPrompt = typeof typed.prompt === "string" ? typed.prompt : ""
-      const hasPolicy = existingPrompt.includes(marker)
-      nextAgent[name] = {
-        ...typed,
-        prompt: hasPolicy
-          ? existingPrompt
-          : (existingPrompt.length > 0 ? `${existingPrompt}\n\n${policyText}` : policyText),
-      }
-    } else {
-      nextAgent[name] = value
-    }
-  }
-
-  return { ...config, agent: nextAgent }
-}
-
-export type OpenCodeConfigReadStatus = "missing" | "ok" | "invalid"
-
-/** Distinguishes a missing file from invalid JSON (both previously surfaced as `{}`). */
-export function readOpenCodeConfigState(dir?: string): {
-  config: OpenCodeConfig
-  status: OpenCodeConfigReadStatus
-} {
-  const configDir = dir ?? OPENCODE_CONFIG_DIR()
-  const configPath = path.join(configDir, "opencode.json")
-  if (!fs.existsSync(configPath)) {
-    return { config: {}, status: "missing" }
-  }
-  try {
-    const raw = fs.readFileSync(configPath, "utf-8")
-    return { config: JSON.parse(raw) as OpenCodeConfig, status: "ok" }
-  } catch {
-    return { config: {}, status: "invalid" }
-  }
-}
-
-export function readOpenCodeConfig(dir?: string): OpenCodeConfig {
-  return readOpenCodeConfigState(dir).config
-}
-
-export function writeOpenCodeConfig(config: OpenCodeConfig, dir?: string): boolean {
-  const configDir = dir ?? OPENCODE_CONFIG_DIR()
-  const configPath = path.join(configDir, "opencode.json")
+  const dir = getDataDir()
 
-  let existing: string | null = null
-  try {
-    existing = fs.readFileSync(configPath, "utf-8")
-  } catch {
-    // file doesn't exist
+  // Use original port for default data dir (backwards compatible)
+  if (dir === DEFAULT_DATA_DIR) {
+    return DEFAULT_LOCK_PORT
   }
 
-  const newContent = JSON.stringify(config, null, 2) + "\n"
-  if (existing === newContent) {
-    return false
+  // Hash-based port for custom data dirs
+  let hash = 0
+  for (let i = 0; i < dir.length; i++) {
+    const char = dir.charCodeAt(i)
+    hash = (hash << 5) - hash + char
+    hash = hash & hash // Convert to 32bit integer
   }
-
-  fs.mkdirSync(configDir, { recursive: true })
-  fs.writeFileSync(configPath, newContent, "utf-8")
-  return true
-}
-
-export function ensureAgentMemoryConfig(dir?: string): boolean {
-  const configDir = dir ?? OPENCODE_CONFIG_DIR()
-  const configPath = path.join(configDir, "agent-memory.json")
-
-  try {
-    fs.readFileSync(configPath, "utf-8")
-    return false
-  } catch {
-    // create with defaults
-  }
-
-  const defaults = {
-    journal: {
-      enabled: true,
-      tags: [
-        { name: "infra", description: "Infrastructure changes, host/service topology, runtime environment" },
-        { name: "debugging", description: "Bug investigations, root-cause analysis, and troubleshooting" },
-        { name: "decision", description: "Architecture and implementation decisions with rationale" },
-        { name: "incident", description: "Service failures, outages, and recovery actions" },
-        { name: "automation", description: "Agent workflows, scripts, and repeatable operational routines" },
-      ],
-    },
-  }
-
-  fs.mkdirSync(configDir, { recursive: true })
-  fs.writeFileSync(configPath, JSON.stringify(defaults, null, 2) + "\n", "utf-8")
-  return true
-}
-
-// ---------------------------------------------------------------------------
-// Skill file: otto-subagent-threads
-// ---------------------------------------------------------------------------
-
-const SKILL_NAME = "otto-subagent-threads"
-
-const SKILL_MD = `---
-name: otto-subagent-threads
-description: Enforce visible Discord threads for every subagent spawn. Use before dispatching any subagent via kimaki send.
----
-
-# Otto Subagent Threads
-
-## When to Use
-
-Use this skill EVERY TIME you are about to spawn a subagent (parallel task, background investigation, code review, etc.).
-
-## Rules
-
-### 1. NEVER use Task tool directly for subagents
-
-The Task tool spawns a subagent in "shadow mode" — invisible to the user in Discord.
-Instead, create a visible Discord thread.
-
-### 2. Create a Discord thread with kimaki send
-
-\`\`\`bash
-kimaki send --channel <channel_id> --prompt "detailed task description" --user "<username>"
-\`\`\`
-
-Get channel_id and username from your system prompt:
-- "Your current Discord channel ID is: ..."
-- Discord user info section
-
-### 3. Wait for result if needed
-
-If you need the subagent's output before continuing, add \`--wait\` and set Bash timeout to 1_500_000+:
-
-\`\`\`bash
-kimaki send --channel <channel_id> --prompt "task" --user "<username>" --wait
-\`\`\`
-
-### 4. After subagent completes
-
-Check the otto.subagentThreads config:
-- **autoDeleteOnComplete = true** → archive the thread:
-  \`\`\`bash
-  kimaki session archive --session <session_id>
-  \`\`\`
-- **askBeforeDelete = true** → ask the user:
-  "Subagent finished. Should I archive the thread or keep it open?"
-- **both false** → keep the thread open.
-
-### 5. Nested subagents
-
-If your subagent itself needs to spawn further subagents, include these same rules in its prompt so it also creates visible threads.
-
-## Quick Reference
-
-| Scenario | Command |
-|----------|---------|
-| Parallel task (fire & forget) | \`kimaki send -c <ch> -p "task" -u <user>\` |
-| Sequential task (need result) | \`kimaki send -c <ch> -p "task" -u <user> --wait\` |
-| Archive thread | \`kimaki session archive -s <session_id>\` |
-| List sessions | \`kimaki session list\` |
-| Read session output | \`kimaki session read <session_id> > ./tmp/session.md 2>/dev/null\` |
-
-## Anti-patterns
-
-- **DO NOT** use the Task tool to spawn subagents (creates invisible shadow sessions).
-- **DO NOT** create worktrees (\`--worktree\`) unless the user explicitly asks.
-- **DO NOT** forget to include your channel_id in the kimaki send command.
-`
-
-export function ensureSubagentThreadSkill(dir?: string): boolean {
-  const configDir = dir ?? OPENCODE_CONFIG_DIR()
-  const skillDir = path.join(configDir, "skills", SKILL_NAME)
-  const skillPath = path.join(skillDir, "SKILL.md")
-
-  try {
-    const existing = fs.readFileSync(skillPath, "utf-8")
-    if (existing === SKILL_MD) {
-      return false // already up to date
-    }
-  } catch {
-    // file doesn't exist — will create
-  }
-
-  fs.mkdirSync(skillDir, { recursive: true })
-  fs.writeFileSync(skillPath, SKILL_MD, "utf-8")
-  return true
+  // Map to port range 30000-39999
+  return 30000 + (Math.abs(hash) % 10000)
 }

package/src/context-awareness-plugin.test.ts

@@ -0,0 +1,144 @@
+// Tests for context-awareness directory switch reminders.
+
+import { describe, expect, test } from 'vitest'
+import {
+  shouldInjectPwd,
+  shouldInjectMemoryReminderFromLatestAssistant,
+} from './context-awareness-plugin.js'
+
+describe('shouldInjectPwd', () => {
+  test('does not inject when current directory matches announced directory', () => {
+    const result = shouldInjectPwd({
+      currentDir: '/repo/worktree',
+      previousDir: '/repo/main',
+      announcedDir: '/repo/worktree',
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `)
+  })
+
+  test('does not inject without a previous directory to warn about', () => {
+    const result = shouldInjectPwd({
+      currentDir: '/repo/worktree',
+      previousDir: undefined,
+      announcedDir: undefined,
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `)
+  })
+
+  test('names previous and current directories in the correct order', () => {
+    const result = shouldInjectPwd({
+      currentDir: '/repo/worktree',
+      previousDir: '/repo/main',
+      announcedDir: undefined,
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": true,
+        "text": "
+      [working directory changed (cwd / pwd has changed). The user expects you to edit files in the new cwd. Previous folder (DO NOT TOUCH): /repo/main. New folder (new cwd / pwd, edit files here): /repo/worktree. You MUST read, write, and edit files only under the new folder /repo/worktree. You MUST NOT read, write, or edit any files under the previous folder /repo/main — that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes.]
+      ",
+      }
+    `)
+  })
+
+  test('prefers the last announced directory as the previous directory', () => {
+    const result = shouldInjectPwd({
+      currentDir: '/repo/worktree-b',
+      previousDir: '/repo/main',
+      announcedDir: '/repo/worktree-a',
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": true,
+        "text": "
+      [working directory changed (cwd / pwd has changed). The user expects you to edit files in the new cwd. Previous folder (DO NOT TOUCH): /repo/worktree-a. New folder (new cwd / pwd, edit files here): /repo/worktree-b. You MUST read, write, and edit files only under the new folder /repo/worktree-b. You MUST NOT read, write, or edit any files under the previous folder /repo/worktree-a — that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes.]
+      ",
+      }
+    `)
+  })
+})
+
+describe('shouldInjectMemoryReminderFromLatestAssistant', () => {
+  test('does not trigger before threshold', () => {
+    const result = shouldInjectMemoryReminderFromLatestAssistant({
+      latestAssistantMessage: {
+        id: 'msg_asst_1',
+        role: 'assistant',
+        time: { completed: 1 },
+        tokens: {
+          input: 1_000,
+          output: 3_000,
+          reasoning: 500,
+          cache: { read: 0, write: 0 },
+        },
+      },
+      threshold: 10_000,
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `)
+  })
+
+  test('triggers when latest assistant message exceeds threshold', () => {
+    const result = shouldInjectMemoryReminderFromLatestAssistant({
+      latestAssistantMessage: {
+        id: 'msg_asst_2',
+        role: 'assistant',
+        time: { completed: 2 },
+        tokens: {
+          input: 2_000,
+          output: 2_200,
+          reasoning: 400,
+          cache: { read: 0, write: 0 },
+        },
+      },
+      threshold: 2_000,
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "assistantMessageId": "msg_asst_2",
+        "inject": true,
+      }
+    `)
+  })
+
+  test('does not trigger again for the same reminded assistant message', () => {
+    const result = shouldInjectMemoryReminderFromLatestAssistant({
+      lastMemoryReminderAssistantMessageId: 'msg_asst_3',
+      latestAssistantMessage: {
+        id: 'msg_asst_3',
+        role: 'assistant',
+        time: { completed: 3 },
+        tokens: {
+          input: 2_000,
+          output: 2_200,
+          reasoning: 400,
+          cache: { read: 0, write: 0 },
+        },
+      },
+      threshold: 10_000,
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `)
+  })
+})