@aurora-foundation/obsidian-next 0.4.7 → 0.4.9

package/dist/chunk-EMBMLZFE.js

@@ -0,0 +1,370 @@
+import {
+  config
+} from "./chunk-PWA7V4XX.js";
+import {
+  settings
+} from "./chunk-EPG5V5OO.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+import {
+  db
+} from "./chunk-FNLWB54Z.js";
+
+// src/core/context.ts
+import path from "path";
+var CONTEXT_CONFIG = {
+  DECAY_HALF_LIFE_MS: 36e5,
+  // 1 hour - files lose half their score every hour
+  MAX_WORKING_SET_SIZE: 50,
+  // Limit working set to prevent unbounded growth
+  IMPORTANCE_MODIFIED: 2,
+  // 2x weight for modified files
+  IMPORTANCE_ENTRY_POINT: 1.5,
+  // Higher weight for index.ts, main.ts, etc.
+  IMPORTANCE_RECENT_EDIT: 1.3,
+  // Files edited in last 5 interactions
+  TOKEN_ESTIMATE_PER_LINE: 4
+  // Rough estimate: 4 tokens per line
+};
+var ENTRY_POINT_PATTERNS = [
+  /^index\.(ts|tsx|js|jsx)$/,
+  /^main\.(ts|tsx|js|jsx)$/,
+  /^app\.(ts|tsx|js|jsx)$/,
+  /^server\.(ts|tsx|js|jsx)$/
+];
+function calculateRankScore(accessCount, lastAccessed, isModified, isEntryPoint) {
+  const ageMs = Date.now() - lastAccessed;
+  const decayFactor = Math.pow(0.5, ageMs / CONTEXT_CONFIG.DECAY_HALF_LIFE_MS);
+  let importanceMultiplier = 1;
+  if (isModified) importanceMultiplier *= CONTEXT_CONFIG.IMPORTANCE_MODIFIED;
+  if (isEntryPoint) importanceMultiplier *= CONTEXT_CONFIG.IMPORTANCE_ENTRY_POINT;
+  return accessCount * decayFactor * importanceMultiplier;
+}
+function isEntryPointFile(filePath) {
+  const filename = path.basename(filePath);
+  return ENTRY_POINT_PATTERNS.some((pattern) => pattern.test(filename));
+}
+function generateSessionId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+function createEmptyContext() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    session_id: generateSessionId(),
+    mode: "safe",
+    current_task: null,
+    files_read: [],
+    files_modified: [],
+    working_set: [],
+    last_action: null,
+    created_at: now,
+    updated_at: now
+  };
+}
+var ContextManager = class {
+  ctx = createEmptyContext();
+  constructor() {
+  }
+  async init() {
+    try {
+      const lastSession = db.getDb().prepare(`
+                SELECT id, created_at, source, permissions 
+                FROM sessions 
+                ORDER BY created_at DESC 
+                LIMIT 1
+            `).get();
+      if (lastSession) {
+        await this.load(lastSession.id);
+      } else {
+        this.ctx = createEmptyContext();
+        await this.save();
+      }
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Context] Failed to init from DB: ${e instanceof Error ? e.message : String(e)}` });
+      this.ctx = createEmptyContext();
+      await this.save();
+    }
+  }
+  async load(sessionId) {
+    if (!sessionId) return;
+    try {
+      const session = db.getDb().prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId);
+      if (!session) return;
+      const workingSetRows = db.getDb().prepare(`
+                SELECT file_path 
+                FROM working_set 
+                WHERE session_id = ? 
+                ORDER BY rank_score DESC
+            `).all(sessionId);
+      this.ctx = {
+        session_id: session.id,
+        mode: "safe",
+        // Mode loaded from settings usually, but DB could store it if we added column
+        current_task: null,
+        // Tasks are now in 'tasks' table
+        files_read: [],
+        // Reset on load, or we could store this in DB if needed
+        files_modified: [],
+        working_set: workingSetRows.map((r) => r.file_path),
+        last_action: null,
+        created_at: new Date(session.created_at).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        // Refreshed
+      };
+      await this.syncModeFromSettings();
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Context] Failed to load session: ${e instanceof Error ? e.message : String(e)}` });
+    }
+  }
+  async save() {
+    this.ctx.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    const cfg = await config.load();
+    try {
+      const timestamp = Date.now();
+      db.getDb().prepare(`
+                INSERT INTO sessions (id, created_at, workspace)
+                VALUES (?, ?, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                workspace = excluded.workspace,
+                created_at = excluded.created_at
+            `).run(this.ctx.session_id, timestamp, cfg.workspaceRoot);
+      const insertFile = db.getDb().prepare(`
+                INSERT INTO working_set (session_id, file_path, rank_score, last_accessed, access_count)
+                VALUES (?, ?, ?, ?, 1)
+                ON CONFLICT(session_id, file_path) DO UPDATE SET 
+                access_count = access_count + 1,
+                last_accessed = ?
+            `);
+      const transaction = db.getDb().transaction(() => {
+        for (const file of this.ctx.working_set) {
+          insertFile.run(this.ctx.session_id, file, 1, timestamp, timestamp);
+        }
+      });
+      transaction();
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Context] Failed to save: ${e instanceof Error ? e.message : String(e)}` });
+    }
+  }
+  async archive() {
+  }
+  async startNewSession() {
+    const oldMode = this.ctx.mode;
+    this.ctx = createEmptyContext();
+    this.ctx.mode = oldMode;
+    await this.save();
+    await settings.set("mode", this.ctx.mode);
+  }
+  // Getters
+  get() {
+    return { ...this.ctx };
+  }
+  getMode() {
+    return this.ctx.mode;
+  }
+  async syncModeFromSettings() {
+    const s = await settings.load();
+    this.ctx.mode = s.mode;
+  }
+  getCurrentTask() {
+    return this.ctx.current_task;
+  }
+  getWorkingSet() {
+    return [...this.ctx.working_set];
+  }
+  // Setters
+  async setMode(mode) {
+    this.ctx.mode = mode;
+    await settings.set("mode", mode);
+  }
+  async setTask(task) {
+    this.ctx.current_task = task;
+  }
+  // Tracking
+  async trackRead(filePath, tokenEstimate = 0) {
+    const cfg = await config.load();
+    const normalized = path.relative(cfg.workspaceRoot, path.resolve(filePath));
+    if (!this.ctx.files_read.includes(normalized)) {
+      this.ctx.files_read.push(normalized);
+    }
+    if (!this.ctx.working_set.includes(normalized)) {
+      this.ctx.working_set.push(normalized);
+    }
+    try {
+      const timestamp = Date.now();
+      const isModified = this.ctx.files_modified.includes(normalized);
+      const isEntryPoint = isEntryPointFile(normalized);
+      const existing = db.getDb().prepare(`
+                SELECT access_count FROM working_set
+                WHERE session_id = ? AND file_path = ?
+            `).get(this.ctx.session_id, normalized);
+      const newAccessCount = (existing?.access_count || 0) + 1;
+      const rankScore = calculateRankScore(newAccessCount, timestamp, isModified, isEntryPoint);
+      db.getDb().prepare(`
+                INSERT INTO working_set (session_id, file_path, rank_score, last_accessed, access_count)
+                VALUES (?, ?, ?, ?, 1)
+                ON CONFLICT(session_id, file_path) DO UPDATE SET
+                access_count = access_count + 1,
+                last_accessed = ?,
+                rank_score = ?
+            `).run(this.ctx.session_id, normalized, rankScore, timestamp, timestamp, rankScore);
+      await this.pruneWorkingSet();
+    } catch (e) {
+      bus.emitAgent({ type: "thought", content: `[Context] Failed to track read for ${normalized}: ${e instanceof Error ? e.message : String(e)}`, hidden: true });
+    }
+  }
+  async trackModified(filePath, tokenEstimate = 0) {
+    const cfg = await config.load();
+    const normalized = path.relative(cfg.workspaceRoot, path.resolve(filePath));
+    if (!this.ctx.files_modified.includes(normalized)) {
+      this.ctx.files_modified.push(normalized);
+    }
+    try {
+      const timestamp = Date.now();
+      const existing = db.getDb().prepare(`
+                SELECT access_count FROM working_set
+                WHERE session_id = ? AND file_path = ?
+            `).get(this.ctx.session_id, normalized);
+      const accessCount = existing?.access_count || 1;
+      const isEntryPoint = isEntryPointFile(normalized);
+      const rankScore = calculateRankScore(accessCount, timestamp, true, isEntryPoint);
+      db.getDb().prepare(`
+                UPDATE working_set SET rank_score = ?, last_accessed = ?
+                WHERE session_id = ? AND file_path = ?
+            `).run(rankScore, timestamp, this.ctx.session_id, normalized);
+    } catch (e) {
+      await this.trackRead(filePath, tokenEstimate);
+    }
+  }
+  /**
+   * Prune working set to prevent unbounded growth
+   * Keeps top N files by rank score
+   */
+  async pruneWorkingSet() {
+    try {
+      const count = db.getDb().prepare(`
+                SELECT COUNT(*) as count FROM working_set WHERE session_id = ?
+            `).get(this.ctx.session_id);
+      if (count.count > CONTEXT_CONFIG.MAX_WORKING_SET_SIZE) {
+        db.getDb().prepare(`
+                    DELETE FROM working_set
+                    WHERE session_id = ? AND file_path NOT IN (
+                        SELECT file_path FROM working_set
+                        WHERE session_id = ?
+                        ORDER BY rank_score DESC
+                        LIMIT ?
+                    )
+                `).run(this.ctx.session_id, this.ctx.session_id, CONTEXT_CONFIG.MAX_WORKING_SET_SIZE);
+        const remaining = db.getDb().prepare(`
+                    SELECT file_path FROM working_set
+                    WHERE session_id = ?
+                    ORDER BY rank_score DESC
+                `).all(this.ctx.session_id);
+        this.ctx.working_set = remaining.map((r) => r.file_path);
+      }
+    } catch (e) {
+      bus.emitAgent({ type: "thought", content: `[Context] Working set pruning failed: ${e instanceof Error ? e.message : String(e)}`, hidden: true });
+    }
+  }
+  /**
+   * Get working set entries with full metadata
+   */
+  getWorkingSetWithMetadata() {
+    try {
+      const rows = db.getDb().prepare(`
+                SELECT file_path, access_count, last_accessed, rank_score
+                FROM working_set
+                WHERE session_id = ?
+                ORDER BY rank_score DESC
+            `).all(this.ctx.session_id);
+      return rows.map((r) => ({
+        filePath: r.file_path,
+        accessCount: r.access_count,
+        lastAccessed: r.last_accessed,
+        isModified: this.ctx.files_modified.includes(r.file_path),
+        tokenEstimate: 0
+        // Would need to read file to estimate
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  /**
+   * Recalculate all rank scores (useful for periodic refresh)
+   */
+  async recalculateRankScores() {
+    try {
+      const rows = db.getDb().prepare(`
+                SELECT file_path, access_count, last_accessed
+                FROM working_set
+                WHERE session_id = ?
+            `).all(this.ctx.session_id);
+      const updateStmt = db.getDb().prepare(`
+                UPDATE working_set SET rank_score = ?
+                WHERE session_id = ? AND file_path = ?
+            `);
+      db.getDb().transaction(() => {
+        for (const row of rows) {
+          const isModified = this.ctx.files_modified.includes(row.file_path);
+          const isEntryPoint = isEntryPointFile(row.file_path);
+          const newScore = calculateRankScore(
+            row.access_count,
+            row.last_accessed,
+            isModified,
+            isEntryPoint
+          );
+          updateStmt.run(newScore, this.ctx.session_id, row.file_path);
+        }
+      })();
+    } catch (e) {
+      bus.emitAgent({ type: "thought", content: `[Context] Rank recalculation failed: ${e instanceof Error ? e.message : String(e)}`, hidden: true });
+    }
+  }
+  async setLastAction(action) {
+    this.ctx.last_action = action;
+  }
+  // Reset
+  async reset() {
+    this.ctx = createEmptyContext();
+    await this.save();
+  }
+  async clearWorkingSet() {
+    this.ctx.working_set = [];
+    db.getDb().prepare("DELETE FROM working_set WHERE session_id = ?").run(this.ctx.session_id);
+  }
+  // Summary for LLM
+  getSummary() {
+    const lines = [];
+    if (this.ctx.current_task) {
+      lines.push(`Task: ${this.ctx.current_task}`);
+    }
+    const topFiles = this.getWorkingSetWithMetadata().slice(0, 5);
+    if (topFiles.length > 0) {
+      const fileList = topFiles.map((f) => {
+        const modified = f.isModified ? "*" : "";
+        return `${modified}${f.filePath}`;
+      }).join(", ");
+      lines.push(`Working set (top 5): ${fileList}`);
+    }
+    if (this.ctx.files_modified.length > 0) {
+      lines.push(`Modified this session: ${this.ctx.files_modified.slice(-3).join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get context statistics for monitoring
+   */
+  getStats() {
+    return {
+      totalFilesRead: this.ctx.files_read.length,
+      totalFilesModified: this.ctx.files_modified.length,
+      workingSetSize: this.ctx.working_set.length,
+      sessionAge: Date.now() - new Date(this.ctx.created_at).getTime()
+    };
+  }
+};
+var context = new ContextManager();
+
+export {
+  context
+};

package/dist/chunk-EPG5V5OO.js

@@ -0,0 +1,285 @@
+// src/core/settings.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { z } from "zod";
+var SETTINGS_DIR = ".obsidian-next";
+var SETTINGS_FILE = "settings.json";
+var SettingsSchema = z.object({
+  // Execution mode
+  mode: z.enum(["auto", "plan", "safe"]).default("safe"),
+  // Auto-accept settings
+  autoAccept: z.object({
+    enabled: z.boolean().default(false),
+    readOperations: z.boolean().default(true),
+    safeCommands: z.boolean().default(true)
+  }).default({}),
+  // Tool permissions
+  permissions: z.object({
+    // Patterns always allowed without prompt: "tool:pattern"
+    allow: z.array(z.string()).default([]),
+    // Patterns allowed without prompt AND without sandbox
+    allowUnsandboxed: z.array(z.string()).default([]),
+    // Patterns always blocked
+    deny: z.array(z.string()).default([])
+  }).default({}),
+  // Security settings
+  security: z.object({
+    // PII redaction before sending to LLM
+    piiRedaction: z.boolean().default(true),
+    // Audit logging of all commands
+    auditLogging: z.boolean().default(true),
+    // Key storage backend preference
+    keyBackend: z.enum(["auto", "keychain", "secret-tool", "encrypted-file", "env"]).default("auto"),
+    // Restrict filesystem access to sandbox directories
+    sandbox: z.boolean().default(false)
+  }).default({}),
+  // UI preferences
+  ui: z.object({
+    syntaxHighlight: z.boolean().default(true),
+    diffColors: z.boolean().default(true),
+    showLineNumbers: z.boolean().default(true),
+    // Owl animation settings
+    owlAnimation: z.object({
+      enabled: z.boolean().default(false),
+      flyWhenIdle: z.boolean().default(false),
+      idleTimeout: z.number().default(6e4),
+      // 60s before idle animation
+      sleepTimeout: z.number().default(3e5)
+      // 5m before sleep animation
+    }).default({})
+  }).default({}),
+  // Remote Gateway (Telegram)
+  telegram: z.object({
+    enabled: z.boolean().default(false),
+    botToken: z.string().optional(),
+    allowedUserIds: z.array(z.string()).default([])
+  }).default({})
+});
+var DEFAULT_SETTINGS = {
+  mode: "safe",
+  autoAccept: {
+    enabled: false,
+    readOperations: false,
+    safeCommands: false
+  },
+  permissions: {
+    allow: [],
+    // Empty - user builds their own allow list
+    allowUnsandboxed: [],
+    deny: []
+  },
+  security: {
+    piiRedaction: true,
+    // Enabled by default - protects user privacy
+    auditLogging: true,
+    // Enabled by default - for accountability
+    keyBackend: "auto",
+    // Auto-detect best available backend
+    sandbox: false
+    // Disabled by default
+  },
+  ui: {
+    syntaxHighlight: true,
+    diffColors: true,
+    showLineNumbers: true,
+    owlAnimation: {
+      enabled: false,
+      flyWhenIdle: false,
+      idleTimeout: 6e4,
+      // 60s before idle animation
+      sleepTimeout: 3e5
+      // 5m before sleep animation
+    }
+  },
+  telegram: {
+    enabled: false,
+    allowedUserIds: []
+  }
+};
+var SettingsManager = class {
+  settingsPath;
+  cache = null;
+  sessionAllow = /* @__PURE__ */ new Set();
+  sessionUnsandboxed = /* @__PURE__ */ new Set();
+  sessionDeny = /* @__PURE__ */ new Set();
+  constructor() {
+    this.settingsPath = path.join(os.homedir(), SETTINGS_DIR, SETTINGS_FILE);
+  }
+  async load() {
+    if (this.cache) return this.cache;
+    return this.reload();
+  }
+  async reload() {
+    try {
+      const data = await fs.readFile(this.settingsPath, "utf-8");
+      const parsed = JSON.parse(data);
+      this.cache = SettingsSchema.parse({ ...DEFAULT_SETTINGS, ...parsed });
+    } catch {
+      this.cache = DEFAULT_SETTINGS;
+      await this.save(DEFAULT_SETTINGS);
+    }
+    return this.cache;
+  }
+  /**
+   * Add a permission to the allow list (called when user approves a command)
+   */
+  async addAllowedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.allow.includes(pattern)) {
+      s.permissions.allow.push(pattern);
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  /**
+   * Add a permission to the unsandboxed allow list
+   */
+  async addUnsandboxedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.allowUnsandboxed.includes(pattern)) {
+      s.permissions.allowUnsandboxed.push(pattern);
+      if (!s.permissions.allow.includes(pattern)) {
+        s.permissions.allow.push(pattern);
+      }
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  /**
+   * Add a permission to the session-only allow/deny list
+   */
+  async addSessionPermission(tool, command, approved, bypass = false) {
+    const pattern = `${tool}:${command}`;
+    if (approved) {
+      this.sessionAllow.add(pattern);
+      this.sessionDeny.delete(pattern);
+      if (bypass) {
+        this.sessionUnsandboxed.add(pattern);
+      }
+    } else {
+      this.sessionDeny.add(pattern);
+      this.sessionAllow.delete(pattern);
+      this.sessionUnsandboxed.delete(pattern);
+    }
+  }
+  /**
+   * Add a permission to the deny list
+   */
+  async addDeniedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.deny.includes(pattern)) {
+      s.permissions.deny.push(pattern);
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  async save(newSettings) {
+    const current = await this.load();
+    const merged = { ...current, ...newSettings };
+    if (newSettings.autoAccept) {
+      merged.autoAccept = { ...current.autoAccept, ...newSettings.autoAccept };
+    }
+    if (newSettings.permissions) {
+      merged.permissions = { ...current.permissions, ...newSettings.permissions };
+    }
+    if (newSettings.security) {
+      merged.security = { ...current.security, ...newSettings.security };
+    }
+    if (newSettings.ui) {
+      merged.ui = { ...current.ui, ...newSettings.ui };
+    }
+    const validated = SettingsSchema.parse(merged);
+    const dir = path.dirname(this.settingsPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(this.settingsPath, JSON.stringify(validated, null, 2));
+    this.cache = validated;
+  }
+  async get(key) {
+    const s = await this.load();
+    return s[key];
+  }
+  async set(key, value) {
+    await this.save({ [key]: value });
+  }
+  /**
+   * Check if a tool:command pattern is authorized for THIS SESSION only
+   */
+  async isSessionAuthorized(tool, command) {
+    const pattern = `${tool}:${command}`;
+    return this.sessionAllow.has(pattern);
+  }
+  /**
+   * Check if a tool:command pattern is allowed (session or persistent)
+   */
+  async isAllowed(tool, command) {
+    const pattern = `${tool}:${command}`;
+    if (this.sessionAllow.has(pattern)) {
+      return true;
+    }
+    const s = await this.load();
+    for (const deny of s.permissions.deny) {
+      if (this.matchPattern(pattern, deny)) {
+        return false;
+      }
+    }
+    for (const allow of s.permissions.allow) {
+      if (this.matchPattern(pattern, allow)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a tool:command pattern is allowed to bypass sandbox
+   */
+  async isUnsandboxed(tool, command) {
+    const pattern = `${tool}:${command}`;
+    if (this.sessionUnsandboxed.has(pattern)) {
+      return true;
+    }
+    const s = await this.load();
+    for (const allow of s.permissions.allowUnsandboxed) {
+      if (this.matchPattern(pattern, allow)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a tool:command pattern is explicitly denied
+   */
+  async isDenied(tool, command) {
+    const pattern = `${tool}:${command}`;
+    if (this.sessionDeny.has(pattern)) {
+      return true;
+    }
+    const s = await this.load();
+    for (const deny of s.permissions.deny) {
+      if (this.matchPattern(pattern, deny)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Simple glob-like pattern matching
+   * Supports * as wildcard
+   */
+  matchPattern(value, pattern) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${regex}$`).test(value);
+  }
+  clearCache() {
+    this.cache = null;
+  }
+  getPath() {
+    return this.settingsPath;
+  }
+};
+var settings = new SettingsManager();
+
+export {
+  SettingsSchema,
+  settings
+};