@namzu/sdk 0.1.1 → 0.1.2

package/src/tools/builtins/bash.ts

@@ -1,70 +1,59 @@
-import { z } from 'zod'
-import { defineTool } from '../defineTool.js'
-import type { ToolContext } from '../../types/tool/index.js'
 import { exec } from 'node:child_process'
 import { promisify } from 'node:util'
+import { z } from 'zod'
+import { DANGEROUS_PATTERNS } from '../../constants/tools/index.js'
+import { defineTool } from '../defineTool.js'
 
 const execAsync = promisify(exec)
 
 const inputSchema = z.object({
-  command: z.string().describe('The bash command to execute'),
-  timeout: z.preprocess(
-    (v) => (typeof v === 'string' ? Number(v) : v),
-    z.number().default(30_000),
-  ).describe('Command timeout in milliseconds. Default: 30000'),
+	command: z.string().describe('The bash command to execute'),
+	timeout: z
+		.preprocess((v) => (typeof v === 'string' ? Number(v) : v), z.number().default(30_000))
+		.describe('Command timeout in milliseconds. Default: 30000'),
 })
 
 type BashInput = z.infer<typeof inputSchema>
 
-const DANGEROUS_PATTERNS = [
-  /rm\s+-rf\s+\//,
-  /mkfs/,
-  /dd\s+if=/,
-  /:(){ :\|:& };:/,
-]
-
 function isDangerousCommand(command: string): boolean {
-  return DANGEROUS_PATTERNS.some((pattern) => pattern.test(command))
+	return DANGEROUS_PATTERNS.some((pattern) => pattern.test(command))
 }
 
 export const BashTool = defineTool({
-  name: 'bash',
-  description:
-    'Executes a bash command and returns stdout/stderr output. Command timeout is configurable.',
-  inputSchema,
-  category: 'shell',
-  permissions: ['shell_execute'],
-  readOnly: false,
-  destructive: (input: BashInput) => isDangerousCommand(input.command),
-  concurrencySafe: false,
-
-  async execute(input, context) {
-    if (isDangerousCommand(input.command)) {
-      return {
-        success: false,
-        output: '',
-        error: `Dangerous command blocked: "${input.command}"`,
-      }
-    }
-
-    const { stdout, stderr } = await execAsync(input.command, {
-      cwd: context.workingDirectory,
-      timeout: input.timeout,
-      env: { ...process.env, ...context.env },
-      maxBuffer: 1024 * 1024 * 10,
-    })
-
-    const output = [
-      stdout ? `STDOUT:\n${stdout}` : '',
-      stderr ? `STDERR:\n${stderr}` : '',
-    ]
-      .filter(Boolean)
-      .join('\n\n')
-
-    return {
-      success: true,
-      output: output || '(no output)',
-      data: { exitCode: 0 },
-    }
-  },
+	name: 'bash',
+	description:
+		'Executes a bash command and returns stdout/stderr output. Command timeout is configurable.',
+	inputSchema,
+	category: 'shell',
+	permissions: ['shell_execute'],
+	readOnly: false,
+	destructive: (input: BashInput) => isDangerousCommand(input.command),
+	concurrencySafe: false,
+
+	async execute(input, context) {
+		if (isDangerousCommand(input.command)) {
+			return {
+				success: false,
+				output: '',
+				error: `Dangerous command blocked: "${input.command}"`,
+			}
+		}
+
+		const { stdout, stderr } = await execAsync(input.command, {
+			cwd: context.workingDirectory,
+			timeout: input.timeout,
+			env: { ...process.env, ...context.env },
+			maxBuffer: 1024 * 1024 * 10,
+		})
+
+		const output = [stdout ? `STDOUT:\n${stdout}` : '', stderr ? `STDERR:\n${stderr}` : '']
+			.filter(Boolean)
+			.join('\n\n')
+
+		return {
+			success: true,
+			output: output || '(no output)',
+			data: { exitCode: 0 },
+		}
+	},
 })

package/src/tools/builtins/glob.ts

@@ -1,96 +1,92 @@
+import { glob } from 'node:fs/promises'
+import { basename, dirname, relative, resolve, sep } from 'node:path'
 import { z } from 'zod'
 import { defineTool } from '../defineTool.js'
-import { basename, dirname, resolve, relative, sep } from 'node:path'
-import { glob } from 'node:fs/promises'
 
 const inputSchema = z.object({
-  pattern: z.string().describe('Glob pattern (e.g. "**/*.ts", "src/**/*.js")'),
-  path: z
-    .string()
-    .optional()
-    .describe('Directory to search in. Defaults to the working directory if not specified.'),
+	pattern: z.string().describe('Glob pattern (e.g. "**/*.ts", "src/**/*.js")'),
+	path: z
+		.string()
+		.optional()
+		.describe('Directory to search in. Defaults to the working directory if not specified.'),
 })
 
 function extractGlobBaseDirectory(pattern: string): {
-  baseDir: string
-  relativePattern: string
+	baseDir: string
+	relativePattern: string
 } {
-  const globChars = /[*?[{]/
-  const match = pattern.match(globChars)
+	const globChars = /[*?[{]/
+	const match = pattern.match(globChars)
 
-  if (!match || match.index === undefined) {
-    return { baseDir: dirname(pattern), relativePattern: basename(pattern) }
-  }
+	if (!match || match.index === undefined) {
+		return { baseDir: dirname(pattern), relativePattern: basename(pattern) }
+	}
 
-  const staticPrefix = pattern.slice(0, match.index)
-  const lastSepIndex = Math.max(
-    staticPrefix.lastIndexOf('/'),
-    staticPrefix.lastIndexOf(sep),
-  )
+	const staticPrefix = pattern.slice(0, match.index)
+	const lastSepIndex = Math.max(staticPrefix.lastIndexOf('/'), staticPrefix.lastIndexOf(sep))
 
-  if (lastSepIndex === -1) {
-    return { baseDir: '', relativePattern: pattern }
-  }
+	if (lastSepIndex === -1) {
+		return { baseDir: '', relativePattern: pattern }
+	}
 
-  const baseDir = staticPrefix.slice(0, lastSepIndex)
-  const relativePattern = pattern.slice(lastSepIndex + 1)
+	const baseDir = staticPrefix.slice(0, lastSepIndex)
+	const relativePattern = pattern.slice(lastSepIndex + 1)
 
-  return { baseDir, relativePattern }
+	return { baseDir, relativePattern }
 }
 
 export const GlobTool = defineTool({
-  name: 'glob',
-  description:
-    'Searches for files using a glob pattern. Returns matching file paths.',
-  inputSchema,
-  category: 'filesystem',
-  permissions: ['file_read'],
-  readOnly: true,
-  destructive: false,
-  concurrencySafe: true,
-
-  async execute(input, context) {
-    const basePath = input.path
-      ? resolve(context.workingDirectory, input.path)
-      : context.workingDirectory
-
-    let searchPath = basePath
-    let pattern = input.pattern
-
-    const { baseDir, relativePattern } = extractGlobBaseDirectory(pattern)
-    if (baseDir) {
-      const resolvedPatternBase = resolve(context.workingDirectory, baseDir)
-      if (resolvedPatternBase === basePath || resolvedPatternBase.startsWith(basePath + '/')) {
-        searchPath = resolvedPatternBase
-        pattern = relativePattern
-      }
-    }
-
-    if (!pattern.includes('/') && !pattern.startsWith('**/')) {
-      pattern = `**/${pattern}`
-    }
-
-    const matches: string[] = []
-    const MAX_RESULTS = 500
-
-    for await (const entry of glob(pattern, { cwd: searchPath })) {
-      const absolutePath = resolve(searchPath, entry)
-      matches.push(`./${relative(context.workingDirectory, absolutePath)}`)
-      if (matches.length >= MAX_RESULTS) break
-    }
-
-    if (matches.length === 0) {
-      return {
-        success: true,
-        output: `No files found matching pattern "${input.pattern}" in ${searchPath}`,
-        data: { count: 0, files: [] },
-      }
-    }
-
-    return {
-      success: true,
-      output: matches.join('\n'),
-      data: { count: matches.length, files: matches },
-    }
-  },
+	name: 'glob',
+	description: 'Searches for files using a glob pattern. Returns matching file paths.',
+	inputSchema,
+	category: 'filesystem',
+	permissions: ['file_read'],
+	readOnly: true,
+	destructive: false,
+	concurrencySafe: true,
+
+	async execute(input, context) {
+		const basePath = input.path
+			? resolve(context.workingDirectory, input.path)
+			: context.workingDirectory
+
+		let searchPath = basePath
+		let pattern = input.pattern
+
+		const { baseDir, relativePattern } = extractGlobBaseDirectory(pattern)
+		if (baseDir) {
+			const resolvedPatternBase = resolve(context.workingDirectory, baseDir)
+			if (resolvedPatternBase === basePath || resolvedPatternBase.startsWith(`${basePath}/`)) {
+				searchPath = resolvedPatternBase
+				pattern = relativePattern
+			}
+		}
+
+		if (!pattern.includes('/') && !pattern.startsWith('**/')) {
+			pattern = `**/${pattern}`
+		}
+
+		const matches: string[] = []
+		const MAX_RESULTS = 500
+
+		for await (const entry of glob(pattern, { cwd: searchPath })) {
+			const absolutePath = resolve(searchPath, entry)
+			matches.push(`./${relative(context.workingDirectory, absolutePath)}`)
+			if (matches.length >= MAX_RESULTS) break
+		}
+
+		if (matches.length === 0) {
+			return {
+				success: true,
+				output: `No files found matching pattern "${input.pattern}" in ${searchPath}`,
+				data: { count: 0, files: [] },
+			}
+		}
+
+		return {
+			success: true,
+			output: matches.join('\n'),
+			data: { count: matches.length, files: matches },
+		}
+	},
 })

package/src/tools/builtins/index.ts

@@ -1,16 +1,16 @@
-export { ReadFileTool } from "./read-file.js";
-export { WriteFileTool } from "./write-file.js";
-export { BashTool } from "./bash.js";
-export { GlobTool } from "./glob.js";
-export { SearchToolsTool } from "./search-tools.js";
+export { ReadFileTool } from './read-file.js'
+export { WriteFileTool } from './write-file.js'
+export { BashTool } from './bash.js'
+export { GlobTool } from './glob.js'
+export { SearchToolsTool } from './search-tools.js'
 
-import type { ToolDefinition } from "../../types/tool/index.js";
-import { BashTool } from "./bash.js";
-import { GlobTool } from "./glob.js";
-import { ReadFileTool } from "./read-file.js";
-import { SearchToolsTool } from "./search-tools.js";
-import { WriteFileTool } from "./write-file.js";
+import type { ToolDefinition } from '../../types/tool/index.js'
+import { BashTool } from './bash.js'
+import { GlobTool } from './glob.js'
+import { ReadFileTool } from './read-file.js'
+import { SearchToolsTool } from './search-tools.js'
+import { WriteFileTool } from './write-file.js'
 
 export function getBuiltinTools(): ToolDefinition[] {
-	return [ReadFileTool, WriteFileTool, BashTool, GlobTool, SearchToolsTool];
+	return [ReadFileTool, WriteFileTool, BashTool, GlobTool, SearchToolsTool]
 }

package/src/tools/builtins/read-file.ts

@@ -1,54 +1,49 @@
-import { z } from 'zod'
-import { defineTool } from '../defineTool.js'
 import { readFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
+import { z } from 'zod'
+import { defineTool } from '../defineTool.js'
 
 const inputSchema = z.object({
-  path: z.string().describe('Path to the file to read (absolute or relative)'),
-  offset: z
-    .coerce.number()
-    .int()
-    .min(0)
-    .optional()
-    .describe('Starting line number (0-indexed). Defaults to 0 (beginning of file).'),
-  limit: z
-    .coerce.number()
-    .optional()
-    .describe('Maximum number of lines to read'),
+	path: z.string().describe('Path to the file to read (absolute or relative)'),
+	offset: z.coerce
+		.number()
+		.int()
+		.min(0)
+		.optional()
+		.describe('Starting line number (0-indexed). Defaults to 0 (beginning of file).'),
+	limit: z.coerce.number().optional().describe('Maximum number of lines to read'),
 })
 
 export const ReadFileTool = defineTool({
-  name: 'read_file',
-  description:
-    'Reads a file and returns its contents with line numbers. Supports offset and limit parameters for large files.',
-  inputSchema,
-  category: 'filesystem',
-  permissions: ['file_read'],
-  readOnly: true,
-  destructive: false,
-  concurrencySafe: true,
+	name: 'read_file',
+	description:
+		'Reads a file and returns its contents with line numbers. Supports offset and limit parameters for large files.',
+	inputSchema,
+	category: 'filesystem',
+	permissions: ['file_read'],
+	readOnly: true,
+	destructive: false,
+	concurrencySafe: true,
 
-  async execute(input, context) {
-    const filePath = resolve(context.workingDirectory, input.path)
-    const content = await readFile(filePath, 'utf-8')
-    const lines = content.split('\n')
+	async execute(input, context) {
+		const filePath = resolve(context.workingDirectory, input.path)
+		const content = await readFile(filePath, 'utf-8')
+		const lines = content.split('\n')
 
-    const start = Math.max(0, input.offset ?? 0)
-    const end = input.limit ? start + input.limit : lines.length
-    const selectedLines = lines.slice(start, end)
+		const start = Math.max(0, input.offset ?? 0)
+		const end = input.limit ? start + input.limit : lines.length
+		const selectedLines = lines.slice(start, end)
 
-    const numberedLines = selectedLines
-      .map((line, i) => `${start + i}\t${line}`)
-      .join('\n')
+		const numberedLines = selectedLines.map((line, i) => `${start + i}\t${line}`).join('\n')
 
-    return {
-      success: true,
-      output: numberedLines,
-      data: {
-        totalLines: lines.length,
-        returnedLines: selectedLines.length,
-        path: filePath,
-      },
-    }
-  },
+		return {
+			success: true,
+			output: numberedLines,
+			data: {
+				totalLines: lines.length,
+				returnedLines: selectedLines.length,
+				path: filePath,
+			},
+		}
+	},
 })

package/src/tools/builtins/search-tools.ts

@@ -1,17 +1,17 @@
-import { z } from "zod";
-import { defineTool } from "../defineTool.js";
+import { z } from 'zod'
+import { defineTool } from '../defineTool.js'
 
 const inputSchema = z.object({
-	query: z.string().describe("Tool name or capability keyword to search for"),
-});
+	query: z.string().describe('Tool name or capability keyword to search for'),
+})
 
 export const SearchToolsTool = defineTool({
-	name: "search_tools",
+	name: 'search_tools',
 	description:
-		"Search and load available tools by name or capability. " +
-		"Deferred tools listed in the system prompt must be loaded via this tool before use.",
+		'Search and load available tools by name or capability. ' +
+		'Deferred tools listed in the system prompt must be loaded via this tool before use.',
 	inputSchema,
-	category: "analysis",
+	category: 'analysis',
 	permissions: [],
 	readOnly: true,
 	destructive: false,
@@ -21,25 +21,23 @@ export const SearchToolsTool = defineTool({
 		if (!context.toolRegistry) {
 			return {
 				success: false,
-				output: "",
-				error: "Tool registry not available in this context.",
-			};
+				output: '',
+				error: 'Tool registry not available in this context.',
+			}
 		}
 
-		const matches = context.toolRegistry.searchDeferred(input.query);
+		const matches = context.toolRegistry.searchDeferred(input.query)
 
 		if (matches.length === 0) {
 			return {
 				success: true,
 				output: `No deferred tools matching "${input.query}". All matching tools are already active.`,
-			};
+			}
 		}
 
-		context.toolRegistry.activate(matches.map((t) => t.name));
+		context.toolRegistry.activate(matches.map((t) => t.name))
 
-		const descriptions = matches
-			.map((t) => `- ${t.name}: ${t.description}`)
-			.join("\n");
+		const descriptions = matches.map((t) => `- ${t.name}: ${t.description}`).join('\n')
 
 		return {
 			success: true,
@@ -48,6 +46,6 @@ export const SearchToolsTool = defineTool({
 				activated: matches.map((t) => t.name),
 				count: matches.length,
 			},
-		};
+		}
 	},
-});
+})

package/src/tools/builtins/write-file.ts

@@ -1,34 +1,34 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
 import { z } from 'zod'
 import { defineTool } from '../defineTool.js'
-import { writeFile, mkdir } from 'node:fs/promises'
-import { resolve, dirname } from 'node:path'
 
 const inputSchema = z.object({
-  path: z.string().describe('Path to the file to write'),
-  content: z.string().describe('Content to write to the file'),
+	path: z.string().describe('Path to the file to write'),
+	content: z.string().describe('Content to write to the file'),
 })
 
 export const WriteFileTool = defineTool({
-  name: 'write_file',
-  description:
-    'Writes content to a file. Creates the file if it does not exist, overwrites if it does. Creates intermediate directories as needed.',
-  inputSchema,
-  category: 'filesystem',
-  permissions: ['file_write'],
-  readOnly: false,
-  destructive: true,
-  concurrencySafe: false,
+	name: 'write_file',
+	description:
+		'Writes content to a file. Creates the file if it does not exist, overwrites if it does. Creates intermediate directories as needed.',
+	inputSchema,
+	category: 'filesystem',
+	permissions: ['file_write'],
+	readOnly: false,
+	destructive: true,
+	concurrencySafe: false,
 
-  async execute(input, context) {
-    const filePath = resolve(context.workingDirectory, input.path)
+	async execute(input, context) {
+		const filePath = resolve(context.workingDirectory, input.path)
 
-    await mkdir(dirname(filePath), { recursive: true })
-    await writeFile(filePath, input.content, 'utf-8')
+		await mkdir(dirname(filePath), { recursive: true })
+		await writeFile(filePath, input.content, 'utf-8')
 
-    return {
-      success: true,
-      output: `File written successfully: ${filePath} (${input.content.length} chars)`,
-      data: { path: filePath, size: input.content.length },
-    }
-  },
+		return {
+			success: true,
+			output: `File written successfully: ${filePath} (${input.content.length} chars)`,
+			data: { path: filePath, size: input.content.length },
+		}
+	},
 })