@syntesseraai/opencode-feature-factory 0.2.45 → 0.3.0

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

@@ -1,24 +0,0 @@
-export interface GetCriteria {
-    memoryId?: string;
-    filePath?: string;
-}
-export interface MemoryData {
-    id: string;
-    title: string;
-    description: string;
-    date: string;
-    memoryType: string;
-    agentId: string;
-    importance: number;
-    tags: string[];
-    source?: string;
-    relatedMemories?: string[];
-    context?: {
-        project?: string;
-        task?: string;
-        files?: string[];
-    };
-    content: string;
-    filePath: string;
-}
-export declare function getMemory(directory: string, criteria: GetCriteria): Promise<MemoryData | null>;

package/dist/learning/memory-get.js

@@ -1,155 +0,0 @@
-import { readFile } from 'fs/promises';
-export async function getMemory(directory, criteria) {
-    try {
-        let filePath = null;
-        if (criteria.filePath) {
-            filePath = `${directory}/${criteria.filePath}`;
-        }
-        else if (criteria.memoryId) {
-            // Search for file by ID
-            filePath = await findFileById(directory, criteria.memoryId);
-            if (!filePath) {
-                return null;
-            }
-        }
-        else {
-            return null;
-        }
-        const content = await readFile(filePath, 'utf-8');
-        const metadata = parseFrontmatter(content);
-        if (!metadata) {
-            return null;
-        }
-        // Extract content after frontmatter
-        const contentMatch = content.match(/^---\n[\s\S]*?\n---\n\n([\s\S]*)$/);
-        const bodyContent = contentMatch ? contentMatch[1] : '';
-        return {
-            id: metadata.id,
-            title: metadata.title,
-            description: metadata.description,
-            date: metadata.date,
-            memoryType: metadata.memory_type,
-            agentId: metadata.agent_id,
-            importance: metadata.importance,
-            tags: metadata.tags || [],
-            source: metadata.source,
-            relatedMemories: metadata.related_memories,
-            context: metadata.context,
-            content: bodyContent,
-            filePath: criteria.filePath || (filePath ? filePath.replace(`${directory}/`, '') : ''),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-async function findFileById(cwd, id) {
-    const { glob } = await import('glob');
-    try {
-        const files = await glob('**/*.md', {
-            cwd: `${cwd}/.feature-factory/memories`,
-            absolute: true,
-        });
-        for (const file of files) {
-            try {
-                const content = await readFile(file, 'utf-8');
-                const metadata = parseFrontmatter(content);
-                if (metadata && metadata.id === id) {
-                    return file;
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch {
-        // Directory might not exist
-    }
-    return null;
-}
-function parseFrontmatter(content) {
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!match)
-        return null;
-    const frontmatter = match[1];
-    const result = {};
-    // Simple YAML parsing for our specific format
-    const lines = frontmatter.split('\n');
-    let currentKey = null;
-    let currentArray = [];
-    let currentObject = {};
-    let objectKey = null;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Check for array item
-        if (trimmed.startsWith('- ')) {
-            const value = trimmed.substring(2).replace(/^['"]|['"]$/g, '');
-            if (currentKey) {
-                currentArray.push(value);
-            }
-            continue;
-        }
-        // Check for nested object property
-        if (trimmed.match(/^\w+:\s*/)) {
-            const colonIndex = trimmed.indexOf(':');
-            const key = trimmed.substring(0, colonIndex).trim();
-            const value = trimmed
-                .substring(colonIndex + 1)
-                .trim()
-                .replace(/^['"]|['"]$/g, '');
-            // Check if this is a top-level key or nested
-            if (line.startsWith('  ') && objectKey) {
-                // Nested property
-                if (key === 'files' && value === '') {
-                    // Start of files array
-                    currentObject[key] = [];
-                }
-                else {
-                    currentObject[key] = value;
-                }
-            }
-            else {
-                // Top-level key
-                if (currentKey && currentArray.length > 0) {
-                    result[currentKey] = currentArray;
-                    currentArray = [];
-                }
-                if (objectKey && Object.keys(currentObject).length > 0) {
-                    result[objectKey] = currentObject;
-                    currentObject = {};
-                }
-                if (value === '') {
-                    // Could be start of array or object
-                    currentKey = key;
-                    currentArray = [];
-                    objectKey = key;
-                    currentObject = {};
-                }
-                else {
-                    // Simple value
-                    result[key] = value;
-                    currentKey = null;
-                    objectKey = null;
-                }
-            }
-            continue;
-        }
-        // Check for array item in nested context
-        if (trimmed.startsWith('- ') && objectKey) {
-            const value = trimmed.substring(2).replace(/^['"]|['"]$/g, '');
-            if (!currentObject.files) {
-                currentObject.files = [];
-            }
-            currentObject.files.push(value);
-        }
-    }
-    // Handle any remaining data
-    if (currentKey && currentArray.length > 0) {
-        result[currentKey] = currentArray;
-    }
-    if (objectKey && Object.keys(currentObject).length > 0) {
-        result[objectKey] = currentObject;
-    }
-    return result;
-}

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

@@ -1,20 +0,0 @@
-export interface SearchCriteria {
-    query: string;
-    tags?: string[];
-    memoryType?: 'episodic' | 'semantic' | 'procedural';
-    agentId?: string;
-    limit?: number;
-    minImportance?: number;
-}
-export interface MemoryMetadata {
-    id: string;
-    title: string;
-    description: string;
-    date: string;
-    memoryType: string;
-    agentId: string;
-    importance: number;
-    tags: string[];
-    filePath: string;
-}
-export declare function searchMemories(directory: string, criteria: SearchCriteria): Promise<MemoryMetadata[]>;

package/dist/learning/memory-search.js

@@ -1,193 +0,0 @@
-import { readFile, readdir } from 'fs/promises';
-import { join, relative } from 'path';
-export async function searchMemories(directory, criteria) {
-    const memoriesDir = `${directory}/.feature-factory/memories`;
-    const results = [];
-    try {
-        // Find all memory files
-        const files = await findAllMemoryFiles(memoriesDir);
-        // Parse and filter each file
-        for (const filePath of files) {
-            try {
-                const content = await readFile(filePath, 'utf-8');
-                const metadata = parseFrontmatter(content);
-                if (!metadata)
-                    continue;
-                // Apply filters
-                if (criteria.memoryType && metadata.memory_type !== criteria.memoryType) {
-                    continue;
-                }
-                if (criteria.agentId && metadata.agent_id !== criteria.agentId) {
-                    continue;
-                }
-                if (criteria.minImportance !== undefined &&
-                    metadata.importance < criteria.minImportance) {
-                    continue;
-                }
-                if (criteria.tags && criteria.tags.length > 0) {
-                    const tags = metadata.tags || [];
-                    const hasMatchingTag = criteria.tags.some((tag) => tags.includes(tag));
-                    if (!hasMatchingTag)
-                        continue;
-                }
-                // Check query match
-                const queryLower = criteria.query.toLowerCase();
-                const title = metadata.title || '';
-                const description = metadata.description || '';
-                const tags = metadata.tags || [];
-                const titleMatch = title.toLowerCase().includes(queryLower);
-                const descMatch = description.toLowerCase().includes(queryLower);
-                const tagMatch = tags.some((tag) => tag.toLowerCase().includes(queryLower));
-                if (!titleMatch && !descMatch && !tagMatch) {
-                    continue;
-                }
-                // Calculate relevance score
-                let relevance = 0;
-                if (titleMatch)
-                    relevance += 3;
-                if (descMatch)
-                    relevance += 2;
-                if (tagMatch)
-                    relevance += 1;
-                results.push({
-                    id: metadata.id,
-                    title: metadata.title,
-                    description: metadata.description,
-                    date: metadata.date,
-                    memoryType: metadata.memory_type,
-                    agentId: metadata.agent_id,
-                    importance: metadata.importance,
-                    tags: tags,
-                    filePath: relative(directory, filePath),
-                    relevance,
-                });
-            }
-            catch {
-                // Skip files that can't be parsed
-                continue;
-            }
-        }
-        // Sort by relevance and importance
-        results.sort((a, b) => {
-            const scoreA = a.relevance * a.importance;
-            const scoreB = b.relevance * b.importance;
-            return scoreB - scoreA;
-        });
-        // Limit results
-        const limit = criteria.limit || 10;
-        return results.slice(0, limit).map((r) => ({
-            id: r.id,
-            title: r.title,
-            description: r.description,
-            date: r.date,
-            memoryType: r.memoryType,
-            agentId: r.agentId,
-            importance: r.importance,
-            tags: r.tags,
-            filePath: r.filePath,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-async function findAllMemoryFiles(dir) {
-    const files = [];
-    try {
-        const entries = await readdir(dir, { withFileTypes: true, recursive: true });
-        for (const entry of entries) {
-            if (entry.isFile() && entry.name.endsWith('.md')) {
-                files.push(join(dir, entry.parentPath || '', entry.name));
-            }
-        }
-    }
-    catch {
-        // Directory might not exist
-    }
-    return files;
-}
-function parseFrontmatter(content) {
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!match)
-        return null;
-    const frontmatter = match[1];
-    const result = {};
-    // Simple YAML parsing for our specific format
-    const lines = frontmatter.split('\n');
-    let currentKey = null;
-    let currentArray = [];
-    let currentObject = {};
-    let objectKey = null;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Check for array item
-        if (trimmed.startsWith('- ')) {
-            const value = trimmed.substring(2).replace(/^['"]|['"]$/g, '');
-            if (currentKey) {
-                currentArray.push(value);
-            }
-            continue;
-        }
-        // Check for nested object property
-        if (trimmed.match(/^\w+:\s*/)) {
-            const colonIndex = trimmed.indexOf(':');
-            const key = trimmed.substring(0, colonIndex).trim();
-            const value = trimmed
-                .substring(colonIndex + 1)
-                .trim()
-                .replace(/^['"]|['"]$/g, '');
-            // Check if this is a top-level key or nested
-            if (line.startsWith('  ') && objectKey) {
-                // Nested property
-                if (key === 'files' && value === '') {
-                    // Start of files array
-                    currentObject[key] = [];
-                }
-                else {
-                    currentObject[key] = value;
-                }
-            }
-            else {
-                // Top-level key
-                if (currentKey && currentArray.length > 0) {
-                    result[currentKey] = currentArray;
-                    currentArray = [];
-                }
-                if (objectKey && Object.keys(currentObject).length > 0) {
-                    result[objectKey] = currentObject;
-                    currentObject = {};
-                }
-                if (value === '') {
-                    // Could be start of array or object
-                    currentKey = key;
-                    currentArray = [];
-                    objectKey = key;
-                    currentObject = {};
-                }
-                else {
-                    // Simple value
-                    result[key] = value;
-                    currentKey = null;
-                    objectKey = null;
-                }
-            }
-            continue;
-        }
-        // Check for array item in nested context
-        if (trimmed.startsWith('- ') && objectKey) {
-            const value = trimmed.substring(2).replace(/^['"]|['"]$/g, '');
-            if (!currentObject.files) {
-                currentObject.files = [];
-            }
-            currentObject.files.push(value);
-        }
-    }
-    // Handle any remaining data
-    if (currentKey && currentArray.length > 0) {
-        result[currentKey] = currentArray;
-    }
-    if (objectKey && Object.keys(currentObject).length > 0) {
-        result[objectKey] = currentObject;
-    }
-    return result;
-}

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

@@ -1,20 +0,0 @@
-export interface MemoryInput {
-    title: string;
-    description: string;
-    memoryType: 'episodic' | 'semantic' | 'procedural';
-    tags: string[];
-    importance: number;
-    content?: string;
-    source?: 'conversation' | 'research' | 'implementation' | 'review';
-    relatedMemories?: string[];
-    context?: {
-        project?: string;
-        task?: string;
-        files?: string[];
-    };
-}
-export interface MemoryResult {
-    id: string;
-    filePath: string;
-}
-export declare function storeMemory(directory: string, memoryInput: MemoryInput): Promise<MemoryResult>;

package/dist/learning/memory-store.js

@@ -1,85 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { writeFile, mkdir } from 'fs/promises';
-import { dirname } from 'path';
-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 = `${directory}/${filePath}`;
-    // Generate frontmatter
-    const frontmatter = generateFrontmatter(id, date, memoryInput);
-    // Generate full content
-    const fullContent = `${frontmatter}\n\n${memoryInput.content || ''}`;
-    // Ensure directory exists
-    await mkdir(dirname(fullPath), { recursive: true });
-    // Write file
-    await writeFile(fullPath, fullContent, 'utf-8');
-    return {
-        id,
-        filePath,
-    };
-}
-function generateMemoryFilePath(memoryType, id, date) {
-    const dateObj = new Date(date);
-    const year = dateObj.getUTCFullYear();
-    const month = String(dateObj.getUTCMonth() + 1).padStart(2, '0');
-    const day = String(dateObj.getUTCDate()).padStart(2, '0');
-    const hours = String(dateObj.getUTCHours()).padStart(2, '0');
-    const minutes = String(dateObj.getUTCMinutes()).padStart(2, '0');
-    const seconds = String(dateObj.getUTCSeconds()).padStart(2, '0');
-    switch (memoryType) {
-        case 'episodic':
-            return `.feature-factory/memories/episodic/${year}/${month}/${day}/${year}-${month}-${day}-${hours}-${minutes}-${seconds}-episodic.md`;
-        case 'semantic':
-            return `.feature-factory/memories/semantic/${memoryType}-${id}.md`;
-        case 'procedural':
-            return `.feature-factory/memories/procedural/procedural-${id}.md`;
-        default:
-            return `.feature-factory/memories/semantic/semantic-${id}.md`;
-    }
-}
-function generateFrontmatter(id, date, input) {
-    const frontmatter = {
-        id,
-        title: input.title,
-        description: input.description,
-        date,
-        memory_type: input.memoryType,
-        agent_id: 'agent', // This would be populated from context
-        importance: input.importance,
-        tags: input.tags,
-    };
-    if (input.source) {
-        frontmatter.source = input.source;
-    }
-    if (input.relatedMemories && input.relatedMemories.length > 0) {
-        frontmatter.related_memories = input.relatedMemories;
-    }
-    if (input.context) {
-        frontmatter.context = input.context;
-    }
-    // Convert to YAML format
-    const yamlLines = Object.entries(frontmatter).map(([key, value]) => {
-        if (Array.isArray(value)) {
-            return `${key}:\n${value.map((v) => `  - '${v}'`).join('\n')}`;
-        }
-        else if (typeof value === 'object' && value !== null) {
-            return `${key}:\n${Object.entries(value)
-                .map(([k, v]) => {
-                if (Array.isArray(v)) {
-                    return `  ${k}:\n${v.map((item) => `    - '${item}'`).join('\n')}`;
-                }
-                return `  ${k}: '${v}'`;
-            })
-                .join('\n')}`;
-        }
-        else if (typeof value === 'number') {
-            return `${key}: ${value}`;
-        }
-        else {
-            return `${key}: '${value}'`;
-        }
-    });
-    return `---\n${yamlLines.join('\n')}\n---`;
-}

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

@@ -1,2 +0,0 @@
-import { tool } from '@opencode-ai/plugin/tool';
-export declare function createFFLearningGetTool(): ReturnType<typeof tool>;

package/dist/plugins/ff-learning-get-plugin.js

@@ -1,55 +0,0 @@
-import { tool } from '@opencode-ai/plugin/tool';
-import { getMemory } from '../learning/memory-get.js';
-export function createFFLearningGetTool() {
-    return tool({
-        description: 'Retrieve the full content of a specific memory by ID or file path',
-        args: {
-            memoryId: tool.schema.string().optional().describe('UUID of the memory to retrieve'),
-            filePath: tool.schema.string().optional().describe('Direct file path to the memory file'),
-        },
-        async execute(args, toolCtx) {
-            try {
-                if (!args.memoryId && !args.filePath) {
-                    return JSON.stringify({
-                        success: false,
-                        error: 'Either memoryId or filePath must be provided',
-                    }, null, 2);
-                }
-                const result = await getMemory(toolCtx.directory, {
-                    memoryId: args.memoryId,
-                    filePath: args.filePath,
-                });
-                if (!result) {
-                    return JSON.stringify({
-                        success: false,
-                        error: `Memory not found: ${args.memoryId || args.filePath}`,
-                    }, null, 2);
-                }
-                return JSON.stringify({
-                    success: true,
-                    memory: {
-                        id: result.id,
-                        title: result.title,
-                        description: result.description,
-                        date: result.date,
-                        memoryType: result.memoryType,
-                        agentId: result.agentId,
-                        importance: result.importance,
-                        tags: result.tags,
-                        source: result.source,
-                        relatedMemories: result.relatedMemories,
-                        context: result.context,
-                        content: result.content,
-                        filePath: result.filePath,
-                    },
-                }, null, 2);
-            }
-            catch (error) {
-                return JSON.stringify({
-                    success: false,
-                    error: `Failed to get memory: ${error}`,
-                }, null, 2);
-            }
-        },
-    });
-}

package/dist/plugins/ff-learning-search-plugin.d.ts

@@ -1,2 +0,0 @@
-import { tool } from '@opencode-ai/plugin/tool';
-export declare function createFFLearningSearchTool(): ReturnType<typeof tool>;

package/dist/plugins/ff-learning-search-plugin.js

@@ -1,65 +0,0 @@
-import { tool } from '@opencode-ai/plugin/tool';
-import { searchMemories } from '../learning/memory-search.js';
-export function createFFLearningSearchTool() {
-    return tool({
-        description: 'Search for memories by query, tags, type, or agent. Returns matching memory metadata sorted by relevance and importance',
-        args: {
-            query: tool.schema
-                .string()
-                .describe('Search query string to match against titles and descriptions'),
-            tags: tool.schema.array(tool.schema.string()).optional().describe('Filter by specific tags'),
-            memoryType: tool.schema
-                .enum(['episodic', 'semantic', 'procedural'])
-                .optional()
-                .describe('Filter by memory type'),
-            agentId: tool.schema.string().optional().describe('Filter by agent that created the memory'),
-            limit: tool.schema
-                .number()
-                .min(1)
-                .max(50)
-                .default(10)
-                .describe('Maximum number of results to return (default: 10)'),
-            minImportance: tool.schema
-                .number()
-                .min(0)
-                .max(1)
-                .optional()
-                .describe('Minimum importance threshold (0.0-1.0)'),
-        },
-        async execute(args, toolCtx) {
-            try {
-                const criteria = {
-                    query: args.query,
-                    tags: args.tags,
-                    memoryType: args.memoryType,
-                    agentId: args.agentId,
-                    limit: args.limit,
-                    minImportance: args.minImportance,
-                };
-                const results = await searchMemories(toolCtx.directory, criteria);
-                return JSON.stringify({
-                    success: true,
-                    count: results.length,
-                    query: args.query,
-                    memories: results.map((m) => ({
-                        id: m.id,
-                        title: m.title,
-                        description: m.description,
-                        memoryType: m.memoryType,
-                        agentId: m.agentId,
-                        importance: m.importance,
-                        tags: m.tags,
-                        date: m.date,
-                        filePath: m.filePath,
-                    })),
-                }, null, 2);
-            }
-            catch (error) {
-                return JSON.stringify({
-                    success: false,
-                    error: `Failed to search memories: ${error}`,
-                }, null, 2);
-            }
-        },
-    });
-}

package/dist/plugins/ff-learning-store-plugin.d.ts

@@ -1,2 +0,0 @@
-import { tool } from '@opencode-ai/plugin/tool';
-export declare function createFFLearningStoreTool(): ReturnType<typeof tool>;