@aurora-foundation/obsidian-next 0.4.7 → 0.4.9

package/dist/chunk-VSF5KBW7.js

@@ -0,0 +1,367 @@
+import {
+  config
+} from "./chunk-7MMY74WO.js";
+import {
+  settings
+} from "./chunk-EPG5V5OO.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) {
+      console.error("Failed to init context from DB:", 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) {
+      console.error("Failed to load context:", 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) {
+      console.error("Failed to save context to DB:", 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) {
+      console.error("Failed to track read:", e);
+    }
+  }
+  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) {
+      console.error("Failed to prune working set:", e);
+    }
+  }
+  /**
+   * 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) {
+      console.error("Failed to recalculate rank scores:", e);
+    }
+  }
+  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-VV3JMCKY.js

@@ -0,0 +1,214 @@
+import {
+  auditLog
+} from "./chunk-JTWSK277.js";
+import {
+  context
+} from "./chunk-ZOSSVNGK.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+import {
+  db
+} from "./chunk-FNLWB54Z.js";
+
+// src/core/scheduler.ts
+import cronParser from "cron-parser";
+var parseExpression = cronParser.parseExpression || cronParser.default?.parseExpression || cronParser.parse || cronParser.default?.parse;
+var MAX_CONSECUTIVE_FAILURES = 3;
+var Scheduler = class _Scheduler {
+  static instance;
+  abilities = /* @__PURE__ */ new Map();
+  timer = null;
+  isRunning = false;
+  failureCounts = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!_Scheduler.instance) {
+      _Scheduler.instance = new _Scheduler();
+    }
+    return _Scheduler.instance;
+  }
+  /**
+   * Initialize the scheduler loop
+   */
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.tick().catch((err) => bus.emitAgent({ type: "error", message: `[Scheduler] Initial tick failed: ${err instanceof Error ? err.message : String(err)}` }));
+    this.timer = setInterval(() => this.tick(), 1e4);
+    bus.emitAgent({ type: "thought", content: "[Obsidian] Started background task monitor [Active Heartbeat]" });
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.isRunning = false;
+  }
+  /**
+   * Register a new ability that can be scheduled
+   */
+  registerAbility(name, func) {
+    this.abilities.set(name, func);
+  }
+  /**
+   * Get list of registered abilities
+   */
+  getAbilities() {
+    return Array.from(this.abilities.keys());
+  }
+  /**
+   * Schedule a new task
+   */
+  async scheduleTask(cronExpression, abilityName, params = {}) {
+    try {
+      parseExpression(cronExpression);
+    } catch (err) {
+      throw new Error(`Invalid cron expression: ${cronExpression}`);
+    }
+    if (!this.abilities.has(abilityName)) {
+      throw new Error(`Unknown ability: ${abilityName}`);
+    }
+    const id = `task_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const sessionId = context.get().session_id;
+    const task = {
+      id,
+      session_id: sessionId,
+      cron_expression: cronExpression,
+      command: abilityName,
+      params: JSON.stringify(params),
+      last_run_at: Date.now(),
+      active: 1
+    };
+    db.getDb().prepare(`
+            INSERT INTO scheduled_tasks (id, session_id, cron_expression, command, params, last_run_at, active)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(task.id, task.session_id, task.cron_expression, task.command, task.params, task.last_run_at, task.active);
+    bus.emitAgent({ type: "thought", content: `[Scheduler] Scheduled ${abilityName} (${cronExpression})` });
+    return task;
+  }
+  /**
+   * List all active tasks
+   */
+  listTasks() {
+    const tasks = db.getDb().prepare(`
+            SELECT * FROM scheduled_tasks WHERE active = 1
+        `).all();
+    return tasks.map((t) => {
+      try {
+        const interval = parseExpression(t.cron_expression);
+        t.next_run_at = interval.next().getTime();
+      } catch {
+        t.next_run_at = 0;
+      }
+      return t;
+    });
+  }
+  /**
+   * Main execution loop
+   */
+  async tick() {
+    const tasks = this.listTasks();
+    const now = Date.now();
+    for (const task of tasks) {
+      try {
+        const baseline = task.last_run_at || now - 61e3;
+        let taskParams = {};
+        try {
+          taskParams = task.params ? JSON.parse(task.params) : {};
+        } catch {
+        }
+        if (taskParams.__once && taskParams.__target) {
+          if (now >= taskParams.__target) {
+            await this.executeTask(task);
+          }
+          continue;
+        }
+        const interval = parseExpression(task.cron_expression, {
+          currentDate: baseline
+        });
+        const nextRun = interval.next().getTime();
+        if (nextRun <= now) {
+          await this.executeTask(task);
+        }
+      } catch (error) {
+        bus.emitAgent({ type: "error", message: `[Scheduler] Error checking task ${task.id}: ${error instanceof Error ? error.message : String(error)}` });
+      }
+    }
+  }
+  async executeTask(task) {
+    const ability = this.abilities.get(task.command);
+    if (!ability) {
+      bus.emitAgent({ type: "error", message: `[Scheduler] Ability "${task.command}" not found. Disabling task ${task.id}.` });
+      db.getDb().prepare("UPDATE scheduled_tasks SET active = 0 WHERE id = ?").run(task.id);
+      return;
+    }
+    bus.emitAgent({
+      type: "scheduler_task_started",
+      taskId: task.id,
+      command: task.command
+    });
+    try {
+      let params = {};
+      if (task.params) {
+        try {
+          params = JSON.parse(task.params);
+        } catch {
+        }
+      }
+      await ability(params);
+      bus.emitAgent({
+        type: "scheduler_task_completed",
+        taskId: task.id,
+        command: task.command
+      });
+      this.failureCounts.delete(task.id);
+      if (params.__once) {
+        db.getDb().prepare(`UPDATE scheduled_tasks SET active = 0 WHERE id = ?`).run(task.id);
+        bus.emitAgent({ type: "thought", content: `[Scheduler] One-time task ${task.id} completed and deactivated.` });
+      }
+    } catch (error) {
+      await auditLog.logSystemEvent("scheduler_error", { taskId: task.id, error: error.message });
+      bus.emitAgent({ type: "scheduler_task_failed", taskId: task.id, command: task.command, error: error.message });
+      const failures = (this.failureCounts.get(task.id) || 0) + 1;
+      this.failureCounts.set(task.id, failures);
+      if (failures >= MAX_CONSECUTIVE_FAILURES) {
+        db.getDb().prepare("UPDATE scheduled_tasks SET active = 0 WHERE id = ?").run(task.id);
+        this.failureCounts.delete(task.id);
+        bus.emitAgent({
+          type: "error",
+          message: `[Scheduler] Task ${task.id} (${task.command}) disabled after ${MAX_CONSECUTIVE_FAILURES} consecutive failures.`
+        });
+      } else {
+        bus.emitAgent({
+          type: "error",
+          message: `[Scheduler] Task ${task.id} (${task.command}) failed: ${error.message} (${failures}/${MAX_CONSECUTIVE_FAILURES} before auto-disable)`
+        });
+      }
+    } finally {
+      db.getDb().prepare(`
+                UPDATE scheduled_tasks SET last_run_at = ? WHERE id = ?
+            `).run(Date.now(), task.id);
+    }
+  }
+  /**
+   * Remove (deactivate) a scheduled task
+   */
+  async removeTask(taskId) {
+    const result = db.getDb().prepare(`
+            UPDATE scheduled_tasks SET active = 0 WHERE id = ?
+        `).run(taskId);
+    if (result.changes && result.changes > 0) {
+      bus.emitAgent({ type: "thought", content: `[Scheduler] Deactivated task: ${taskId}` });
+      return true;
+    }
+    return false;
+  }
+};
+var scheduler = Scheduler.getInstance();
+
+export {
+  Scheduler,
+  scheduler
+};

package/dist/chunk-W5L7HOE3.js

@@ -0,0 +1,133 @@
+import {
+  history,
+  session,
+  tasks
+} from "./chunk-VS22YVX6.js";
+import {
+  context
+} from "./chunk-DPNIQWKZ.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+
+// src/commands/resume.ts
+import path from "path";
+var resumeCommand = async (args) => {
+  if (args[0] === "--delete" || args[0] === "-d") {
+    const sessionId = args[1];
+    if (!sessionId) {
+      bus.emitAgent({
+        type: "error",
+        message: "Usage: /resume --delete <session_id>"
+      });
+      return;
+    }
+    const deleted = await session.delete(sessionId);
+    if (deleted) {
+      bus.emitAgent({
+        type: "done",
+        summary: `Session ${sessionId} deleted.`
+      });
+    } else {
+      bus.emitAgent({
+        type: "error",
+        message: `Session ${sessionId} not found.`
+      });
+    }
+    return;
+  }
+  if (args[0] === "--last" || args[0] === "-l") {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "error",
+        message: "No saved sessions found."
+      });
+      return;
+    }
+    args[0] = sessions[0].id;
+  }
+  if (!args[0]) {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "thought",
+        content: "No saved sessions found.\n\nSessions are created when you run /exit."
+      });
+      bus.emitAgent({
+        type: "done",
+        summary: "No sessions available."
+      });
+      return;
+    }
+    const content2 = [
+      "Saved Session Registry",
+      ...sessions.slice(0, 10).map((s) => {
+        const date = new Date(s.savedAt);
+        const dateStr = date.toLocaleDateString();
+        const timeStr = date.toLocaleTimeString([], {
+          hour: "2-digit",
+          minute: "2-digit"
+        });
+        const workspaceName = path.basename(s.workspace);
+        return [
+          `   \u23BF  [${s.id}]`,
+          `      \u23BF  Date      ${dateStr} ${timeStr}`,
+          `      \u23BF  Workspace ${workspaceName}`,
+          s.task ? `      \u23BF  Task      ${s.task}` : null,
+          `      \u23BF  Activity  ${s.filesModified} files handled`,
+          ""
+        ].filter(Boolean).join("\n");
+      }),
+      sessions.length > 10 ? `   ... and ${sessions.length - 10} more sessions
+` : "",
+      "   [Usage]",
+      "   \u23BF  /resume <id>      Restore session",
+      "   \u23BF  /resume --last    Restore latest",
+      ""
+    ].join("\n");
+    bus.emitAgent({
+      type: "thought",
+      content: content2
+    });
+    bus.emitAgent({
+      type: "done",
+      summary: `${sessions.length} session(s) available.`
+    });
+    return;
+  }
+  const sessionIdArg = args[0];
+  const result = await session.restore(sessionIdArg);
+  if (!result.success) {
+    bus.emitAgent({
+      type: "error",
+      message: result.error || "Failed to restore session"
+    });
+    return;
+  }
+  const currentTask = tasks.get();
+  const currentContext = context.get();
+  const content = [
+    "Session Restored Successfully",
+    `   \u23BF  ID          ${sessionIdArg}`,
+    `   \u23BF  Root        ${path.basename(process.cwd())}`,
+    "",
+    "   [Restored State]",
+    `   \u23BF  Context     ${currentContext.files_read.length} files in set`,
+    `   \u23BF  History     ${(await history.load()).length} events rehydrated`,
+    `   \u23BF  Task        ${currentTask?.title || "None"}`,
+    ""
+  ].join("\n");
+  bus.emitAgent({
+    type: "thought",
+    content
+  });
+  bus.emitAgent({
+    type: "done",
+    summary: `Session ${sessionIdArg} restored.`
+  });
+};
+
+export {
+  resumeCommand
+};