agentikit 0.0.7 → 0.0.8

package/src/tool-runner.ts

@@ -0,0 +1,129 @@
+/**
+ * Tool execution utilities.
+ *
+ * Handles building run commands and executing tool scripts for all supported
+ * kinds (bash, bun, powershell, cmd).
+ */
+
+import fs from "node:fs"
+import path from "node:path"
+import { IS_WINDOWS, isWithin } from "./common"
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+/** The supported tool execution kinds. */
+export type ToolKind = "bash" | "bun" | "powershell" | "cmd"
+
+export interface ToolExecution {
+  command: string
+  args: string[]
+  cwd?: string
+}
+
+export interface ToolInfo {
+  runCmd: string
+  kind: ToolKind
+  install?: ToolExecution
+  execute: ToolExecution
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Build execution metadata for a tool file based on its extension.
+ *
+ * For `.ts` / `.js` files, looks up the nearest `package.json` so that
+ * `bun install` can be run in the correct working directory when the
+ * `AGENTIKIT_BUN_INSTALL` env flag is set.
+ */
+export function buildToolInfo(stashDir: string, filePath: string): ToolInfo {
+  const ext = path.extname(filePath).toLowerCase()
+
+  if (ext === ".sh") {
+    return {
+      runCmd: `bash ${shellQuote(filePath)}`,
+      kind: "bash",
+      execute: { command: "bash", args: [filePath] },
+    }
+  }
+
+  if (ext === ".ps1") {
+    return {
+      runCmd: `powershell -ExecutionPolicy Bypass -File ${shellQuote(filePath)}`,
+      kind: "powershell",
+      execute: { command: "powershell", args: ["-ExecutionPolicy", "Bypass", "-File", filePath] },
+    }
+  }
+
+  if (ext === ".cmd" || ext === ".bat") {
+    return {
+      runCmd: `cmd /c ${shellQuote(filePath)}`,
+      kind: "cmd",
+      execute: { command: "cmd", args: ["/c", filePath] },
+    }
+  }
+
+  if (ext !== ".ts" && ext !== ".js") {
+    throw new Error(`Unsupported tool extension: ${ext}`)
+  }
+
+  const toolsRoot = path.resolve(path.join(stashDir, "tools"))
+  const pkgDir = findNearestPackageDir(path.dirname(filePath), toolsRoot)
+  if (!pkgDir) {
+    return {
+      runCmd: `bun ${shellQuote(filePath)}`,
+      kind: "bun",
+      execute: { command: "bun", args: [filePath] },
+    }
+  }
+  const installFlag = process.env.AGENTIKIT_BUN_INSTALL
+  const shouldInstall = installFlag === "1" || installFlag === "true" || installFlag === "yes"
+
+  const quotedPkgDir = shellQuote(pkgDir)
+  const quotedFilePath = shellQuote(filePath)
+  const cdCmd = IS_WINDOWS ? `cd /d ${quotedPkgDir}` : `cd ${quotedPkgDir}`
+  const chain = IS_WINDOWS ? " & " : " && "
+  return {
+    runCmd: shouldInstall
+      ? `${cdCmd}${chain}bun install${chain}bun ${quotedFilePath}`
+      : `${cdCmd}${chain}bun ${quotedFilePath}`,
+    kind: "bun",
+    install: shouldInstall ? { command: "bun", args: ["install"], cwd: pkgDir } : undefined,
+    execute: { command: "bun", args: [filePath], cwd: pkgDir },
+  }
+}
+
+/**
+ * Shell-quote a path for inclusion in a human-readable `runCmd` string.
+ */
+export function shellQuote(input: string): string {
+  if (/[\r\n\t\0]/.test(input)) {
+    throw new Error("Unsupported control characters in stash path.")
+  }
+  if (IS_WINDOWS) {
+    return `"${input.replace(/"/g, '""')}"`
+  }
+  const escaped = input
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, "\\$")
+    .replace(/`/g, "\\`")
+  return `"${escaped}"`
+}
+
+/**
+ * Walk up from `startDir` toward `toolsRoot` looking for the nearest `package.json`.
+ */
+export function findNearestPackageDir(startDir: string, toolsRoot: string): string | undefined {
+  let current = path.resolve(startDir)
+  const root = path.resolve(toolsRoot)
+  while (isWithin(current, root)) {
+    if (fs.existsSync(path.join(current, "package.json"))) {
+      return current
+    }
+    if (current === root) return undefined
+    current = path.dirname(current)
+  }
+  return undefined
+}
+

package/src/walker.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared filesystem walker for agentikit stash directories.
+ *
+ * Provides a single implementation used by both the search fallback
+ * (stash.ts) and the indexer (indexer.ts) to walk type-specific asset
+ * directories and group files by parent directory.
+ */
+
+import fs from "node:fs"
+import path from "node:path"
+import { type AgentikitAssetType } from "./common"
+import { isRelevantAssetFile } from "./asset-spec"
+
+export interface DirectoryGroup {
+  dirPath: string
+  files: string[]
+}
+
+/**
+ * Walk a type root directory and return files grouped by their parent directory.
+ *
+ * Only files relevant to the given `assetType` are included (e.g. `.md` for
+ * commands, script extensions for tools, `SKILL.md` for skills).
+ */
+export function walkStash(typeRoot: string, assetType: AgentikitAssetType): DirectoryGroup[] {
+  if (!fs.existsSync(typeRoot)) return []
+
+  const groups = new Map<string, string[]>()
+
+  const stack = [typeRoot]
+  while (stack.length > 0) {
+    const current = stack.pop()
+    if (!current) continue
+    const entries = fs.readdirSync(current, { withFileTypes: true })
+    for (const entry of entries) {
+      if (entry.name === ".stash.json") continue
+      const fullPath = path.join(current, entry.name)
+      if (entry.isDirectory()) {
+        stack.push(fullPath)
+      } else if (entry.isFile() && isRelevantAssetFile(assetType, entry.name)) {
+        const parentDir = path.dirname(fullPath)
+        const existing = groups.get(parentDir)
+        if (existing) {
+          existing.push(fullPath)
+        } else {
+          groups.set(parentDir, [fullPath])
+        }
+      }
+    }
+  }
+
+  return Array.from(groups, ([dirPath, files]) => ({ dirPath, files }))
+}

package/.claude-plugin/plugin.json

@@ -1,21 +0,0 @@
-{
-  "name": "agentikit",
-  "description": "Search, open, and run extension assets from an Agentikit stash directory. Provides tools, skills, commands, and agents management for AI coding assistants.",
-  "version": "0.0.1",
-  "author": {
-    "name": "itlackey",
-    "url": "https://github.com/itlackey"
-  },
-  "homepage": "https://github.com/itlackey/agentikit#readme",
-  "repository": "https://github.com/itlackey/agentikit",
-  "license": "CC-BY-4.0",
-  "keywords": [
-    "agentikit",
-    "stash",
-    "tools",
-    "skills",
-    "commands",
-    "agents",
-    "plugin"
-  ]
-}

package/commands/open.md

@@ -1,11 +0,0 @@
----
-description: Open an Agentikit stash asset by its openRef
----
-
-Open an Agentikit stash asset using the CLI. Run:
-
-```bash
-agentikit open $ARGUMENTS
-```
-
-Parse the JSON output and present the asset content to the user based on its type (skill content, command template, agent prompt, or tool info).

package/commands/run.md

@@ -1,11 +0,0 @@
----
-description: Run an Agentikit stash tool by its openRef
----
-
-Run an Agentikit stash tool using the CLI. Run:
-
-```bash
-agentikit run $ARGUMENTS
-```
-
-Parse the JSON output and present the tool's output and exit code to the user.

package/commands/search.md

@@ -1,11 +0,0 @@
----
-description: Search the Agentikit stash for tools, skills, commands, and agents using semantic search
----
-
-Search the Agentikit stash using the CLI. If a search index exists, results are ranked by semantic relevance. Run `agentikit index` first to enable semantic search.
-
-```bash
-agentikit search $ARGUMENTS
-```
-
-Parse the JSON output and present the results to the user in a readable format. Include the `openRef` for each hit so the user can open or run assets. Results may include `description`, `tags`, and `score` fields when semantic search is active.

package/dist/src/plugin.d.ts

@@ -1,2 +0,0 @@
-import { type Plugin } from "@opencode-ai/plugin";
-export declare const plugin: Plugin;

package/dist/src/plugin.js

@@ -1,55 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { agentikitOpen, agentikitRun, agentikitSearch } from "./stash";
-import { agentikitIndex } from "./indexer";
-function tryJson(fn, action) {
-    try {
-        return JSON.stringify(fn());
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return JSON.stringify({ ok: false, error: `Failed to ${action}: ${message}` });
-    }
-}
-export const plugin = async () => ({
-    tool: {
-        agentikit_search: tool({
-            description: "Search the Agentikit stash for tools, skills, commands, and agents.",
-            args: {
-                query: tool.schema.string().describe("Case-insensitive substring search."),
-                type: tool.schema
-                    .enum(["tool", "skill", "command", "agent", "any"])
-                    .optional()
-                    .describe("Optional type filter. Defaults to 'any'."),
-                limit: tool.schema.number().optional().describe("Maximum number of hits to return. Defaults to 20."),
-            },
-            async execute({ query, type, limit }) {
-                return tryJson(() => agentikitSearch({ query, type, limit }), "search Agentikit stash");
-            },
-        }),
-        agentikit_open: tool({
-            description: "Open a stash asset from an openRef returned by agentikit_search.",
-            args: {
-                ref: tool.schema.string().describe("Open reference returned by agentikit_search."),
-            },
-            async execute({ ref }) {
-                return tryJson(() => agentikitOpen({ ref }), "open stash asset");
-            },
-        }),
-        agentikit_run: tool({
-            description: "Run a tool from the Agentikit stash by its openRef. Only tool refs are supported.",
-            args: {
-                ref: tool.schema.string().describe("Open reference of a tool returned by agentikit_search."),
-            },
-            async execute({ ref }) {
-                return tryJson(() => agentikitRun({ ref }), "run stash tool");
-            },
-        }),
-        agentikit_index: tool({
-            description: "Build or rebuild the Agentikit search index. Scans stash directories, generates missing .stash.json metadata, and builds a semantic search index.",
-            args: {},
-            async execute() {
-                return tryJson(() => agentikitIndex(), "build Agentikit index");
-            },
-        }),
-    },
-});

package/skills/stash/SKILL.md

@@ -1,73 +0,0 @@
----
-name: stash
-description: Search, open, and run extension assets from an Agentikit stash directory. Use when the user wants to find tools, skills, commands, or agents in their stash, view asset contents, or execute stash tools.
----
-
-# Agentikit Stash
-
-You have access to the `agentikit` CLI to manage extension assets from a stash directory.
-
-The stash directory is configured via the `AGENTIKIT_STASH_DIR` environment variable and contains:
-
-- **tools/** — executable scripts (.sh, .ts, .js, .ps1, .cmd, .bat)
-- **skills/** — skill directories containing SKILL.md
-- **commands/** — markdown template files
-- **agents/** — markdown agent definition files
-
-## Commands
-
-### Build the search index
-
-Scan stash directories, auto-generate missing `.stash.json` metadata, and build a semantic search index.
-
-```bash
-agentikit index
-```
-
-Run this after adding new extensions to enable semantic search ranking.
-
-### Search the stash
-
-Find assets using a two-stage search pipeline: ripgrep pre-filters `.stash.json` metadata files for fast candidate discovery, then TF-IDF ranks results by semantic relevance. Falls back to name substring matching when no index exists.
-
-```bash
-agentikit search [query] [--type tool|skill|command|agent|any] [--limit N]
-```
-
-### Open an asset
-
-Retrieve the full content/payload of an asset using its `openRef` from search results.
-
-```bash
-agentikit open <openRef>
-```
-
-Returns type-specific payloads:
-- **skill** → full SKILL.md content
-- **command** → markdown template + description
-- **agent** → prompt + description, toolPolicy, modelHint
-- **tool** → execution command and kind
-
-### Run a tool
-
-Execute a tool asset by its `openRef`. Only tool refs are supported.
-
-```bash
-agentikit run <openRef>
-```
-
-Returns the tool's stdout/stderr output and exit code.
-
-## Dependencies
-
-`agentikit init` will auto-install [ripgrep](https://github.com/BurntSushi/ripgrep) to `stash/bin/` if not already on PATH. Ripgrep is used for fast candidate filtering during search.
-
-## Workflow
-
-1. Initialize: `agentikit init` (creates stash dirs, installs ripgrep)
-2. Build the index: `agentikit index`
-3. Search for assets: `agentikit search "deploy" --type tool`
-4. Inspect a result: `agentikit open <openRef>`
-5. Run a tool: `agentikit run <openRef>`
-
-All output is JSON for easy parsing.

package/src/plugin.ts

@@ -1,56 +0,0 @@
-import { type Plugin, tool } from "@opencode-ai/plugin"
-import { agentikitOpen, agentikitRun, agentikitSearch } from "./stash"
-import { agentikitIndex } from "./indexer"
-
-function tryJson(fn: () => unknown, action: string): string {
-  try {
-    return JSON.stringify(fn())
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error)
-    return JSON.stringify({ ok: false, error: `Failed to ${action}: ${message}` })
-  }
-}
-
-export const plugin: Plugin = async () => ({
-  tool: {
-    agentikit_search: tool({
-      description: "Search the Agentikit stash for tools, skills, commands, and agents.",
-      args: {
-        query: tool.schema.string().describe("Case-insensitive substring search."),
-        type: tool.schema
-          .enum(["tool", "skill", "command", "agent", "any"])
-          .optional()
-          .describe("Optional type filter. Defaults to 'any'."),
-        limit: tool.schema.number().optional().describe("Maximum number of hits to return. Defaults to 20."),
-      },
-      async execute({ query, type, limit }) {
-        return tryJson(() => agentikitSearch({ query, type, limit }), "search Agentikit stash")
-      },
-    }),
-    agentikit_open: tool({
-      description: "Open a stash asset from an openRef returned by agentikit_search.",
-      args: {
-        ref: tool.schema.string().describe("Open reference returned by agentikit_search."),
-      },
-      async execute({ ref }) {
-        return tryJson(() => agentikitOpen({ ref }), "open stash asset")
-      },
-    }),
-    agentikit_run: tool({
-      description: "Run a tool from the Agentikit stash by its openRef. Only tool refs are supported.",
-      args: {
-        ref: tool.schema.string().describe("Open reference of a tool returned by agentikit_search."),
-      },
-      async execute({ ref }) {
-        return tryJson(() => agentikitRun({ ref }), "run stash tool")
-      },
-    }),
-    agentikit_index: tool({
-      description: "Build or rebuild the Agentikit search index. Scans stash directories, generates missing .stash.json metadata, and builds a semantic search index.",
-      args: {},
-      async execute() {
-        return tryJson(() => agentikitIndex(), "build Agentikit index")
-      },
-    }),
-  },
-})