nex-code 0.4.24 → 0.4.26

package/dist/skills/devops.md

@@ -0,0 +1,43 @@
+# DevOps Agent
+
+You are a DevOps-specialized coding agent with infrastructure management capabilities that go beyond code editing. You have direct access to:
+
+## Infrastructure Tools
+
+- **ssh_exec**: Execute commands on remote servers via SSH profiles (`.nex/servers.json`)
+- **service_manage**: Start/stop/restart systemd services on remote servers
+- **service_logs**: Fetch journalctl logs from remote services
+- **container_list/logs/exec/manage**: Docker container lifecycle management
+- **deploy**: Named deployment workflows via `.nex/deploy.json`
+- **remote_agent**: Delegate coding tasks to nex-code on remote servers
+
+## Deployment Workflow
+
+1. Check server status: `ssh_exec` to verify connectivity
+2. Review deploy config: read `.nex/deploy.json` for named configs
+3. Run deployment: `deploy` tool with named config or explicit params
+4. Verify: Check service status and health endpoints
+5. Rollback: Re-deploy previous version if health check fails
+
+## Server Configuration
+
+Server profiles live in `.nex/servers.json`:
+
+```json
+{
+  "prod": {
+    "host": "prod.example.com",
+    "user": "deploy",
+    "key": "~/.ssh/deploy_key"
+  },
+  "staging": { "host": "staging.example.com", "user": "deploy" }
+}
+```
+
+## Best Practices
+
+- Always check service status before and after changes
+- Use named deploy configs for repeatable deployments
+- Check logs when services fail to start
+- Use health check URLs to verify deployments
+- Keep deployment configs in version control

package/dist/skills/session-search.js

@@ -0,0 +1,180 @@
+/**
+ * cli/skills/session-search.js — Cross-Session Search
+ * Search past sessions by keyword to recall previous approaches.
+ * Inspired by Hermes Agent's FTS session search.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+function getSessionsDir() {
+  return path.join(process.cwd(), ".nex", "sessions");
+}
+
+/**
+ * Search sessions for keyword matches.
+ * Returns matching sessions with context snippets around each match.
+ *
+ * @param {string} query — Search query (case-insensitive substring match)
+ * @param {{ maxResults?: number, maxSnippets?: number }} opts
+ * @returns {Array<{ name, updatedAt, model, matchCount, snippets: string[] }>}
+ */
+function searchSessions(query, opts = {}) {
+  const dir = getSessionsDir();
+  if (!fs.existsSync(dir)) return [];
+
+  const maxResults = opts.maxResults || 5;
+  const maxSnippets = opts.maxSnippets || 3;
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+
+  const queryLower = query.toLowerCase();
+  const results = [];
+
+  for (const f of files) {
+    try {
+      const raw = fs.readFileSync(path.join(dir, f), "utf-8");
+      const session = JSON.parse(raw);
+      if (!session.messages || !Array.isArray(session.messages)) continue;
+
+      // Search through user and assistant messages
+      const snippets = [];
+      let matchCount = 0;
+
+      for (const msg of session.messages) {
+        if (!msg.content || typeof msg.content !== "string") continue;
+        const contentLower = msg.content.toLowerCase();
+        let searchFrom = 0;
+
+        while (searchFrom < contentLower.length) {
+          const idx = contentLower.indexOf(queryLower, searchFrom);
+          if (idx === -1) break;
+          matchCount++;
+
+          if (snippets.length < maxSnippets) {
+            // Extract context around match (80 chars before, 120 after)
+            const start = Math.max(0, idx - 80);
+            const end = Math.min(msg.content.length, idx + query.length + 120);
+            const prefix = start > 0 ? "..." : "";
+            const suffix = end < msg.content.length ? "..." : "";
+            const snippet =
+              `[${msg.role}] ${prefix}${msg.content.slice(start, end)}${suffix}`;
+            snippets.push(snippet.replace(/\n/g, " ").trim());
+          }
+
+          searchFrom = idx + query.length;
+        }
+      }
+
+      if (matchCount > 0) {
+        results.push({
+          name: session.name || f.replace(".json", ""),
+          updatedAt: session.updatedAt || null,
+          model: session.model || null,
+          messageCount: session.messageCount || session.messages.length,
+          matchCount,
+          snippets,
+        });
+      }
+    } catch {
+      // skip corrupt files
+    }
+  }
+
+  // Sort by match count (most relevant first), then by date
+  results.sort((a, b) => {
+    if (b.matchCount !== a.matchCount) return b.matchCount - a.matchCount;
+    return (b.updatedAt || "").localeCompare(a.updatedAt || "");
+  });
+
+  return results.slice(0, maxResults);
+}
+
+module.exports = {
+  name: "session-search",
+  description:
+    "Search past sessions by keyword to recall previous approaches, " +
+    "solutions, and conversations.",
+
+  instructions: `You have a session search tool for cross-session recall.
+
+## When to use
+
+- When the user asks about past work ("what did we do last time?", "how did we fix X?")
+- When you need to recall a previous approach before starting similar work
+- When the user references something from an earlier session
+
+## Tips
+
+- Search for specific keywords, error messages, or file names
+- Combine results from multiple searches to build context
+- Session search only covers saved sessions in .nex/sessions/`,
+
+  tools: [
+    {
+      type: "function",
+      function: {
+        name: "search_sessions",
+        description:
+          "Search past sessions by keyword. Returns matching sessions with context " +
+          "snippets showing where the keyword appears. Use this to recall previous " +
+          "approaches, solutions, or conversations.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description:
+                "Search keyword or phrase (case-insensitive). Use specific terms " +
+                "like error messages, file names, or tool names for best results.",
+            },
+            max_results: {
+              type: "number",
+              description:
+                "Maximum number of sessions to return (default: 5)",
+            },
+          },
+          required: ["query"],
+        },
+      },
+      execute: async (args) => {
+        const { query, max_results } = args;
+
+        if (!query || typeof query !== "string" || query.trim().length < 2) {
+          return JSON.stringify({
+            status: "error",
+            error: "Query must be at least 2 characters",
+          });
+        }
+
+        const results = searchSessions(query.trim(), {
+          maxResults: max_results || 5,
+        });
+
+        if (results.length === 0) {
+          return JSON.stringify({
+            status: "ok",
+            message: `No sessions found matching "${query}"`,
+            results: [],
+          });
+        }
+
+        return JSON.stringify({
+          status: "ok",
+          query,
+          total_matches: results.reduce((s, r) => s + r.matchCount, 0),
+          sessions: results.map((r) => ({
+            name: r.name,
+            updated: r.updatedAt,
+            model: r.model,
+            messages: r.messageCount,
+            matches: r.matchCount,
+            snippets: r.snippets,
+          })),
+        });
+      },
+    },
+  ],
+
+  // Export searchSessions for direct use and testing
+  _searchSessions: searchSessions,
+};

package/dist/skills/skill-learning.js

@@ -0,0 +1,304 @@
+/**
+ * cli/skills/skill-learning.js — Skill Auto-Learning
+ * Lets the agent create and update reusable skills from experience.
+ * Inspired by Hermes Agent's closed learning loop.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+function getSkillsDir() {
+  return path.join(process.cwd(), ".nex", "skills");
+}
+
+function ensureSkillsDir() {
+  const dir = getSkillsDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Validate a skill name: lowercase, alphanumeric + hyphens, 2-64 chars
+ */
+function validateName(name) {
+  if (!name || typeof name !== "string") return "name is required";
+  if (name.length < 2 || name.length > 64) return "name must be 2-64 characters";
+  if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(name) && name.length > 1)
+    return "name must be lowercase alphanumeric with hyphens (e.g. deploy-workflow)";
+  return null;
+}
+
+/**
+ * Build a .md skill file with YAML frontmatter
+ */
+function buildSkillContent(name, description, triggers, content) {
+  const triggerBlock =
+    triggers && triggers.length > 0
+      ? `trigger:\n${triggers.map((t) => `  - "${t}"`).join("\n")}\n`
+      : "";
+  return `---
+name: ${name}
+description: ${description}
+${triggerBlock}---
+
+${content}
+`;
+}
+
+module.exports = {
+  name: "skill-learning",
+  description:
+    "Create and update reusable skills from experience. " +
+    "After complex tasks, the agent can save its approach as a skill for future reuse.",
+
+  instructions: `You have tools to create and improve reusable skills.
+
+## When to create a skill
+
+After completing a complex task (5+ tool calls), fixing a tricky multi-step issue,
+or discovering a non-obvious workflow, save the approach as a reusable skill using
+skill_learn_create. Good candidates:
+
+- Deployment procedures with specific steps
+- Debugging workflows for recurring issues
+- Project-specific patterns (build, test, release)
+- Recurring maintenance or migration tasks
+
+Do NOT create skills for trivial one-off tasks or generic knowledge.
+
+## When to update a skill
+
+When using a skill and finding it outdated, incomplete, or wrong, patch it immediately
+with skill_learn_patch. Skills that are not maintained become liabilities.
+
+## Skill quality
+
+- Instructions should be actionable step-by-step guides
+- Include the WHY behind non-obvious steps
+- Add trigger keywords so the skill activates automatically on relevant prompts
+- Keep skills focused — one workflow per skill, not a knowledge dump`,
+
+  commands: [
+    {
+      cmd: "/skills-learned",
+      desc: "List all user-created skills in .nex/skills/",
+      handler: () => {
+        const dir = getSkillsDir();
+        if (!fs.existsSync(dir)) return "No learned skills yet.";
+        const files = fs
+          .readdirSync(dir)
+          .filter((f) => f.endsWith(".md") || f.endsWith(".js"));
+        if (files.length === 0) return "No learned skills yet.";
+        return (
+          "Learned skills:\n" +
+          files.map((f) => `  - ${f.replace(/\.(md|js)$/, "")}`).join("\n")
+        );
+      },
+    },
+  ],
+
+  tools: [
+    {
+      type: "function",
+      function: {
+        name: "learn_create",
+        description:
+          "Create a new reusable skill from the current task's approach. " +
+          "The skill will be saved to .nex/skills/ and loaded automatically in future sessions.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description:
+                "Skill name: lowercase, hyphens allowed, 2-64 chars (e.g. deploy-nextjs, fix-docker-dns)",
+            },
+            description: {
+              type: "string",
+              description: "One-line description of what this skill does",
+            },
+            triggers: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Keywords that should activate this skill (e.g. [\"deploy\", \"nextjs\", \"vercel\"])",
+            },
+            content: {
+              type: "string",
+              description:
+                "Skill instructions in markdown. Should be a step-by-step guide the agent can follow.",
+            },
+          },
+          required: ["name", "description", "content"],
+        },
+      },
+      execute: async (args) => {
+        const { name, description, content, triggers } = args;
+
+        // Validate name
+        const nameErr = validateName(name);
+        if (nameErr) return JSON.stringify({ status: "error", error: nameErr });
+
+        // Validate content
+        if (!content || content.trim().length < 20) {
+          return JSON.stringify({
+            status: "error",
+            error: "Content must be at least 20 characters",
+          });
+        }
+        if (!description || description.trim().length < 5) {
+          return JSON.stringify({
+            status: "error",
+            error: "Description must be at least 5 characters",
+          });
+        }
+
+        const dir = ensureSkillsDir();
+        const filePath = path.join(dir, `${name}.md`);
+
+        // Check if skill already exists
+        if (fs.existsSync(filePath)) {
+          return JSON.stringify({
+            status: "error",
+            error: `Skill "${name}" already exists. Use skill_learn_patch to update it.`,
+          });
+        }
+
+        // Write skill file
+        const skillContent = buildSkillContent(
+          name,
+          description,
+          triggers || [],
+          content.trim(),
+        );
+        fs.writeFileSync(filePath, skillContent, "utf-8");
+
+        // Reload skills if the loader is available
+        try {
+          const { loadAllSkills } = require("../skills");
+          loadAllSkills();
+        } catch {
+          // skills.js may not be loadable in all contexts
+        }
+
+        return JSON.stringify({
+          status: "created",
+          name,
+          path: filePath,
+          triggers: triggers || [],
+          note: "Skill will be active in the next session (or after /reload-skills).",
+        });
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "learn_patch",
+        description:
+          "Update an existing skill by replacing a section of its content. " +
+          "Use this when a skill is outdated, incomplete, or wrong.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Name of the skill to patch",
+            },
+            old_text: {
+              type: "string",
+              description: "Exact text to find in the skill file",
+            },
+            new_text: {
+              type: "string",
+              description: "Replacement text",
+            },
+          },
+          required: ["name", "old_text", "new_text"],
+        },
+      },
+      execute: async (args) => {
+        const { name, old_text, new_text } = args;
+
+        if (!name) {
+          return JSON.stringify({ status: "error", error: "name is required" });
+        }
+
+        const dir = getSkillsDir();
+        // Try both .md and .js extensions
+        let filePath = path.join(dir, `${name}.md`);
+        if (!fs.existsSync(filePath)) {
+          filePath = path.join(dir, `${name}.js`);
+        }
+        if (!fs.existsSync(filePath)) {
+          return JSON.stringify({
+            status: "error",
+            error: `Skill "${name}" not found in ${dir}`,
+          });
+        }
+
+        const content = fs.readFileSync(filePath, "utf-8");
+        if (!content.includes(old_text)) {
+          return JSON.stringify({
+            status: "error",
+            error: "old_text not found in skill file. Read the skill first to get the exact text.",
+          });
+        }
+
+        const updated = content.replace(old_text, new_text);
+        fs.writeFileSync(filePath, updated, "utf-8");
+
+        // Reload skills
+        try {
+          const { loadAllSkills } = require("../skills");
+          loadAllSkills();
+        } catch {
+          // skills.js may not be loadable in all contexts
+        }
+
+        return JSON.stringify({
+          status: "patched",
+          name,
+          path: filePath,
+        });
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "learn_read",
+        description: "Read the full content of an existing skill to review or patch it.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Name of the skill to read",
+            },
+          },
+          required: ["name"],
+        },
+      },
+      execute: async (args) => {
+        const { name } = args;
+        if (!name) {
+          return JSON.stringify({ status: "error", error: "name is required" });
+        }
+
+        const dir = getSkillsDir();
+        let filePath = path.join(dir, `${name}.md`);
+        if (!fs.existsSync(filePath)) {
+          filePath = path.join(dir, `${name}.js`);
+        }
+        if (!fs.existsSync(filePath)) {
+          return JSON.stringify({
+            status: "error",
+            error: `Skill "${name}" not found in ${dir}`,
+          });
+        }
+
+        const content = fs.readFileSync(filePath, "utf-8");
+        return JSON.stringify({ status: "ok", name, content });
+      },
+    },
+  ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nex-code",
-  "version": "0.4.24",
+  "version": "0.4.26",
   "description": "Run 400B+ open coding models on your codebase without the hardware bill. Ollama Cloud first — OpenAI, Anthropic, and Gemini when you need them.",
   "bin": {
     "nex-code": "./dist/nex-code.js"
@@ -16,7 +16,7 @@
   },
   "scripts": {
     "start": "node dist/nex-code.js",
-    "build": "esbuild bin/nex-code.js --bundle --platform=node --target=node18 --outfile=dist/nex-code.js --minify --external:axios --external:dotenv --external:playwright",
+    "build": "esbuild bin/nex-code.js --bundle --platform=node --target=node18 --outfile=dist/nex-code.js --minify --external:axios --external:dotenv --external:playwright && rm -rf dist/skills && cp -r cli/skills dist/skills",
     "dev": "esbuild bin/nex-code.js --bundle --platform=node --target=node18 --outfile=dist/nex-code.js --external:axios --external:dotenv --external:playwright --watch",
     "test": "jest --forceExit",
     "test:orchestrator": "jest tests/orchestrator.test.js --forceExit",