@hasna/assistants 1.1.3 → 1.1.5

package/dist/cli.js

@@ -162160,6 +162160,15 @@ class AssistantLoop {
     registerConnectorsListTool(this.toolRegistry, {
       getConnectorBridge: () => this.connectorBridge
     });
+    registerConnectorsSearchTool(this.toolRegistry, {
+      getConnectorBridge: () => this.connectorBridge,
+      onConnectorSelected: (connectorName) => {
+        this.connectorBridge.registerConnector(this.toolRegistry, connectorName);
+      }
+    });
+    registerConnectorExecuteTool(this.toolRegistry, {
+      getConnectorBridge: () => this.connectorBridge
+    });
     registerConnectorAutoRefreshTool(this.toolRegistry);
     registerConfigTools(this.toolRegistry, {
       cwd: this.cwd
@@ -162293,6 +162302,48 @@ class AssistantLoop {
     if (this.extraSystemPrompt) {
       this.context.addSystemMessage(this.extraSystemPrompt);
     }
+    if (this.config.heartbeat?.autonomous) {
+      const maxSleepMin = Math.round((this.config.heartbeat.maxSleepMs ?? 1800000) / 60000);
+      this.context.addSystemMessage(`## Autonomous Heartbeat System
+
+You are running in **autonomous mode**. You manage your own wakeup schedule.
+
+### How it works
+- After every turn, a safety-net hook ensures a heartbeat schedule exists
+- The heartbeat fires \`/main-loop\` which runs your autonomous check-in skill
+- A watchdog monitors your health and forces a wakeup if you're overdue
+
+### Your responsibilities at the END of every turn
+1. **Save state** to memory before the turn ends:
+   - \`memory_save agent.heartbeat.intention "what you plan to do next"\`
+   - \`memory_save agent.state.pending "items waiting for follow-up"\`
+   - \`memory_save agent.state.lastActions "what you just did"\`
+2. **Schedule your next heartbeat**:
+   - Delete old: \`schedule_delete heartbeat-${this.sessionId}\`
+   - Create new: \`schedule_create\` with \`kind: "once"\`, \`actionType: "message"\`, \`message: "/main-loop"\`, and \`at\` set to your chosen time
+3. **Save goals** when they change: \`memory_save agent.goals "..."\`
+
+### Timing guidelines
+| Situation | Wake up in |
+|-----------|-----------|
+| Active jobs running or tasks pending | 1\u20133 minutes |
+| Goals exist but nothing urgent | 5\u201315 minutes |
+| Nothing pending, user idle | 15\u2013${maxSleepMin} minutes (max) |
+
+### Key memory keys
+- \`agent.heartbeat.last\` \u2014 when you last ran (save ISO timestamp)
+- \`agent.heartbeat.next\` \u2014 when you plan to run next
+- \`agent.heartbeat.intention\` \u2014 why you're waking up
+- \`agent.goals\` \u2014 your active goals
+- \`agent.state.pending\` \u2014 items waiting
+- \`agent.state.lastActions\` \u2014 what you did recently
+
+### Rules
+- **Stay fast** \u2014 if work takes >30s, delegate to a subassistant
+- **Never sleep longer than ${maxSleepMin} minutes** \u2014 the system enforces this cap
+- **Always schedule your next heartbeat** \u2014 if you forget, the safety net creates a default one
+`);
+    }
     this.contextManager?.refreshState(this.context.getMessages());
     await this.hookExecutor.execute(this.hookLoader.getHooks("SessionStart"), {
       session_id: this.sessionId,
@@ -162563,6 +162614,17 @@ class AssistantLoop {
         hook_event_name: "Stop",
         cwd: this.cwd
       });
+      try {
+        await nativeHookRegistry.execute("Stop", {
+          session_id: this.sessionId,
+          hook_event_name: "Stop",
+          cwd: this.cwd
+        }, {
+          sessionId: this.sessionId,
+          cwd: this.cwd,
+          messages: this.context.getMessages()
+        });
+      } catch {}
       const shouldSkipVerification = this.shouldStop || streamError !== null;
       if (shouldSkipVerification) {
         this.scopeContextManager.clear();

package/dist/lib.js

@@ -113513,6 +113513,162 @@ Use job_status or job_result to check progress.`;
     }
   }
 }
+var connectorExecuteTool = {
+  name: "connector_execute",
+  description: "Execute a command on any discovered connector. Use connectors_list or connectors_search first to discover available connectors and their commands.",
+  parameters: {
+    type: "object",
+    properties: {
+      connector: {
+        type: "string",
+        description: 'Name of the connector to use (e.g., "notion", "gmail", "googledrive")'
+      },
+      command: {
+        type: "string",
+        description: "The command to run on the connector"
+      },
+      args: {
+        type: "array",
+        description: "Arguments to pass to the command",
+        items: { type: "string", description: "Argument value" }
+      },
+      options: {
+        type: "object",
+        description: "Options to pass to the command (key-value pairs)"
+      }
+    },
+    required: ["connector", "command"]
+  }
+};
+function createConnectorExecuteExecutor(context) {
+  return async (input) => {
+    const bridge = context.getConnectorBridge();
+    if (!bridge) {
+      return JSON.stringify({
+        error: "Connector system not available",
+        suggestion: "Ensure connectors are configured and discovered"
+      });
+    }
+    const connectorName = input.connector;
+    if (!connectorName) {
+      return JSON.stringify({
+        error: "Missing required parameter: connector",
+        suggestion: "Use connectors_list to find available connectors"
+      });
+    }
+    const connector = bridge.getConnector(connectorName);
+    if (!connector) {
+      const available = bridge.getConnectors().map((c) => c.name);
+      return JSON.stringify({
+        error: `Connector '${connectorName}' not found`,
+        available: available.slice(0, 10),
+        totalAvailable: available.length,
+        suggestion: "Use connectors_list to see all available connectors"
+      });
+    }
+    const executor = bridge["createExecutor"](connector);
+    return executor({
+      command: input.command,
+      args: input.args,
+      options: input.options,
+      cwd: input.cwd
+    });
+  };
+}
+function registerConnectorExecuteTool(registry, context) {
+  const executor = createConnectorExecuteExecutor(context);
+  registry.register(connectorExecuteTool, executor);
+}
+var connectorsSearchTool = {
+  name: "connectors_search",
+  description: "Search for connectors by name, description, or command. Use this to find the right connector for a task when many are available.",
+  parameters: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query to match against connector names, descriptions, and commands"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (default: 5, max: 20)"
+      }
+    },
+    required: ["query"]
+  }
+};
+function createConnectorsSearchExecutor(context) {
+  return async (input) => {
+    const bridge = context.getConnectorBridge();
+    if (!bridge) {
+      return JSON.stringify({
+        error: "Connector discovery not available",
+        results: []
+      });
+    }
+    const query = (input.query || "").toLowerCase();
+    const limit = Math.min(Math.max(1, Number(input.limit) || 5), 20);
+    if (!query) {
+      return JSON.stringify({
+        error: "Search query is required",
+        suggestion: 'Provide a query like "email", "storage", or "calendar"'
+      });
+    }
+    const connectors = bridge.getConnectors();
+    const results = [];
+    for (const connector of connectors) {
+      let score = 0;
+      const matchedCommands = [];
+      if (connector.name.toLowerCase().includes(query)) {
+        score += 10;
+        if (connector.name.toLowerCase() === query) {
+          score += 5;
+        }
+      }
+      if (connector.description.toLowerCase().includes(query)) {
+        score += 5;
+      }
+      for (const cmd of connector.commands) {
+        if (cmd.name.toLowerCase().includes(query)) {
+          score += 2;
+          matchedCommands.push(cmd.name);
+        }
+        if (cmd.description.toLowerCase().includes(query)) {
+          score += 1;
+          if (!matchedCommands.includes(cmd.name)) {
+            matchedCommands.push(cmd.name);
+          }
+        }
+      }
+      if (score > 0) {
+        results.push({
+          name: connector.name,
+          description: connector.description,
+          matchedCommands: matchedCommands.slice(0, 5),
+          score
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    const topResults = results.slice(0, limit);
+    if (context.onConnectorSelected && topResults.length > 0) {
+      for (const result of topResults) {
+        context.onConnectorSelected(result.name);
+      }
+    }
+    return JSON.stringify({
+      query,
+      count: topResults.length,
+      totalMatches: results.length,
+      results: topResults.map(({ score, ...rest }) => rest),
+      suggestion: topResults.length > 0 ? `Use connector_execute with connector="${topResults[0].name}" to run commands` : "Try a different search query or use connectors_list to see all available connectors"
+    }, null, 2);
+  };
+}
+function registerConnectorsSearchTool(registry, context) {
+  const executor = createConnectorsSearchExecutor(context);
+  registry.register(connectorsSearchTool, executor);
+}
 var connectorsListTool = {
   name: "connectors_list",
   description: "List all discovered connectors and their available commands. Use this to discover what connectors are available and what operations they support.",
@@ -155185,6 +155341,15 @@ class AssistantLoop {
     registerConnectorsListTool(this.toolRegistry, {
       getConnectorBridge: () => this.connectorBridge
     });
+    registerConnectorsSearchTool(this.toolRegistry, {
+      getConnectorBridge: () => this.connectorBridge,
+      onConnectorSelected: (connectorName) => {
+        this.connectorBridge.registerConnector(this.toolRegistry, connectorName);
+      }
+    });
+    registerConnectorExecuteTool(this.toolRegistry, {
+      getConnectorBridge: () => this.connectorBridge
+    });
     registerConnectorAutoRefreshTool(this.toolRegistry);
     registerConfigTools(this.toolRegistry, {
       cwd: this.cwd
@@ -155318,6 +155483,48 @@ class AssistantLoop {
     if (this.extraSystemPrompt) {
       this.context.addSystemMessage(this.extraSystemPrompt);
     }
+    if (this.config.heartbeat?.autonomous) {
+      const maxSleepMin = Math.round((this.config.heartbeat.maxSleepMs ?? 1800000) / 60000);
+      this.context.addSystemMessage(`## Autonomous Heartbeat System
+
+You are running in **autonomous mode**. You manage your own wakeup schedule.
+
+### How it works
+- After every turn, a safety-net hook ensures a heartbeat schedule exists
+- The heartbeat fires \`/main-loop\` which runs your autonomous check-in skill
+- A watchdog monitors your health and forces a wakeup if you're overdue
+
+### Your responsibilities at the END of every turn
+1. **Save state** to memory before the turn ends:
+   - \`memory_save agent.heartbeat.intention "what you plan to do next"\`
+   - \`memory_save agent.state.pending "items waiting for follow-up"\`
+   - \`memory_save agent.state.lastActions "what you just did"\`
+2. **Schedule your next heartbeat**:
+   - Delete old: \`schedule_delete heartbeat-${this.sessionId}\`
+   - Create new: \`schedule_create\` with \`kind: "once"\`, \`actionType: "message"\`, \`message: "/main-loop"\`, and \`at\` set to your chosen time
+3. **Save goals** when they change: \`memory_save agent.goals "..."\`
+
+### Timing guidelines
+| Situation | Wake up in |
+|-----------|-----------|
+| Active jobs running or tasks pending | 1\u20133 minutes |
+| Goals exist but nothing urgent | 5\u201315 minutes |
+| Nothing pending, user idle | 15\u2013${maxSleepMin} minutes (max) |
+
+### Key memory keys
+- \`agent.heartbeat.last\` \u2014 when you last ran (save ISO timestamp)
+- \`agent.heartbeat.next\` \u2014 when you plan to run next
+- \`agent.heartbeat.intention\` \u2014 why you're waking up
+- \`agent.goals\` \u2014 your active goals
+- \`agent.state.pending\` \u2014 items waiting
+- \`agent.state.lastActions\` \u2014 what you did recently
+
+### Rules
+- **Stay fast** \u2014 if work takes >30s, delegate to a subassistant
+- **Never sleep longer than ${maxSleepMin} minutes** \u2014 the system enforces this cap
+- **Always schedule your next heartbeat** \u2014 if you forget, the safety net creates a default one
+`);
+    }
     this.contextManager?.refreshState(this.context.getMessages());
     await this.hookExecutor.execute(this.hookLoader.getHooks("SessionStart"), {
       session_id: this.sessionId,
@@ -155588,6 +155795,17 @@ class AssistantLoop {
         hook_event_name: "Stop",
         cwd: this.cwd
       });
+      try {
+        await nativeHookRegistry.execute("Stop", {
+          session_id: this.sessionId,
+          hook_event_name: "Stop",
+          cwd: this.cwd
+        }, {
+          sessionId: this.sessionId,
+          cwd: this.cwd,
+          messages: this.context.getMessages()
+        });
+      } catch {}
       const shouldSkipVerification = this.shouldStop || streamError !== null;
       if (shouldSkipVerification) {
         this.scopeContextManager.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/assistants",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "AI assistant that runs in your terminal - powered by Claude",
   "license": "MIT",
   "type": "module",
@@ -53,7 +53,7 @@
     "prepublishOnly": "pnpm run clean && pnpm run build"
   },
   "dependencies": {
-    "@hasna/assistants": "^1.1.2",
+    "@hasna/assistants": "1.1.3",
     "chalk": "^5.3.0",
     "ink": "^6.0.0",
     "ink-scroll-view": "^0.3.5",