@syntesseraai/opencode-feature-factory 0.4.3 → 0.4.4

package/dist/local-recall/thinking-extractor.js

@@ -1,132 +0,0 @@
-/**
- * thinking-extractor.ts — Extracts learnings from "thinking" / reasoning blocks.
- *
- * OpenCode stores extended-thinking or chain-of-thought content in parts
- * with type "reasoning" or "thinking". These often contain high-signal insights about
- * decision making and problem solving that are worth capturing.
- */
-import { listParts } from './storage-reader.js';
-const THINKING_SIGNALS = [
-    {
-        category: 'decision',
-        weight: 0.9,
-        patterns: [
-            /\blet me think about\b/i,
-            /\bthe (better|right|correct) approach\b/i,
-            /\bI('ll| will) go with\b/i,
-            /\bweighing (the )?(options|trade-?offs)\b/i,
-            /\boption [A-D1-4] (is|seems|looks)\b/i,
-            /\bpros and cons\b/i,
-        ],
-    },
-    {
-        category: 'debugging',
-        weight: 0.85,
-        patterns: [
-            /\bthe (issue|problem|bug) (is|was|seems)\b/i,
-            /\broot cause\b/i,
-            /\bthis (fails|breaks|errors) because\b/i,
-            /\bI (notice|see|found) (that |the )?(error|issue|bug)\b/i,
-            /\bstack trace (shows|indicates|reveals)\b/i,
-        ],
-    },
-    {
-        category: 'pattern',
-        weight: 0.8,
-        patterns: [
-            /\bthe (standard|common|typical) (pattern|approach|way)\b/i,
-            /\bbest practice\b/i,
-            /\bfollow(ing)? the (same |existing )?(pattern|convention)\b/i,
-            /\bthis is (a |the )?(standard|idiomatic)\b/i,
-        ],
-    },
-    {
-        category: 'context',
-        weight: 0.7,
-        patterns: [
-            /\blooking at the (code|codebase|architecture|structure)\b/i,
-            /\bthe (project|repo|codebase) (uses|follows|has)\b/i,
-            /\bbased on (the |my )?understanding\b/i,
-            /\bthe (current|existing) (setup|config|architecture)\b/i,
-        ],
-    },
-    {
-        category: 'procedure',
-        weight: 0.75,
-        patterns: [
-            /\bfirst[\s\S]+then[\s\S]+finally\b/i,
-            /\bstep \d/i,
-            /\bthe (process|procedure|workflow) (is|involves)\b/i,
-            /\bI need to:?\s*\n/i,
-        ],
-    },
-];
-// ────────────────────────────────────────────────────────────
-// Analysis
-// ────────────────────────────────────────────────────────────
-const MIN_THINKING_LENGTH = 120;
-const MIN_THINKING_CONFIDENCE = 0.2;
-function classifyThinking(text) {
-    let best = null;
-    for (const signal of THINKING_SIGNALS) {
-        let hits = 0;
-        for (const pat of signal.patterns) {
-            if (pat.test(text))
-                hits++;
-        }
-        if (hits === 0)
-            continue;
-        const confidence = Math.min(1, (hits / signal.patterns.length) * signal.weight);
-        if (!best || confidence > best.confidence) {
-            best = { category: signal.category, confidence };
-        }
-    }
-    return best;
-}
-function deriveThinkingTitle(text) {
-    // Attempt to find a summary-like sentence
-    const sentences = text.split(/[.!?]\s+/).filter((s) => s.trim().length > 15);
-    const summary = sentences.find((s) => /\b(so|therefore|conclusion|result|decided|approach)\b/i.test(s)) ??
-        sentences[0];
-    if (!summary)
-        return 'Thinking insight';
-    const clean = summary.replace(/^[\s*#-]+/, '').trim();
-    return clean.length > 120 ? clean.slice(0, 117) + '...' : clean;
-}
-// ────────────────────────────────────────────────────────────
-// Public API
-// ────────────────────────────────────────────────────────────
-/**
- * Extract learnings specifically from reasoning/thinking parts.
- */
-export function extractFromThinkingParts(input, parts) {
-    const results = [];
-    for (const part of parts) {
-        // Accept reasoning/thinking type parts (extended thinking)
-        if ((part.type !== 'reasoning' && part.type !== 'thinking') || !part.text)
-            continue;
-        if (part.text.length < MIN_THINKING_LENGTH)
-            continue;
-        const classification = classifyThinking(part.text);
-        if (!classification || classification.confidence < MIN_THINKING_CONFIDENCE)
-            continue;
-        results.push({
-            sessionID: input.sessionID,
-            messageID: input.messageID,
-            category: classification.category,
-            title: deriveThinkingTitle(part.text),
-            body: part.text,
-            tags: ['thinking', 'reasoning'],
-            importance: Math.min(1, classification.confidence * 1.1), // slight boost for thinking
-            source: 'thinking',
-        });
-    }
-    return results;
-}
-/**
- * High-level: extract thinking-based learnings from a message.
- */
-export async function extractThinkingFromMessage(input) {
-    const parts = await listParts(input.messageID);
-    return extractFromThinkingParts(input, parts);
-}

package/dist/local-recall/types.d.ts

@@ -1,152 +0,0 @@
-/**
- * Local-Recall MCP-Only Memory Types
- *
- * Defines the domain types for reading OpenCode's native storage
- * and exposing memory retrieval via MCP tools.
- */
-/** Raw project record from ~/.local/share/opencode/storage/project/*.json */
-export interface OCProject {
-    id: string;
-    worktree: string;
-    vcs: string;
-    sandboxes: unknown[];
-    time: {
-        created: number;
-        updated: number;
-    };
-}
-/** Raw session record from ~/.local/share/opencode/storage/session/<projectHash>/ses_*.json */
-export interface OCSession {
-    id: string;
-    slug: string;
-    version: string;
-    projectID: string;
-    directory: string;
-    title: string;
-    time: {
-        created: number;
-        updated: number;
-    };
-}
-/** Raw message record from ~/.local/share/opencode/storage/message/<sessionID>/msg_*.json */
-export interface OCMessage {
-    id: string;
-    sessionID: string;
-    role: 'user' | 'assistant' | 'thinking';
-    time: {
-        created: number;
-    };
-    summary: {
-        title: string;
-        diffs: unknown[];
-    };
-    agent: string;
-    model: {
-        providerID: string;
-        modelID: string;
-    };
-    variant: string;
-}
-/** Raw part record from ~/.local/share/opencode/storage/part/<messageID>/prt_*.json */
-export interface OCPart {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    type: string;
-    text?: string;
-    synthetic?: boolean;
-    time?: {
-        start?: number;
-        end?: number;
-    };
-}
-/** A memory extracted from a conversation turn */
-export interface Memory {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    /** Describes the kind of insight */
-    category: MemoryCategory;
-    /** Short human-readable summary */
-    title: string;
-    /** Full text of the extracted memory */
-    body: string;
-    /** Searchable tags */
-    tags: string[];
-    /** 0-1 relevance weight */
-    importance: number;
-    /** Epoch ms extraction timestamp */
-    createdAt: number;
-    /** Which model was used for extraction */
-    extractedBy: string;
-}
-export type MemoryCategory = 'pattern' | 'decision' | 'debugging' | 'preference' | 'context' | 'procedure';
-/** Criteria for searching memories */
-export interface SearchCriteria {
-    query: string;
-    category?: MemoryCategory;
-    tags?: string[];
-    sessionID?: string;
-    minImportance?: number;
-    limit?: number;
-}
-/** Result metadata returned from search (excludes full body for brevity) */
-export interface MemorySearchResult {
-    id: string;
-    sessionID: string;
-    category: MemoryCategory;
-    title: string;
-    tags: string[];
-    importance: number;
-    createdAt: number;
-    /** Relevance score from search ranking */
-    relevance: number;
-}
-/** Identifies a message to extract from */
-export interface ExtractionInput {
-    sessionID: string;
-    messageID: string;
-}
-/** A single extracted learning before it becomes a full Memory */
-export interface ExtractionResult {
-    sessionID: string;
-    messageID: string;
-    category: MemoryCategory;
-    title: string;
-    body: string;
-    tags: string[];
-    importance: number;
-    /** Where the extraction came from — used to generate logical IDs */
-    source: 'session' | 'thinking';
-}
-interface ProcessedMessageEntryBase {
-    messageID: string;
-    processedAt: number;
-    /** SHA-256 hex hash of the concatenated extracted bodies for content-level idempotency */
-    contentHash: string;
-}
-/** Tracks which messages have already been processed */
-export type ProcessedMessageEntry = (ProcessedMessageEntryBase & {
-    status: 'success';
-    memoriesCreated: number;
-    failure?: undefined;
-}) | (ProcessedMessageEntryBase & {
-    status: 'failed';
-    memoriesCreated: 0;
-    failure: string;
-}) | (ProcessedMessageEntryBase & {
-    status?: undefined;
-    memoriesCreated: number;
-    failure?: undefined;
-});
-/** Persistent daemon-level failures that are not tied to a specific message record. */
-export type ProcessedFailureEntry = {
-    kind: 'failure';
-    scope: 'project' | 'session' | 'extraction';
-    processedAt: number;
-    failure: string;
-    directory?: string;
-    sessionID?: string;
-};
-export type ProcessedEntry = ProcessedMessageEntry | ProcessedFailureEntry;
-export {};

package/dist/local-recall/types.js

@@ -1,7 +0,0 @@
-/**
- * Local-Recall MCP-Only Memory Types
- *
- * Defines the domain types for reading OpenCode's native storage
- * and exposing memory retrieval via MCP tools.
- */
-export {};

package/dist/local-recall/vector/embedding-provider.d.ts

@@ -1,37 +0,0 @@
-import type { EmbeddingProvider, EmbeddingProviderName } from './types.js';
-interface EmbeddingProviderEnv extends NodeJS.ProcessEnv {
-    FF_LOCAL_RECALL_EMBEDDING_PROVIDER?: string;
-    FF_LOCAL_RECALL_OLLAMA_URL?: string;
-    FF_LOCAL_RECALL_OLLAMA_MODEL?: string;
-    FF_LOCAL_RECALL_OPENAI_URL?: string;
-    FF_LOCAL_RECALL_OPENAI_MODEL?: string;
-    OPENAI_API_KEY?: string;
-}
-export declare class OllamaEmbeddingProvider implements EmbeddingProvider {
-    readonly name: EmbeddingProviderName;
-    readonly model: string;
-    readonly baseURL: string;
-    dimensions?: number;
-    constructor(options?: {
-        model?: string;
-        baseURL?: string;
-    });
-    embed(input: string[]): Promise<number[][]>;
-    private embedBatch;
-    private embedLegacy;
-}
-export declare class OpenAIEmbeddingProvider implements EmbeddingProvider {
-    readonly name: EmbeddingProviderName;
-    readonly model: string;
-    readonly baseURL: string;
-    readonly apiKey: string;
-    dimensions?: number;
-    constructor(options: {
-        apiKey: string;
-        model?: string;
-        baseURL?: string;
-    });
-    embed(input: string[]): Promise<number[][]>;
-}
-export declare function createEmbeddingProvider(env?: EmbeddingProviderEnv): EmbeddingProvider;
-export {};

package/dist/local-recall/vector/embedding-provider.js

@@ -1,184 +0,0 @@
-const DEFAULT_OLLAMA_URL = 'http://127.0.0.1:11434';
-const DEFAULT_OLLAMA_MODEL = 'nomic-embed-text';
-const DEFAULT_OPENAI_URL = 'https://api.openai.com/v1';
-const DEFAULT_OPENAI_MODEL = 'text-embedding-3-small';
-function normalizeBaseURL(url) {
-    return url.endsWith('/') ? url.slice(0, -1) : url;
-}
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function assertEmbeddingShape(vectors) {
-    if (!Array.isArray(vectors)) {
-        throw new Error('Embedding response was not an array');
-    }
-    for (const vector of vectors) {
-        if (!Array.isArray(vector) || !vector.every((value) => typeof value === 'number')) {
-            throw new Error('Embedding response contained invalid vectors');
-        }
-    }
-    return vectors;
-}
-function validateDimensions(vectors, currentDimensions) {
-    const first = vectors[0];
-    if (!first) {
-        throw new Error('Embedding provider returned no vectors');
-    }
-    const nextDimensions = first.length;
-    if (nextDimensions === 0) {
-        throw new Error('Embedding provider returned empty vectors');
-    }
-    for (const vector of vectors) {
-        if (vector.length !== nextDimensions) {
-            throw new Error('Embedding provider returned mixed vector dimensions');
-        }
-    }
-    if (currentDimensions && currentDimensions !== nextDimensions) {
-        throw new Error(`Embedding dimensions changed from ${currentDimensions} to ${nextDimensions}`);
-    }
-    return nextDimensions;
-}
-async function parseError(response) {
-    try {
-        const text = await response.text();
-        if (!text) {
-            return `${response.status} ${response.statusText}`;
-        }
-        return `${response.status} ${response.statusText}: ${text}`;
-    }
-    catch {
-        return `${response.status} ${response.statusText}`;
-    }
-}
-export class OllamaEmbeddingProvider {
-    name = 'ollama';
-    model;
-    baseURL;
-    dimensions;
-    constructor(options) {
-        this.model = options?.model ?? DEFAULT_OLLAMA_MODEL;
-        this.baseURL = normalizeBaseURL(options?.baseURL ?? DEFAULT_OLLAMA_URL);
-    }
-    async embed(input) {
-        if (input.length === 0) {
-            return [];
-        }
-        let vectors = null;
-        let primaryError = null;
-        try {
-            vectors = await this.embedBatch(input);
-        }
-        catch (error) {
-            primaryError = toErrorMessage(error);
-        }
-        if (!vectors) {
-            try {
-                const legacyVectors = await Promise.all(input.map((value) => this.embedLegacy(value)));
-                vectors = legacyVectors;
-            }
-            catch (error) {
-                const fallbackError = toErrorMessage(error);
-                throw new Error(`Failed to fetch embeddings from Ollama. batch=${primaryError ?? 'n/a'} fallback=${fallbackError}`);
-            }
-        }
-        const dimensions = validateDimensions(vectors, this.dimensions);
-        this.dimensions = dimensions;
-        return vectors;
-    }
-    async embedBatch(input) {
-        const response = await fetch(`${this.baseURL}/api/embed`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: this.model,
-                input,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(await parseError(response));
-        }
-        const payload = (await response.json());
-        return assertEmbeddingShape(payload.embeddings);
-    }
-    async embedLegacy(input) {
-        const response = await fetch(`${this.baseURL}/api/embeddings`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: this.model,
-                prompt: input,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(await parseError(response));
-        }
-        const payload = (await response.json());
-        const [embedding] = assertEmbeddingShape([payload.embedding]);
-        return embedding;
-    }
-}
-export class OpenAIEmbeddingProvider {
-    name = 'openai';
-    model;
-    baseURL;
-    apiKey;
-    dimensions;
-    constructor(options) {
-        this.apiKey = options.apiKey;
-        this.model = options.model ?? DEFAULT_OPENAI_MODEL;
-        this.baseURL = normalizeBaseURL(options.baseURL ?? DEFAULT_OPENAI_URL);
-    }
-    async embed(input) {
-        if (input.length === 0) {
-            return [];
-        }
-        const response = await fetch(`${this.baseURL}/embeddings`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.apiKey}`,
-            },
-            body: JSON.stringify({
-                model: this.model,
-                input,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(await parseError(response));
-        }
-        const payload = (await response.json());
-        const embeddings = assertEmbeddingShape(payload.data?.map((entry) => entry.embedding) ?? []);
-        const dimensions = validateDimensions(embeddings, this.dimensions);
-        this.dimensions = dimensions;
-        return embeddings;
-    }
-}
-function getRequestedProvider(env) {
-    const value = (env.FF_LOCAL_RECALL_EMBEDDING_PROVIDER ?? 'ollama').trim().toLowerCase();
-    if (value === 'openai') {
-        return 'openai';
-    }
-    return 'ollama';
-}
-export function createEmbeddingProvider(env = process.env) {
-    const provider = getRequestedProvider(env);
-    if (provider === 'openai') {
-        const apiKey = env.OPENAI_API_KEY;
-        if (!apiKey) {
-            throw new Error('OPENAI_API_KEY is required when FF_LOCAL_RECALL_EMBEDDING_PROVIDER=openai');
-        }
-        return new OpenAIEmbeddingProvider({
-            apiKey,
-            model: env.FF_LOCAL_RECALL_OPENAI_MODEL,
-            baseURL: env.FF_LOCAL_RECALL_OPENAI_URL,
-        });
-    }
-    return new OllamaEmbeddingProvider({
-        model: env.FF_LOCAL_RECALL_OLLAMA_MODEL,
-        baseURL: env.FF_LOCAL_RECALL_OLLAMA_URL,
-    });
-}

package/dist/local-recall/vector/orama-index.d.ts

@@ -1,39 +0,0 @@
-import type { Memory, MemorySearchResult, SearchCriteria } from '../types.js';
-import type { EmbeddingProvider } from './types.js';
-export declare class OramaMemoryIndex {
-    private readonly directory;
-    private readonly provider;
-    private db;
-    private readonly documents;
-    private readonly embedMaxChars;
-    private dimensions;
-    private updatedAt;
-    constructor(directory: string, provider: EmbeddingProvider);
-    initialize(): Promise<void>;
-    getStatus(): {
-        documents: number;
-        dimensions: number | null;
-        provider: string;
-        model: string;
-        updatedAt: string | null;
-    };
-    search(criteria: SearchCriteria): Promise<MemorySearchResult[]>;
-    upsertMemories(memories: Memory[]): Promise<number>;
-    removeMemories(memoryIDs: string[]): Promise<number>;
-    rebuild(memories: Memory[]): Promise<number>;
-    private get indexDir();
-    private get manifestPath();
-    private get documentsPath();
-    private buildSchema;
-    private ensureDB;
-    private rebuildDatabaseFromDocuments;
-    private hydrateDB;
-    private loadSnapshot;
-    private persistSnapshot;
-    private writeAtomic;
-    private memoryToEmbeddingInput;
-    private prepareEmbeddingInput;
-    private toDocument;
-    private assertEmbeddingDimensions;
-    private embedBatch;
-}