@hung319/opencode-hive 1.4.0 → 1.4.2

package/dist/hooks/smart-title.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Smart Session Title Plugin
+ *
+ * Auto-generates meaningful session titles based on conversation content.
+ * Based on: https://github.com/Tarquinen/opencode-smart-title
+ *
+ * Note: This is a simplified version that uses heuristics.
+ * Full AI-based title generation can be added later.
+ */
+import type { Event } from '@opencode-ai/sdk';
+export interface SmartTitleConfig {
+    enabled?: boolean;
+    updateThreshold?: number;
+}
+export declare function createSmartTitleHandler(config: SmartTitleConfig): (input: {
+    event: Event;
+}) => Promise<void>;
+export declare function clearSessionData(sessionID: string): void;

package/dist/index.js

@@ -16266,6 +16266,267 @@ async function buildMemoryInjection(projectRoot) {
   return sections.join(`
 `);
 }
+function getTypedMemoryDir() {
+  return path2.join(os.homedir(), ".config", "opencode", "hive", "typed-memory");
+}
+function getDeletionsFile() {
+  return path2.join(getTypedMemoryDir(), "deletions.logfmt");
+}
+function parseTypedMemoryLine(line) {
+  const tsMatch = line.match(/ts=([^\s]+)/);
+  const typeMatch = line.match(/type=([^\s]+)/);
+  const scopeMatch = line.match(/scope=([^\s]+)/);
+  const contentMatch = line.match(/content="([^"]*(?:\\"[^"]*)*)"/);
+  const issueMatch = line.match(/issue=([^\s]+)/);
+  const tagsMatch = line.match(/tags=([^\s]+)/);
+  if (!tsMatch?.[1] || !typeMatch?.[1] || !scopeMatch?.[1])
+    return null;
+  return {
+    ts: tsMatch[1],
+    type: typeMatch[1],
+    scope: scopeMatch[1],
+    content: contentMatch?.[1]?.replace(/\\"/g, '"') || "",
+    issue: issueMatch?.[1],
+    tags: tagsMatch?.[1]?.split(",")
+  };
+}
+function formatTypedMemory(m) {
+  const date5 = m.ts.split("T")[0];
+  const tags = m.tags?.length ? ` [${m.tags.join(", ")}]` : "";
+  const issue2 = m.issue ? ` (${m.issue})` : "";
+  return `[${date5}] ${m.type}/${m.scope}: ${m.content}${issue2}${tags}`;
+}
+function scoreTypedMemoryMatch(memory, words) {
+  const searchable = `${memory.type} ${memory.scope} ${memory.content} ${memory.tags?.join(" ") || ""}`.toLowerCase();
+  let score = 0;
+  for (const word of words) {
+    if (searchable.includes(word))
+      score++;
+    if (memory.scope.toLowerCase() === word)
+      score += 2;
+    if (memory.type.toLowerCase() === word)
+      score += 2;
+  }
+  return score;
+}
+async function ensureTypedMemoryDir() {
+  const dir = getTypedMemoryDir();
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+async function getAllTypedMemories() {
+  const dir = getTypedMemoryDir();
+  if (!fs2.existsSync(dir))
+    return [];
+  const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".logfmt"));
+  if (!files.length)
+    return [];
+  const lines = [];
+  for (const filename of files) {
+    if (filename === "deletions.logfmt")
+      continue;
+    const filepath = path2.join(dir, filename);
+    const text = fs2.readFileSync(filepath, "utf-8");
+    lines.push(...text.trim().split(`
+`).filter(Boolean));
+  }
+  return lines.map(parseTypedMemoryLine).filter((m) => m !== null);
+}
+async function findTypedMemories(scope, type, query) {
+  const dir = getTypedMemoryDir();
+  if (!fs2.existsSync(dir))
+    return [];
+  const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".logfmt"));
+  const matches = [];
+  for (const filename of files) {
+    if (filename === "deletions.logfmt")
+      continue;
+    const filepath = path2.join(dir, filename);
+    const text = fs2.readFileSync(filepath, "utf-8");
+    const lines = text.split(`
+`);
+    lines.forEach((line, lineIndex) => {
+      const memory = parseTypedMemoryLine(line);
+      if (!memory)
+        return;
+      if (scope && memory.scope !== scope)
+        return;
+      if (type && memory.type !== type)
+        return;
+      if (query) {
+        const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+        if (scoreTypedMemoryMatch(memory, words) === 0)
+          return;
+      }
+      matches.push({ filepath, lineIndex });
+    });
+  }
+  return matches;
+}
+async function logTypedMemoryDeletion(memory, reason) {
+  await ensureTypedMemoryDir();
+  const ts = new Date().toISOString();
+  const content = memory.content.replace(/"/g, "\\\"");
+  const escapedReason = reason.replace(/"/g, "\\\"");
+  const issue2 = memory.issue ? ` issue=${memory.issue}` : "";
+  const tags = memory.tags?.length ? ` tags=${memory.tags.join(",")}` : "";
+  const line = `ts=${ts} action=deleted original_ts=${memory.ts} type=${memory.type} scope=${memory.scope} content="${content}" reason="${escapedReason}"${issue2}${tags}
+`;
+  const file2 = getDeletionsFile();
+  const existing = fs2.existsSync(file2) ? fs2.readFileSync(file2, "utf-8") : "";
+  fs2.writeFileSync(file2, existing + line);
+}
+var hiveMemoryRecallTool = tool({
+  description: "Search typed memories by scope, type, or query. Retrieve learnings, decisions, preferences, and patterns.",
+  args: {
+    scope: tool.schema.string().optional().describe("Filter by scope (e.g., project, user, auth, api)"),
+    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).optional().describe("Filter by memory type"),
+    query: tool.schema.string().optional().describe("Search terms (matches type, scope, content)"),
+    limit: tool.schema.number().optional().describe("Maximum results (default: 20)")
+  },
+  async execute({ scope, type, query, limit = 20 }) {
+    await ensureTypedMemoryDir();
+    const allMemories = await getAllTypedMemories();
+    if (!allMemories.length) {
+      return JSON.stringify({
+        message: "No typed memories found. Use hive_memory_set to create one.",
+        total: 0,
+        results: []
+      }, null, 2);
+    }
+    let results = allMemories;
+    if (scope) {
+      results = results.filter((m) => m.scope === scope || m.scope.includes(scope));
+    }
+    if (type) {
+      results = results.filter((m) => m.type === type);
+    }
+    if (query) {
+      const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+      const scored = results.map((m) => ({ memory: m, score: scoreTypedMemoryMatch(m, words) })).filter((x) => x.score > 0).sort((a, b) => b.score - a.score);
+      results = scored.map((x) => x.memory);
+    }
+    const totalCount = allMemories.length;
+    const filteredCount = results.length;
+    const limited = results.slice(0, limit);
+    if (!limited.length) {
+      return JSON.stringify({
+        message: "No matching memories found.",
+        total: totalCount,
+        results: []
+      }, null, 2);
+    }
+    return JSON.stringify({
+      total: totalCount,
+      filtered: filteredCount,
+      returned: limited.length,
+      results: limited.map((m) => ({
+        type: m.type,
+        scope: m.scope,
+        content: m.content,
+        created: m.ts,
+        issue: m.issue,
+        tags: m.tags,
+        formatted: formatTypedMemory(m)
+      }))
+    }, null, 2);
+  }
+});
+var hiveMemoryUpdateTool = tool({
+  description: "Update a typed memory entry. Finds by scope and type, updates content.",
+  args: {
+    scope: tool.schema.string().describe("Scope of memory to update"),
+    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).describe("Type of memory"),
+    content: tool.schema.string().describe("New content"),
+    query: tool.schema.string().optional().describe("If multiple matches, filter by query")
+  },
+  async execute({ scope, type, content, query }) {
+    const matches = await findTypedMemories(scope, type);
+    if (matches.length === 0) {
+      return JSON.stringify({
+        success: false,
+        error: `No memories found for ${type} in ${scope}`
+      }, null, 2);
+    }
+    let target = matches[0];
+    if (matches.length > 1 && query) {
+      const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+      const scored = matches.map((m) => {
+        const memory = parseTypedMemoryLine(fs2.readFileSync(m.filepath, "utf-8").split(`
+`)[m.lineIndex]);
+        return { match: m, score: memory ? scoreTypedMemoryMatch(memory, words) : 0 };
+      }).filter((x) => x.score > 0).sort((a, b) => b.score - a.score);
+      if (scored.length === 0) {
+        return JSON.stringify({
+          success: false,
+          error: `Found ${matches.length} memories for ${type}/${scope}, but none matched query "${query}"`
+        }, null, 2);
+      }
+      target = scored[0].match;
+    }
+    const oldLine = fs2.readFileSync(target.filepath, "utf-8").split(`
+`)[target.lineIndex];
+    const oldMemory = parseTypedMemoryLine(oldLine);
+    if (oldMemory) {
+      await logTypedMemoryDeletion(oldMemory, `Updated to: ${content}`);
+    }
+    const ts = new Date().toISOString();
+    const lines = fs2.readFileSync(target.filepath, "utf-8").split(`
+`);
+    lines[target.lineIndex] = `ts=${ts} type=${type} scope=${scope} content="${content.replace(/"/g, "\\\"")}"`;
+    fs2.writeFileSync(target.filepath, lines.join(`
+`));
+    return JSON.stringify({
+      success: true,
+      scope,
+      type,
+      content,
+      message: `Updated ${type} in ${scope}`
+    }, null, 2);
+  }
+});
+var hiveMemoryForgetTool = tool({
+  description: "Delete a typed memory. Logs deletion for audit purposes.",
+  args: {
+    scope: tool.schema.string().describe("Scope of memory to delete"),
+    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).describe("Type of memory"),
+    reason: tool.schema.string().describe("Why this memory is being deleted")
+  },
+  async execute({ scope, type, reason }) {
+    const matches = await findTypedMemories(scope, type);
+    if (matches.length === 0) {
+      return JSON.stringify({
+        success: false,
+        error: `No memories found for ${type} in ${scope}`
+      }, null, 2);
+    }
+    let deleted = 0;
+    const deletedMemories = [];
+    for (const match of matches) {
+      const text = fs2.readFileSync(match.filepath, "utf-8");
+      const lines = text.split(`
+`);
+      const memory = parseTypedMemoryLine(lines[match.lineIndex]);
+      if (memory) {
+        await logTypedMemoryDeletion(memory, reason);
+        deletedMemories.push(memory);
+        deleted++;
+      }
+      lines.splice(match.lineIndex, 1);
+      fs2.writeFileSync(match.filepath, lines.join(`
+`));
+    }
+    return JSON.stringify({
+      success: true,
+      deleted,
+      scope,
+      type,
+      reason,
+      message: `Deleted ${deleted} ${type} memory(ies) from ${scope}. Deletion logged.`
+    }, null, 2);
+  }
+});
 
 // src/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
@@ -18471,6 +18732,14 @@ var DEFAULT_HIVE_CONFIG = {
     includeActiveFeature: true,
     includePendingTasks: true,
     includeModifiedFiles: false
+  },
+  snip: {
+    enabled: false,
+    command: "snip"
+  },
+  smartTitle: {
+    enabled: false,
+    updateThreshold: 1
   }
 };
 var HIVE_DIR = ".hive";
@@ -25165,6 +25434,18 @@ No Hive skills available.` : base + formatSkillsXml(filteredSkills);
     }
   });
 }
+var ENV_VAR_RE = /^([A-Za-z_][A-Za-z0-9_]*=[^\s]* +)*/;
+function prefixWithSnip(command, snipCommand = "snip") {
+  if (command.startsWith(`${snipCommand} `)) {
+    return command;
+  }
+  const splitMatch = command.match(/^(.*?)( &&| [|]| ;|;)(.*)$/);
+  const firstPart = splitMatch ? splitMatch[1] : command;
+  const rest = splitMatch ? splitMatch[2] + splitMatch[3] : "";
+  const envPrefix = (firstPart.match(ENV_VAR_RE) ?? [""])[0];
+  const bareCmd = firstPart.slice(envPrefix.length).trim();
+  return `${envPrefix}${snipCommand} ${bareCmd}${rest}`;
+}
 var plugin = async (ctx) => {
   const { directory, client } = ctx;
   const featureService = new FeatureService(directory);
@@ -25753,9 +26034,6 @@ ${snapshot}
       }
       if (input.tool !== "bash")
         return;
-      const sandboxConfig = configService.getSandboxConfig();
-      if (sandboxConfig.mode === "none")
-        return;
       const command = output.args?.command?.trim();
       if (!command)
         return;
@@ -25765,15 +26043,27 @@ ${snapshot}
         output.args.command = strippedCommand;
         return;
       }
-      const workdir = output.args?.workdir;
-      if (!workdir)
-        return;
-      const hiveWorktreeBase = path8.join(directory, ".hive", ".worktrees");
-      if (!workdir.startsWith(hiveWorktreeBase))
-        return;
-      const wrapped = DockerSandboxService.wrapCommand(workdir, command, sandboxConfig);
-      output.args.command = wrapped;
-      output.args.workdir = undefined;
+      const snipConfig = configService.get().snip;
+      let finalCommand = command;
+      if (snipConfig?.enabled) {
+        finalCommand = prefixWithSnip(command, snipConfig.command ?? "snip");
+      }
+      const sandboxConfig = configService.getSandboxConfig();
+      if (sandboxConfig.mode !== "none") {
+        const workdir = output.args?.workdir;
+        if (workdir) {
+          const hiveWorktreeBase = path8.join(directory, ".hive", ".worktrees");
+          if (workdir.startsWith(hiveWorktreeBase)) {
+            const wrapped = DockerSandboxService.wrapCommand(workdir, finalCommand, sandboxConfig);
+            output.args.command = wrapped;
+            output.args.workdir = undefined;
+            return;
+          }
+        }
+      }
+      if (snipConfig?.enabled && finalCommand !== command) {
+        output.args.command = finalCommand;
+      }
     },
     "tool.execute.after": async (input, output) => {
       const truncationConfig = configService.get().tokenTruncation;
@@ -25818,6 +26108,9 @@ ${snapshot}
       hive_memory_list: hiveMemoryListTool,
       hive_memory_set: hiveMemorySetTool,
       hive_memory_replace: hiveMemoryReplaceTool,
+      hive_memory_recall: hiveMemoryRecallTool,
+      hive_memory_update: hiveMemoryUpdateTool,
+      hive_memory_forget: hiveMemoryForgetTool,
       hive_journal_write: hiveJournalWriteTool,
       hive_journal_search: hiveJournalSearchTool,
       hive_skill: createHiveSkillTool(filteredSkills),
@@ -26722,12 +27015,24 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         allAgents["scout-researcher"] = builtInAgentConfigs["scout-researcher"];
         allAgents["forager-worker"] = builtInAgentConfigs["forager-worker"];
         allAgents["hygienic-reviewer"] = builtInAgentConfigs["hygienic-reviewer"];
+        allAgents["codebase-locator"] = builtInAgentConfigs["codebase-locator"];
+        allAgents["codebase-analyzer"] = builtInAgentConfigs["codebase-analyzer"];
+        allAgents["pattern-finder"] = builtInAgentConfigs["pattern-finder"];
+        allAgents["project-initializer"] = builtInAgentConfigs["project-initializer"];
+        allAgents["code-reviewer"] = builtInAgentConfigs["code-reviewer"];
+        allAgents["code-simplifier"] = builtInAgentConfigs["code-simplifier"];
       } else {
         allAgents["architect-planner"] = builtInAgentConfigs["architect-planner"];
         allAgents["swarm-orchestrator"] = builtInAgentConfigs["swarm-orchestrator"];
         allAgents["scout-researcher"] = builtInAgentConfigs["scout-researcher"];
         allAgents["forager-worker"] = builtInAgentConfigs["forager-worker"];
         allAgents["hygienic-reviewer"] = builtInAgentConfigs["hygienic-reviewer"];
+        allAgents["codebase-locator"] = builtInAgentConfigs["codebase-locator"];
+        allAgents["codebase-analyzer"] = builtInAgentConfigs["codebase-analyzer"];
+        allAgents["pattern-finder"] = builtInAgentConfigs["pattern-finder"];
+        allAgents["project-initializer"] = builtInAgentConfigs["project-initializer"];
+        allAgents["code-reviewer"] = builtInAgentConfigs["code-reviewer"];
+        allAgents["code-simplifier"] = builtInAgentConfigs["code-simplifier"];
       }
       Object.assign(allAgents, customSubagents);
       const primaryAgent = agentMode === "unified" ? "zetta" : "architect-planner";
@@ -26775,9 +27080,52 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
           }
         }
       }
+    },
+    event: async (input) => {
+      const smartTitleConfig = configService.get().smartTitle;
+      if (!smartTitleConfig?.enabled)
+        return;
+      const { event } = input;
+      if (event.type === "message.created" || event.type === "message-part.created") {
+        const sessionID = event.properties?.sessionID;
+        const role = event.properties?.role;
+        const content = event.properties?.content;
+        if (sessionID && role === "user" && content && !sessionFirstMessage.has(sessionID)) {
+          sessionFirstMessage.set(sessionID, content);
+        }
+      }
+      if (event.type === "session.idle") {
+        const sessionID = event.properties?.sessionID;
+        if (!sessionID)
+          return;
+        if (sessionID.includes("-worker-") || sessionID.includes("-sub-"))
+          return;
+        const currentCount = (sessionIdleCount.get(sessionID) || 0) + 1;
+        sessionIdleCount.set(sessionID, currentCount);
+        if (currentCount % (smartTitleConfig.updateThreshold ?? 1) !== 0)
+          return;
+        const firstMessage = sessionFirstMessage.get(sessionID);
+        if (firstMessage) {
+          const title = generateSmartTitle(firstMessage);
+          console.log(`[hive:smart-title] Title for ${sessionID}: "${title}"`);
+        }
+      }
     }
   };
 };
+var sessionIdleCount = new Map;
+var sessionFirstMessage = new Map;
+function generateSmartTitle(message) {
+  if (!message)
+    return "Untitled session";
+  let cleaned = message.trim();
+  cleaned = cleaned.replace(/^(user[:\s]*|human[:\s]*|hi[,!\s]*|hello[,!\s]*|hey[,!\s]*)/i, "");
+  if (cleaned.length > 50) {
+    cleaned = cleaned.slice(0, 47) + "...";
+  }
+  cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+  return cleaned || "Untitled session";
+}
 var src_default = plugin;
 export {
   src_default as default

package/dist/tools/memory.d.ts

@@ -33,3 +33,15 @@ export declare const hiveMemoryReplaceTool: ToolDefinition;
 export declare const hiveJournalWriteTool: ToolDefinition;
 export declare const hiveJournalSearchTool: ToolDefinition;
 export declare function buildMemoryInjection(projectRoot: string): Promise<string>;
+export type MemoryType = 'decision' | 'learning' | 'preference' | 'blocker' | 'context' | 'pattern';
+export interface TypedMemory {
+    ts: string;
+    type: MemoryType;
+    scope: string;
+    content: string;
+    issue?: string;
+    tags?: string[];
+}
+export declare const hiveMemoryRecallTool: ToolDefinition;
+export declare const hiveMemoryUpdateTool: ToolDefinition;
+export declare const hiveMemoryForgetTool: ToolDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hung319/opencode-hive",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",