@otto-assistant/otto 0.1.2 → 0.7.16

package/dist/config.js

@@ -1,264 +1,109 @@
-import fs from "node:fs";
-import path from "node:path";
-import { OPENCODE_CONFIG_DIR } from "./manifest.js";
-/** Defaults used when otto.json is missing or partial. */
-export const OTTO_DEFAULTS = {
-    subagentThreads: {
-        enabled: true,
-        askBeforeDelete: true,
-        autoDeleteOnComplete: false,
-    },
-};
-export function mergePlugins(config, pluginToAdd) {
-    const plugins = config.plugin ?? [];
-    if (plugins.includes(pluginToAdd)) {
-        return config;
-    }
-    return { ...config, plugin: [...plugins, pluginToAdd] };
+// 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() {
+    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 function readOttoConfig(dir) {
-    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);
-        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 };
-    }
+/**
+ * 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) {
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        fs.mkdirSync(resolvedDir, { recursive: true });
+    }
+    store.setState({ dataDir: resolvedDir });
 }
-export function writeOttoConfig(config, dir) {
-    const configDir = dir ?? OPENCODE_CONFIG_DIR();
-    const configPath = path.join(configDir, "otto.json");
-    let existing = null;
-    try {
-        existing = fs.readFileSync(configPath, "utf-8");
-    }
-    catch {
-        // file doesn't exist
-    }
-    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;
+/**
+ * Get the projects directory path (for /create-new-project command).
+ * Returns the custom --projects-dir if set, otherwise <dataDir>/projects.
+ */
+export function getProjectsDir() {
+    const custom = store.getState().projectsDir;
+    if (custom) {
+        return custom;
+    }
+    return path.join(getDataDir(), 'projects');
 }
-export function buildSubagentThreadPolicy(ottoConfig) {
-    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", "");
-    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).");
-    }
-    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");
+/**
+ * Set a custom projects directory path (from --projects-dir CLI flag).
+ * Creates the directory if it doesn't exist.
+ */
+export function setProjectsDir(dir) {
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        fs.mkdirSync(resolvedDir, { recursive: true });
+    }
+    store.setState({ projectsDir: resolvedDir });
 }
-export function mergeAgentPrompts(config, policyText) {
-    const marker = "Otto subagent policy (must follow):";
-    const agent = (config.agent ?? {});
-    const entries = Object.entries(agent);
-    if (entries.length === 0) {
-        return {
-            ...config,
-            agent: {
-                build: { prompt: policyText },
-            },
-        };
-    }
-    const nextAgent = {};
-    for (const [name, value] of entries) {
-        if (value && typeof value === "object" && !Array.isArray(value)) {
-            const typed = value;
-            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;
+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() {
+    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;
         }
     }
-    return { ...config, agent: nextAgent };
-}
-/** Distinguishes a missing file from invalid JSON (both previously surfaced as `{}`). */
-export function readOpenCodeConfigState(dir) {
-    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), status: "ok" };
-    }
-    catch {
-        return { config: {}, status: "invalid" };
-    }
-}
-export function readOpenCodeConfig(dir) {
-    return readOpenCodeConfigState(dir).config;
-}
-export function writeOpenCodeConfig(config, dir) {
-    const configDir = dir ?? OPENCODE_CONFIG_DIR();
-    const configPath = path.join(configDir, "opencode.json");
-    let existing = null;
-    try {
-        existing = fs.readFileSync(configPath, "utf-8");
-    }
-    catch {
-        // file doesn't exist
-    }
-    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;
-}
-export function ensureAgentMemoryConfig(dir) {
-    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) {
-    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
-        }
+    const dir = getDataDir();
+    // Use original port for default data dir (backwards compatible)
+    if (dir === DEFAULT_DATA_DIR) {
+        return DEFAULT_LOCK_PORT;
     }
-    catch {
-        // file doesn't exist — will create
+    // 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(skillDir, { recursive: true });
-    fs.writeFileSync(skillPath, SKILL_MD, "utf-8");
-    return true;
+    // Map to port range 30000-39999
+    return 30000 + (Math.abs(hash) % 10000);
 }
-//# sourceMappingURL=config.js.map