mindforge-sdk 10.7.0

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * MindForge SDK — Public API
+ * @module @mindforge/sdk
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.MindForgeMemory = exports.commands = exports.MindForgeEventStream = exports.MindForgeClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "MindForgeClient", { enumerable: true, get: function () { return client_1.MindForgeClient; } });
+var events_1 = require("./events");
+Object.defineProperty(exports, "MindForgeEventStream", { enumerable: true, get: function () { return events_1.MindForgeEventStream; } });
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "commands", { enumerable: true, get: function () { return commands_1.commands; } });
+var memory_1 = require("./memory");
+Object.defineProperty(exports, "MindForgeMemory", { enumerable: true, get: function () { return memory_1.MindForgeMemory; } });
+exports.VERSION = '10.7.0';

package/dist/memory.d.ts

@@ -0,0 +1,183 @@
+/**
+ * MindForge v2.4.0 SDK — Memory API (RAG 2.0)
+ * Self-contained TypeScript interface to the MindForge Knowledge Graph.
+ *
+ * This module is fully standalone — it reads/writes JSONL files directly
+ * without depending on bin/ internal modules.
+ */
+export type KnowledgeType = 'architectural_decision' | 'code_pattern' | 'bug_pattern' | 'team_preference' | 'domain_knowledge';
+export interface KnowledgeEntry {
+    id: string;
+    timestamp: string;
+    type: KnowledgeType;
+    topic: string;
+    content: string;
+    source: string;
+    project: string;
+    confidence: number;
+    tags: string[];
+    linked_adrs: string[];
+    times_referenced: number;
+    last_referenced: string | null;
+    deprecated: boolean;
+    deprecated_by: string | null;
+    decision?: string;
+    rationale?: string;
+    root_cause?: string;
+    fix?: string;
+    preference?: string;
+    strength?: 'strong' | 'moderate' | 'weak';
+    bug_category?: string;
+    domain?: string;
+    tech_stack?: string[];
+    global?: boolean;
+    promoted_at?: string;
+}
+export interface QueryParams {
+    tags?: string[];
+    topic?: string;
+    type?: KnowledgeType;
+    minConfidence?: number;
+    limit?: number;
+    includeGlobal?: boolean;
+    includeDeprecated?: boolean;
+    project?: string;
+}
+export interface MemoryStats {
+    total_entries: number;
+    active_entries: number;
+    deprecated_entries: number;
+    by_type: Record<string, number>;
+    avg_confidence: number;
+}
+export interface SessionContext {
+    preferences: KnowledgeEntry[];
+    decisions: KnowledgeEntry[];
+    bugPatterns: KnowledgeEntry[];
+    codePatterns: KnowledgeEntry[];
+    domain: KnowledgeEntry[];
+    count: number;
+    formatted: string;
+}
+export type EdgeType = 'RELATED_TO' | 'CAUSED_BY' | 'SUPERSEDES' | 'DEPENDS_ON' | 'INFORMS' | 'CONTRADICTS';
+export interface GraphEdge {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    type: EdgeType;
+    weight: number;
+    reason: string;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    last_traversed: string | null;
+    traversal_count: number;
+    deprecated: boolean;
+    checksum: string;
+}
+export interface ShadowContext {
+    formatted: string;
+    items: ShadowItem[];
+    count: number;
+    budgetUsed: number;
+}
+export interface ShadowItem {
+    id: string;
+    type: KnowledgeType;
+    topic: string;
+    content: string;
+    confidence: number;
+    score: number;
+    source: string;
+    tags: string[];
+    edges?: string;
+}
+export interface GraphStats {
+    total_nodes: number;
+    total_edges: number;
+    edges_by_type: Record<string, number>;
+    orphan_nodes: number;
+    avg_weight: number;
+    connected_ratio: number;
+}
+export interface TraversalResult {
+    id: string;
+    depth: number;
+    path: string[];
+}
+/**
+ * MindForge Knowledge Graph client (RAG 2.0).
+ */
+export declare class MindForgeMemory {
+    private readonly projectRoot;
+    private readonly memoryDir;
+    private readonly kbPath;
+    private readonly globalPath;
+    private readonly edgesPath;
+    constructor(projectRoot?: string);
+    /** Add a new knowledge entry. */
+    remember(entry: Partial<KnowledgeEntry>): Promise<string>;
+    /** Query the knowledge base. */
+    query(params?: QueryParams): Promise<KnowledgeEntry[]>;
+    /** Reinforce an entry (increase confidence). */
+    reinforce(id: string): Promise<void>;
+    /** Deprecate an entry. */
+    deprecate(id: string, reason: string, supersededBy?: string): Promise<void>;
+    /** Get memory statistics. */
+    getStats(): Promise<MemoryStats>;
+    /** Load context for a session. */
+    loadContext(opts: {
+        techStack?: string[];
+        phase?: string;
+        topic?: string;
+    }): Promise<SessionContext>;
+    /** Add a typed edge between two knowledge nodes. */
+    addEdge(edge: {
+        sourceId: string;
+        targetId: string;
+        type: EdgeType;
+        weight?: number;
+        reason?: string;
+    }): Promise<string>;
+    /** Get all edges for a specific node. */
+    getEdges(nodeId: string, opts?: {
+        direction?: 'outgoing' | 'incoming' | 'both';
+        edgeTypes?: EdgeType[];
+    }): Promise<GraphEdge[]>;
+    /** BFS traversal from a starting node. */
+    traverse(startId: string, maxDepth?: number, opts?: {
+        edgeTypes?: EdgeType[];
+        minWeight?: number;
+    }): Promise<TraversalResult[]>;
+    /** Find related knowledge via keyword-based scoring + graph traversal. */
+    findRelated(queryText: string, opts?: {
+        maxHops?: number;
+        topK?: number;
+    }): Promise<Array<{
+        id: string;
+        score: number;
+        source: string;
+    }>>;
+    /** Generate auto-shadow context for a task. */
+    autoShadow(opts: {
+        taskDescription: string;
+        excludeIds?: string[];
+        techStack?: string[];
+    }): Promise<ShadowContext>;
+    /** Get graph statistics. */
+    getGraphStats(): Promise<GraphStats>;
+    /** Apply weight decay to stale edges. */
+    decayEdges(): Promise<{
+        decayed: number;
+        pruned: number;
+    }>;
+    /** Detect cycles in directed edge types. */
+    detectCycles(): Promise<string[][]>;
+    /** Verify SHA-256 integrity of all edges. */
+    verifyIntegrity(): Promise<{
+        valid: number;
+        corrupted: string[];
+    }>;
+    private readAllEntries;
+    private readAllEdges;
+    private formatSessionContext;
+}