@syntesseraai/opencode-feature-factory 0.2.34 → 0.2.36

package/dist/agent-context.d.ts

@@ -1,4 +1,3 @@
-import type { PluginInput } from '@opencode-ai/plugin';
 export interface AgentContext {
     /** Unique UUID for this agent instance */
     id: string;
@@ -27,28 +26,32 @@ export interface AgentContext {
  * Write an agent context file
  * File naming: {agent}-{uuid}.md
  */
-export declare function writeAgentContext(input: PluginInput, context: AgentContext): Promise<string>;
+export declare function writeAgentContext(directory: string, context: AgentContext): Promise<string>;
 /**
  * Read an agent context file by UUID
  */
-export declare function readAgentContextById(input: PluginInput, id: string): Promise<AgentContext | null>;
+export declare function readAgentContextById(directory: string, id: string): Promise<AgentContext | null>;
 /**
  * Update agent status in context file
  */
-export declare function updateAgentStatus(input: PluginInput, id: string, status: AgentContext['status']): Promise<boolean>;
+export declare function updateAgentStatus(directory: string, id: string, status: AgentContext['status']): Promise<boolean>;
 /**
  * List all active agents
  */
-export declare function listActiveAgents(input: PluginInput, sessionId?: string, agentType?: string): Promise<AgentContext[]>;
+export declare function listActiveAgents(directory: string, sessionId?: string, agentType?: string): Promise<AgentContext[]>;
 /**
  * Find agent files by various criteria
  */
-export declare function findAgentFiles(input: PluginInput, agentType?: string, sessionId?: string): Promise<string[]>;
+export declare function findAgentFiles(directory: string, agentType?: string, sessionId?: string): Promise<string[]>;
 /**
  * Find agent file by UUID
  */
-export declare function findAgentFilesById(input: PluginInput, id: string): Promise<string[]>;
+export declare function findAgentFilesById(directory: string, id: string): Promise<string[]>;
 /**
  * Find all agent files
  */
-export declare function findAllAgentFiles(input: PluginInput): Promise<string[]>;
+export declare function findAllAgentFiles(directory: string): Promise<string[]>;
+/**
+ * Delete agent files
+ */
+export declare function deleteAgentFiles(directory: string, files: string[]): Promise<number>;

package/dist/agent-context.js

@@ -1,4 +1,5 @@
 import { isValidUUID } from './uuid.js';
+import { writeFile, readFile, readdir, stat, unlink } from 'fs/promises';
 /**
  * Generate the content for an agent context file
  */
@@ -35,14 +36,12 @@ ${context.delegated_to && context.delegated_to.length > 0 ? context.delegated_to
  * Write an agent context file
  * File naming: {agent}-{uuid}.md
  */
-export async function writeAgentContext(input, context) {
-    const { directory, $ } = input;
+export async function writeAgentContext(directory, context) {
     const fileName = `${context.agent}-${context.id}.md`;
     const filePath = `${directory}/.feature-factory/agents/${fileName}`;
     const content = generateContextFileContent(context);
     try {
-        // Use echo to write file (Bun shell)
-        await $ `echo ${content} > ${filePath}`.quiet();
+        await writeFile(filePath, content, 'utf-8');
         return filePath;
     }
     catch (error) {
@@ -52,21 +51,24 @@ export async function writeAgentContext(input, context) {
 /**
  * Read an agent context file by UUID
  */
-export async function readAgentContextById(input, id) {
-    const { directory, $ } = input;
+export async function readAgentContextById(directory, id) {
     if (!isValidUUID(id)) {
         return null;
     }
     try {
-        // Find file with this UUID
-        const result = await $ `ls ${directory}/.feature-factory/agents/ | grep "-${id}.md"`.quiet();
-        const fileName = result.text().trim();
+        // Read directory and find file with this UUID
+        const agentsDir = `${directory}/.feature-factory/agents`;
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        const fileName = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => entry.name)
+            .find((name) => name.includes(`-${id}.md`));
         if (!fileName) {
             return null;
         }
-        const filePath = `${directory}/.feature-factory/agents/${fileName}`;
-        const content = await $ `cat ${filePath}`.quiet();
-        return parseAgentContext(content.text());
+        const filePath = `${agentsDir}/${fileName}`;
+        const content = await readFile(filePath, 'utf-8');
+        return parseAgentContext(content);
     }
     catch {
         return null;
@@ -119,22 +121,25 @@ function parseAgentContext(content) {
 /**
  * Update agent status in context file
  */
-export async function updateAgentStatus(input, id, status) {
-    const { directory, $ } = input;
+export async function updateAgentStatus(directory, id, status) {
     try {
-        const result = await $ `ls ${directory}/.feature-factory/agents/ | grep "-${id}.md"`.quiet();
-        const fileName = result.text().trim();
+        const agentsDir = `${directory}/.feature-factory/agents`;
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        const fileName = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => entry.name)
+            .find((name) => name.includes(`-${id}.md`));
         if (!fileName) {
             return false;
         }
-        const filePath = `${directory}/.feature-factory/agents/${fileName}`;
+        const filePath = `${agentsDir}/${fileName}`;
         // Read current content
-        const content = await $ `cat ${filePath}`.quiet();
-        let text = content.text();
+        const content = await readFile(filePath, 'utf-8');
+        let text = content;
         // Replace status line
         text = text.replace(/status: \w+/, `status: ${status}`);
         // Write back
-        await $ `echo ${text} > ${filePath}`.quiet();
+        await writeFile(filePath, text, 'utf-8');
         return true;
     }
     catch {
@@ -144,28 +149,25 @@ export async function updateAgentStatus(input, id, status) {
 /**
  * List all active agents
  */
-export async function listActiveAgents(input, sessionId, agentType) {
-    const { directory, $ } = input;
+export async function listActiveAgents(directory, sessionId, agentType) {
     const agentsDir = `${directory}/.feature-factory/agents`;
     try {
         // Check if directory exists
-        await $ `test -d ${agentsDir}`.quiet();
+        await stat(agentsDir);
     }
     catch {
         return [];
     }
     try {
-        const result = await $ `ls ${agentsDir}/*.md 2>/dev/null || echo ""`.quiet();
-        const files = result
-            .text()
-            .trim()
-            .split('\n')
-            .filter((f) => f.endsWith('.md'));
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        const files = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => `${agentsDir}/${entry.name}`);
         const agents = [];
         for (const filePath of files) {
             try {
-                const content = await $ `cat ${filePath}`.quiet();
-                const context = parseAgentContext(content.text());
+                const content = await readFile(filePath, 'utf-8');
+                const context = parseAgentContext(content);
                 if (context) {
                     // Apply filters
                     if (sessionId && context.session !== sessionId) {
@@ -191,33 +193,29 @@ export async function listActiveAgents(input, sessionId, agentType) {
 /**
  * Find agent files by various criteria
  */
-export async function findAgentFiles(input, agentType, sessionId) {
-    const { directory, $ } = input;
+export async function findAgentFiles(directory, agentType, sessionId) {
     const agentsDir = `${directory}/.feature-factory/agents`;
     try {
-        await $ `test -d ${agentsDir}`.quiet();
+        await stat(agentsDir);
     }
     catch {
         return [];
     }
     try {
-        let pattern = '*.md';
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        let files = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => `${agentsDir}/${entry.name}`);
         if (agentType) {
-            pattern = `${agentType}-*.md`;
+            files = files.filter((file) => file.includes(`${agentType}-`));
         }
-        const result = await $ `ls ${agentsDir}/${pattern} 2>/dev/null || echo ""`.quiet();
-        const files = result
-            .text()
-            .trim()
-            .split('\n')
-            .filter((f) => f && f.endsWith('.md'));
         if (sessionId) {
             // Filter by session ID (need to read files)
             const filteredFiles = [];
             for (const file of files) {
                 try {
-                    const content = await $ `cat ${file}`.quiet();
-                    if (content.text().includes(`session: "${sessionId}"`)) {
+                    const content = await readFile(file, 'utf-8');
+                    if (content.includes(`session: "${sessionId}"`)) {
                         filteredFiles.push(file);
                     }
                 }
@@ -236,18 +234,16 @@ export async function findAgentFiles(input, agentType, sessionId) {
 /**
  * Find agent file by UUID
  */
-export async function findAgentFilesById(input, id) {
-    const { directory, $ } = input;
+export async function findAgentFilesById(directory, id) {
     if (!isValidUUID(id)) {
         return [];
     }
     try {
-        const result = await $ `ls ${directory}/.feature-factory/agents/*-${id}.md 2>/dev/null || echo ""`.quiet();
-        return result
-            .text()
-            .trim()
-            .split('\n')
-            .filter((f) => f && f.endsWith('.md'));
+        const agentsDir = `${directory}/.feature-factory/agents`;
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md') && entry.name.includes(`-${id}.md`))
+            .map((entry) => `${agentsDir}/${entry.name}`);
     }
     catch {
         return [];
@@ -256,18 +252,31 @@ export async function findAgentFilesById(input, id) {
 /**
  * Find all agent files
  */
-export async function findAllAgentFiles(input) {
-    const { directory, $ } = input;
+export async function findAllAgentFiles(directory) {
     const agentsDir = `${directory}/.feature-factory/agents`;
     try {
-        const result = await $ `ls ${agentsDir}/*.md 2>/dev/null || echo ""`.quiet();
-        return result
-            .text()
-            .trim()
-            .split('\n')
-            .filter((f) => f && f.endsWith('.md'));
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => `${agentsDir}/${entry.name}`);
     }
     catch {
         return [];
     }
 }
+/**
+ * Delete agent files
+ */
+export async function deleteAgentFiles(directory, files) {
+    let deletedCount = 0;
+    for (const file of files) {
+        try {
+            await unlink(file);
+            deletedCount++;
+        }
+        catch {
+            // Continue even if one file fails
+        }
+    }
+    return deletedCount;
+}

package/dist/index.js

@@ -42,36 +42,36 @@ export const FeatureFactoryPlugin = async (input) => {
     // Create all tools
     const tools = {
         // Agent management tools
-        'ff-agents-current': createFFAgentsCurrentTool(input),
-        'ff-agents-show': createFFAgentsShowTool(input),
-        'ff-agents-clear': createFFAgentsClearTool(input),
+        'ff-agents-current': createFFAgentsCurrentTool(),
+        'ff-agents-show': createFFAgentsShowTool(),
+        'ff-agents-clear': createFFAgentsClearTool(),
         // Learning/memory tools
-        'ff-learning-store': createFFLearningStoreTool(input),
-        'ff-learning-search': createFFLearningSearchTool(input),
-        'ff-learning-get': createFFLearningGetTool(input),
+        'ff-learning-store': createFFLearningStoreTool(),
+        'ff-learning-search': createFFLearningSearchTool(),
+        'ff-learning-get': createFFLearningGetTool(),
         // Plan tools
-        'ff-plan-create': createFFPlanCreateTool(input),
-        'ff-plan-update': createFFPlanUpdateTool(input),
+        'ff-plan-create': createFFPlanCreateTool(),
+        'ff-plan-update': createFFPlanUpdateTool(),
         // Agent context tools
-        'ff-agent-context-create': createFFAgentContextCreateTool(input),
-        'ff-agent-context-update': createFFAgentContextUpdateTool(input),
+        'ff-agent-context-create': createFFAgentContextCreateTool(),
+        'ff-agent-context-update': createFFAgentContextUpdateTool(),
         // Review tools
-        'ff-review-create': createFFReviewCreateTool(input),
+        'ff-review-create': createFFReviewCreateTool(),
         // File management - agents
-        'ff-agents-get': createFFAgentsGetTool(input),
-        'ff-agents-update': createFFAgentsUpdateTool(input),
-        'ff-agents-delete': createFFAgentsDeleteTool(input),
-        'ff-agents-list': createFFAgentsListTool(input),
+        'ff-agents-get': createFFAgentsGetTool(),
+        'ff-agents-update': createFFAgentsUpdateTool(),
+        'ff-agents-delete': createFFAgentsDeleteTool(),
+        'ff-agents-list': createFFAgentsListTool(),
         // File management - plans
-        'ff-plans-get': createFFPlansGetTool(input),
-        'ff-plans-update': createFFPlansUpdateTool(input),
-        'ff-plans-delete': createFFPlansDeleteTool(input),
-        'ff-plans-list': createFFPlansListTool(input),
+        'ff-plans-get': createFFPlansGetTool(),
+        'ff-plans-update': createFFPlansUpdateTool(),
+        'ff-plans-delete': createFFPlansDeleteTool(),
+        'ff-plans-list': createFFPlansListTool(),
         // File management - reviews
-        'ff-reviews-get': createFFReviewsGetTool(input),
-        'ff-reviews-update': createFFReviewsUpdateTool(input),
-        'ff-reviews-delete': createFFReviewsDeleteTool(input),
-        'ff-reviews-list': createFFReviewsListTool(input),
+        'ff-reviews-get': createFFReviewsGetTool(),
+        'ff-reviews-update': createFFReviewsUpdateTool(),
+        'ff-reviews-delete': createFFReviewsDeleteTool(),
+        'ff-reviews-list': createFFReviewsListTool(),
     };
     // Return combined hooks and tools
     return {

package/dist/learning/memory-get.d.ts

@@ -1,4 +1,3 @@
-import type { PluginInput } from '@opencode-ai/plugin';
 export interface GetCriteria {
     memoryId?: string;
     filePath?: string;
@@ -22,4 +21,4 @@ export interface MemoryData {
     content: string;
     filePath: string;
 }
-export declare function getMemory(input: PluginInput, criteria: GetCriteria): Promise<MemoryData | null>;
+export declare function getMemory(directory: string, criteria: GetCriteria): Promise<MemoryData | null>;

package/dist/learning/memory-get.js

@@ -1,13 +1,13 @@
 import { readFile } from 'fs/promises';
-export async function getMemory(input, criteria) {
+export async function getMemory(directory, criteria) {
     try {
         let filePath = null;
         if (criteria.filePath) {
-            filePath = `${input.directory}/${criteria.filePath}`;
+            filePath = `${directory}/${criteria.filePath}`;
         }
         else if (criteria.memoryId) {
             // Search for file by ID
-            filePath = await findFileById(input.directory, criteria.memoryId);
+            filePath = await findFileById(directory, criteria.memoryId);
             if (!filePath) {
                 return null;
             }
@@ -36,7 +36,7 @@ export async function getMemory(input, criteria) {
             relatedMemories: metadata.related_memories,
             context: metadata.context,
             content: bodyContent,
-            filePath: criteria.filePath || (filePath ? filePath.replace(`${input.directory}/`, '') : ''),
+            filePath: criteria.filePath || (filePath ? filePath.replace(`${directory}/`, '') : ''),
         };
     }
     catch {

package/dist/learning/memory-search.d.ts

@@ -1,4 +1,3 @@
-import type { PluginInput } from '@opencode-ai/plugin';
 export interface SearchCriteria {
     query: string;
     tags?: string[];
@@ -18,4 +17,4 @@ export interface MemoryMetadata {
     tags: string[];
     filePath: string;
 }
-export declare function searchMemories(input: PluginInput, criteria: SearchCriteria): Promise<MemoryMetadata[]>;
+export declare function searchMemories(directory: string, criteria: SearchCriteria): Promise<MemoryMetadata[]>;

package/dist/learning/memory-search.js

@@ -1,7 +1,7 @@
 import { readFile, readdir } from 'fs/promises';
 import { join, relative } from 'path';
-export async function searchMemories(input, criteria) {
-    const memoriesDir = `${input.directory}/.feature-factory/memories`;
+export async function searchMemories(directory, criteria) {
+    const memoriesDir = `${directory}/.feature-factory/memories`;
     const results = [];
     try {
         // Find all memory files
@@ -58,7 +58,7 @@ export async function searchMemories(input, criteria) {
                     agentId: metadata.agent_id,
                     importance: metadata.importance,
                     tags: tags,
-                    filePath: relative(input.directory, filePath),
+                    filePath: relative(directory, filePath),
                     relevance,
                 });
             }

package/dist/learning/memory-store.d.ts

@@ -1,4 +1,3 @@
-import type { PluginInput } from '@opencode-ai/plugin';
 export interface MemoryInput {
     title: string;
     description: string;
@@ -18,4 +17,4 @@ export interface MemoryResult {
     id: string;
     filePath: string;
 }
-export declare function storeMemory(input: PluginInput, memoryInput: MemoryInput): Promise<MemoryResult>;
+export declare function storeMemory(directory: string, memoryInput: MemoryInput): Promise<MemoryResult>;

package/dist/learning/memory-store.js

@@ -1,12 +1,12 @@
 import { v4 as uuidv4 } from 'uuid';
 import { writeFile, mkdir } from 'fs/promises';
 import { dirname } from 'path';
-export async function storeMemory(input, memoryInput) {
+export async function storeMemory(directory, memoryInput) {
     const id = uuidv4();
     const date = new Date().toISOString();
     // Determine file path based on memory type
     const filePath = generateMemoryFilePath(memoryInput.memoryType, id, date);
-    const fullPath = `${input.directory}/${filePath}`;
+    const fullPath = `${directory}/${filePath}`;
     // Generate frontmatter
     const frontmatter = generateFrontmatter(id, date, memoryInput);
     // Generate full content

package/dist/plugins/ff-agent-context-create-plugin.d.ts

@@ -1,3 +1,2 @@
 import { tool } from '@opencode-ai/plugin/tool';
-import type { PluginInput } from '@opencode-ai/plugin';
-export declare function createFFAgentContextCreateTool(input: PluginInput): ReturnType<typeof tool>;
+export declare function createFFAgentContextCreateTool(): ReturnType<typeof tool>;

package/dist/plugins/ff-agent-context-create-plugin.js

@@ -1,7 +1,7 @@
 import { tool } from '@opencode-ai/plugin/tool';
 import { writeFile, mkdir } from 'fs/promises';
 import { dirname } from 'path';
-export function createFFAgentContextCreateTool(input) {
+export function createFFAgentContextCreateTool() {
     return tool({
         description: 'Create a new agent context file in .feature-factory/agents/. Use this to document agent tasks, track progress, and maintain delegation chains.',
         args: {
@@ -22,10 +22,10 @@ export function createFFAgentContextCreateTool(input) {
                 .describe('Array of child agent UUIDs'),
             notes: tool.schema.string().optional().describe('Additional notes or context'),
         },
-        async execute(args) {
+        async execute(args, toolCtx) {
             try {
                 const timestamp = new Date().toISOString();
-                const filePath = `${input.directory}/.feature-factory/agents/${args.agent}-${args.id}.md`;
+                const filePath = `${toolCtx.directory}/.feature-factory/agents/${args.agent}-${args.id}.md`;
                 // Generate frontmatter
                 const frontmatter = `---
 
@@ -33,7 +33,7 @@ id: "${args.id}"
 agent: ${args.agent}
 title: "${args.title}"
 description: "${args.description}"
-folder: "${input.directory}"
+folder: "${toolCtx.directory}"
 status: ${args.status}
 started: "${timestamp}"
 session: "${args.agent}-${args.id}"

package/dist/plugins/ff-agent-context-update-plugin.d.ts

@@ -1,3 +1,2 @@
 import { tool } from '@opencode-ai/plugin/tool';
-import type { PluginInput } from '@opencode-ai/plugin';
-export declare function createFFAgentContextUpdateTool(input: PluginInput): ReturnType<typeof tool>;
+export declare function createFFAgentContextUpdateTool(): ReturnType<typeof tool>;

package/dist/plugins/ff-agent-context-update-plugin.js

@@ -1,6 +1,6 @@
 import { tool } from '@opencode-ai/plugin/tool';
 import { readFile, writeFile } from 'fs/promises';
-export function createFFAgentContextUpdateTool(input) {
+export function createFFAgentContextUpdateTool() {
     return tool({
         description: 'Update an existing agent context file in .feature-factory/agents/. Use this to update status, add delegated agents, or append notes.',
         args: {
@@ -20,9 +20,9 @@ export function createFFAgentContextUpdateTool(input) {
                 .optional()
                 .describe('Progress update to add (e.g., "- [x] Step completed")'),
         },
-        async execute(args) {
+        async execute(args, toolCtx) {
             try {
-                const filePath = `${input.directory}/.feature-factory/agents/${args.agent}-${args.agentId}.md`;
+                const filePath = `${toolCtx.directory}/.feature-factory/agents/${args.agent}-${args.agentId}.md`;
                 // Read existing file
                 let content;
                 try {

package/dist/plugins/ff-agents-clear-plugin.d.ts

@@ -1,3 +1,2 @@
 import { tool } from '@opencode-ai/plugin/tool';
-import type { PluginInput } from '@opencode-ai/plugin';
-export declare function createFFAgentsClearTool(input: PluginInput): ReturnType<typeof tool>;
+export declare function createFFAgentsClearTool(): ReturnType<typeof tool>;

package/dist/plugins/ff-agents-clear-plugin.js

@@ -1,7 +1,6 @@
 import { tool } from '@opencode-ai/plugin/tool';
-import { findAgentFiles, findAgentFilesById, findAllAgentFiles } from '../agent-context.js';
-export function createFFAgentsClearTool(input) {
-    const { $ } = input;
+import { findAgentFiles, findAgentFilesById, findAllAgentFiles, deleteAgentFiles, } from '../agent-context.js';
+export function createFFAgentsClearTool() {
     return tool({
         description: 'Clear agent context files. Can clear all, or filter by session, agent type, or specific UUID',
         args: {
@@ -9,36 +8,29 @@ export function createFFAgentsClearTool(input) {
             agent: tool.schema.string().optional().describe('Clear only specific agent type'),
             id: tool.schema.string().optional().describe('Clear specific agent by UUID'),
         },
-        async execute(args) {
+        async execute(args, toolCtx) {
             try {
                 let files = [];
                 if (args.id) {
-                    files = await findAgentFilesById(input, args.id);
+                    files = await findAgentFilesById(toolCtx.directory, args.id);
                 }
                 else if (args.agent && args.sessionID) {
-                    files = await findAgentFiles(input, args.agent, args.sessionID);
+                    files = await findAgentFiles(toolCtx.directory, args.agent, args.sessionID);
                 }
                 else if (args.sessionID) {
-                    files = await findAgentFiles(input, undefined, args.sessionID);
+                    files = await findAgentFiles(toolCtx.directory, undefined, args.sessionID);
                 }
                 else if (args.agent) {
-                    files = await findAgentFiles(input, args.agent);
+                    files = await findAgentFiles(toolCtx.directory, args.agent);
                 }
                 else {
-                    files = await findAllAgentFiles(input);
+                    files = await findAllAgentFiles(toolCtx.directory);
                 }
                 if (files.length === 0) {
                     return 'No agent context files found to clear.';
                 }
-                for (const file of files) {
-                    try {
-                        await $ `rm ${file}`.quiet();
-                    }
-                    catch {
-                        // Continue even if one file fails
-                    }
-                }
-                return `Cleared ${files.length} agent context file(s)`;
+                const deletedCount = await deleteAgentFiles(toolCtx.directory, files);
+                return `Cleared ${deletedCount} agent context file(s)`;
             }
             catch (error) {
                 return `Error clearing agents: ${error}`;

package/dist/plugins/ff-agents-current-plugin.d.ts

@@ -1,3 +1,2 @@
 import { tool } from '@opencode-ai/plugin/tool';
-import type { PluginInput } from '@opencode-ai/plugin';
-export declare function createFFAgentsCurrentTool(input: PluginInput): ReturnType<typeof tool>;
+export declare function createFFAgentsCurrentTool(): ReturnType<typeof tool>;

package/dist/plugins/ff-agents-current-plugin.js

@@ -1,6 +1,6 @@
 import { tool } from '@opencode-ai/plugin/tool';
 import { listActiveAgents } from '../agent-context.js';
-export function createFFAgentsCurrentTool(input) {
+export function createFFAgentsCurrentTool() {
     return tool({
         description: 'List all currently active Feature Factory agents with their UUIDs and status',
         args: {
@@ -10,9 +10,9 @@ export function createFFAgentsCurrentTool(input) {
                 .optional()
                 .describe('Filter by agent type (e.g., planning, research)'),
         },
-        async execute(args) {
+        async execute(args, toolCtx) {
             try {
-                const agents = await listActiveAgents(input, args.sessionID, args.agent);
+                const agents = await listActiveAgents(toolCtx.directory, args.sessionID, args.agent);
                 if (agents.length === 0) {
                     return JSON.stringify({
                         count: 0,

package/dist/plugins/ff-agents-delete-plugin.d.ts

@@ -1,3 +1,2 @@
 import { tool } from '@opencode-ai/plugin/tool';
-import type { PluginInput } from '@opencode-ai/plugin';
-export declare function createFFAgentsDeleteTool(input: PluginInput): ReturnType<typeof tool>;
+export declare function createFFAgentsDeleteTool(): ReturnType<typeof tool>;

package/dist/plugins/ff-agents-delete-plugin.js

@@ -1,8 +1,7 @@
 import { tool } from '@opencode-ai/plugin/tool';
 import { validateSafePath, resolveSafePath, getFeatureFactoryDir } from '../utils/file-utils.js';
-export function createFFAgentsDeleteTool(input) {
-    const { directory, $ } = input;
-    const agentsDir = getFeatureFactoryDir(directory, 'agents');
+import { unlink } from 'fs/promises';
+export function createFFAgentsDeleteTool() {
     return tool({
         description: 'Delete an agent context file from .feature-factory/agents',
         args: {
@@ -10,25 +9,22 @@ export function createFFAgentsDeleteTool(input) {
                 .string()
                 .describe('Name of the agent file to delete (e.g., "planning-abc123.md")'),
         },
-        async execute(args) {
+        async execute(args, toolCtx) {
             try {
+                const agentsDir = getFeatureFactoryDir(toolCtx.directory, 'agents');
                 // Validate the file path
                 if (!validateSafePath(agentsDir, args.fileName)) {
                     return `Error: Invalid or unsafe file name "${args.fileName}". Only .md files with alphanumeric names are allowed.`;
                 }
                 const filePath = resolveSafePath(agentsDir, args.fileName);
-                // Check if file exists
-                try {
-                    await $ `test -f ${filePath}`.quiet();
-                }
-                catch {
-                    return `Error: File "${args.fileName}" not found in .feature-factory/agents`;
-                }
                 // Delete the file
-                await $ `rm ${filePath}`.quiet();
+                await unlink(filePath);
                 return `Successfully deleted agent file: ${args.fileName}`;
             }
             catch (error) {
+                if (error.code === 'ENOENT') {
+                    return `Error: File "${args.fileName}" not found in .feature-factory/agents`;
+                }
                 return `Error deleting agent file: ${error}`;
             }
         },

package/dist/plugins/ff-agents-get-plugin.d.ts

@@ -1,3 +1,2 @@
 import { tool } from '@opencode-ai/plugin/tool';
-import type { PluginInput } from '@opencode-ai/plugin';
-export declare function createFFAgentsGetTool(input: PluginInput): ReturnType<typeof tool>;
+export declare function createFFAgentsGetTool(): ReturnType<typeof tool>;