decisionnode 0.2.0

package/dist/env.js

@@ -0,0 +1,139 @@
+// This file must be imported FIRST to ensure env is set up before any other modules
+import path from 'path';
+import fs from 'fs';
+import dotenv from 'dotenv';
+// NUCLEAR OPTION: Redirect console.log to console.error
+// MCP protocol uses stdout for communication. Any library logging to stdout
+// will break the protocol. Redirecting to stderr is safe.
+console.log = console.error;
+/**
+ * Get the global DecisionNode store location
+ * ~/.decisionnode/.decisions/
+ */
+function getGlobalStorePath() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    return path.join(homeDir, '.decisionnode', '.decisions');
+}
+// Current project name - can be overridden at runtime
+let currentProjectName = path.basename(process.cwd());
+/**
+ * Set the current project name (called by MCP tools)
+ */
+export function setCurrentProject(projectName) {
+    currentProjectName = projectName;
+}
+/**
+ * Get the current project name
+ */
+export function getCurrentProject() {
+    return currentProjectName;
+}
+/**
+ * Get the project-specific storage path
+ * ~/.decisionnode/.decisions/{projectname}/
+ * Does NOT create the folder - that's done when saving files
+ */
+export function getProjectPath(projectName) {
+    const name = projectName || currentProjectName;
+    return path.join(getGlobalStorePath(), name);
+}
+/**
+ * Ensure project folder exists (call before writing files)
+ */
+export function ensureProjectFolder(projectName) {
+    const projectPath = getProjectPath(projectName);
+    if (!fs.existsSync(projectPath)) {
+        fs.mkdirSync(projectPath, { recursive: true });
+    }
+}
+// Global store path (e.g., ~/.decisionnode/.decisions/)
+export const GLOBAL_STORE = getGlobalStorePath();
+// Reserved folder name for global decisions
+export const GLOBAL_PROJECT_NAME = '_global';
+/**
+ * Get the path to the global decisions folder
+ * ~/.decisionnode/.decisions/_global/
+ */
+export function getGlobalDecisionsPath() {
+    return path.join(getGlobalStorePath(), GLOBAL_PROJECT_NAME);
+}
+/**
+ * Ensure the global decisions folder exists
+ */
+export function ensureGlobalFolder() {
+    const globalPath = getGlobalDecisionsPath();
+    if (!fs.existsSync(globalPath)) {
+        fs.mkdirSync(globalPath, { recursive: true });
+    }
+}
+/**
+ * Check if a decision ID is a global decision (prefixed with "global:")
+ */
+export function isGlobalId(id) {
+    return id.startsWith('global:');
+}
+/**
+ * Strip the "global:" prefix from a decision ID
+ */
+export function stripGlobalPrefix(id) {
+    return id.replace(/^global:/, '');
+}
+// Also export a getter for dynamic access
+export function getProjectRoot() {
+    return getProjectPath(currentProjectName);
+}
+// Load .env file from home directory ONLY
+// This is the single source of truth for API keys
+const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+dotenv.config({
+    path: path.join(homeDir, '.decisionnode', '.env'),
+    quiet: true
+});
+const CONFIG_FILE_PATH = path.join(homeDir, '.decisionnode', 'config.json');
+const DEFAULT_CONFIG = {
+    searchSensitivity: 'high'
+};
+/**
+ * Load the global DecisionNode config
+ */
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE_PATH)) {
+            const content = fs.readFileSync(CONFIG_FILE_PATH, 'utf-8');
+            return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+        }
+    }
+    catch {
+        // Return default if file is corrupted
+    }
+    return DEFAULT_CONFIG;
+}
+/**
+ * Save the global DecisionNode config
+ */
+function saveConfig(config) {
+    try {
+        const dir = path.dirname(CONFIG_FILE_PATH);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(CONFIG_FILE_PATH, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    catch {
+        // Silently fail if we can't write config
+    }
+}
+/**
+ * Get the current search sensitivity level
+ */
+export function getSearchSensitivity() {
+    return loadConfig().searchSensitivity;
+}
+/**
+ * Set the search sensitivity level
+ */
+export function setSearchSensitivity(level) {
+    const config = loadConfig();
+    config.searchSensitivity = level;
+    saveConfig(config);
+}

package/dist/history.d.ts

@@ -0,0 +1,34 @@
+import { DecisionCollection, DecisionNode } from './types.js';
+export type ActionType = 'added' | 'updated' | 'deleted' | 'imported' | 'installed' | 'cloud_push' | 'cloud_pull' | 'conflict_resolved';
+export type SourceType = 'cli' | 'mcp' | 'cloud' | 'marketplace';
+export interface ActivityLogEntry {
+    id: string;
+    action: ActionType;
+    decisionId: string;
+    description: string;
+    timestamp: string;
+    source?: SourceType;
+    snapshot: Record<string, DecisionCollection>;
+}
+/**
+ * Log an action to the activity log
+ * This captures the current state as a snapshot
+ */
+export declare function logAction(action: ActionType, decisionId: string, description?: string, source?: SourceType): Promise<void>;
+/**
+ * Log a batch action (for multiple decisions at once, like cloud sync)
+ * Uses a single entry with a summarized description
+ */
+export declare function logBatchAction(action: ActionType, decisionIds: string[], source?: SourceType): Promise<void>;
+/**
+ * Get recent activity log entries
+ */
+export declare function getHistory(limit?: number): Promise<ActivityLogEntry[]>;
+/**
+ * Get a specific snapshot by entry ID
+ */
+export declare function getSnapshot(entryId: string): Promise<ActivityLogEntry | null>;
+/**
+ * Get all decisions from a snapshot
+ */
+export declare function getDecisionsFromSnapshot(snapshot: Record<string, DecisionCollection>): DecisionNode[];

package/dist/history.js

@@ -0,0 +1,159 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { loadDecisions } from './store.js';
+import { getProjectRoot, ensureProjectFolder } from './env.js';
+const HISTORY_DIR = 'history';
+const LOG_FILE = path.join(HISTORY_DIR, 'activity.json');
+/**
+ * Generate a short hash for entry ID
+ */
+function generateEntryId() {
+    return crypto.randomBytes(4).toString('hex');
+}
+/**
+ * Get the log file path
+ */
+function getLogPath() {
+    return path.join(getProjectRoot(), LOG_FILE);
+}
+/**
+ * Ensure history directory exists
+ */
+async function ensureHistoryDir() {
+    await fs.mkdir(path.join(getProjectRoot(), HISTORY_DIR), { recursive: true });
+}
+/**
+ * Load the activity log
+ */
+async function loadActivityLog() {
+    try {
+        const content = await fs.readFile(getLogPath(), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { entries: [] };
+    }
+}
+/**
+ * Save the activity log
+ */
+async function saveActivityLog(log) {
+    ensureProjectFolder();
+    await ensureHistoryDir();
+    await fs.writeFile(getLogPath(), JSON.stringify(log, null, 2), 'utf-8');
+}
+/**
+ * Get all available scopes by scanning the .decisions directory
+ */
+async function getAvailableScopes() {
+    try {
+        const files = await fs.readdir(getProjectRoot());
+        return files
+            .filter(f => f.endsWith('.json') && f !== 'vectors.json')
+            .map(f => f.replace('.json', ''))
+            .map(s => s.charAt(0).toUpperCase() + s.slice(1));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Take a snapshot of current decisions
+ */
+async function takeSnapshot() {
+    const scopes = await getAvailableScopes();
+    const snapshot = {};
+    for (const scope of scopes) {
+        const collection = await loadDecisions(scope);
+        snapshot[scope.toLowerCase()] = collection;
+    }
+    return snapshot;
+}
+/**
+ * Log an action to the activity log
+ * This captures the current state as a snapshot
+ */
+export async function logAction(action, decisionId, description, source) {
+    const log = await loadActivityLog();
+    const snapshot = await takeSnapshot();
+    const entry = {
+        id: generateEntryId(),
+        action,
+        decisionId,
+        description: description || `${action} ${decisionId}`,
+        timestamp: new Date().toISOString(),
+        source: source || 'cli',
+        snapshot
+    };
+    // Add to beginning (newest first)
+    log.entries.unshift(entry);
+    // Keep last 100 entries to prevent unbounded growth
+    if (log.entries.length > 100) {
+        log.entries = log.entries.slice(0, 100);
+    }
+    await saveActivityLog(log);
+}
+/**
+ * Log a batch action (for multiple decisions at once, like cloud sync)
+ * Uses a single entry with a summarized description
+ */
+export async function logBatchAction(action, decisionIds, source = 'cloud') {
+    if (decisionIds.length === 0)
+        return;
+    const log = await loadActivityLog();
+    const snapshot = await takeSnapshot();
+    // Create summarized description
+    let description;
+    const actionVerb = action === 'cloud_push' ? 'Pushed' : action === 'cloud_pull' ? 'Pulled' : action;
+    if (decisionIds.length === 1) {
+        description = `${actionVerb} ${decisionIds[0]}`;
+    }
+    else if (decisionIds.length <= 3) {
+        description = `${actionVerb} ${decisionIds.length} decisions (${decisionIds.join(', ')})`;
+    }
+    else {
+        const shown = decisionIds.slice(0, 3).join(', ');
+        description = `${actionVerb} ${decisionIds.length} decisions (${shown}... +${decisionIds.length - 3} more)`;
+    }
+    const entry = {
+        id: generateEntryId(),
+        action,
+        decisionId: decisionIds.join(','), // Store all IDs
+        description,
+        timestamp: new Date().toISOString(),
+        source,
+        snapshot
+    };
+    log.entries.unshift(entry);
+    if (log.entries.length > 100) {
+        log.entries = log.entries.slice(0, 100);
+    }
+    await saveActivityLog(log);
+}
+/**
+ * Get recent activity log entries
+ */
+export async function getHistory(limit = 20) {
+    const log = await loadActivityLog();
+    return log.entries.slice(0, limit);
+}
+/**
+ * Get a specific snapshot by entry ID
+ */
+export async function getSnapshot(entryId) {
+    const log = await loadActivityLog();
+    return log.entries.find(e => e.id === entryId) || null;
+}
+/**
+ * Get all decisions from a snapshot
+ */
+export function getDecisionsFromSnapshot(snapshot) {
+    const decisions = [];
+    for (const scope of Object.keys(snapshot)) {
+        if (snapshot[scope].decisions && Array.isArray(snapshot[scope].decisions)) {
+            decisions.push(...snapshot[scope].decisions);
+        }
+    }
+    return decisions;
+}

package/dist/maintenance.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Clean orphaned data (vectors and reviews) for decisions that no longer exist
+ */
+export declare function cleanOrphanedData(): Promise<{
+    vectorsRemoved: number;
+    reviewsRemoved: number;
+}>;

package/dist/maintenance.js

@@ -0,0 +1,49 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getProjectRoot } from './env.js';
+import { listDecisions } from './store.js';
+import { loadVectorCache, saveVectorCache } from './ai/rag.js';
+const REVIEWED_FILE = () => path.join(getProjectRoot(), 'reviewed.json');
+async function loadReviewed() {
+    try {
+        const content = await fs.readFile(REVIEWED_FILE(), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { reviewed: [] };
+    }
+}
+async function saveReviewed(data) {
+    await fs.writeFile(REVIEWED_FILE(), JSON.stringify(data, null, 2), 'utf-8');
+}
+/**
+ * Clean orphaned data (vectors and reviews) for decisions that no longer exist
+ */
+export async function cleanOrphanedData() {
+    const decisions = await listDecisions();
+    const validIds = new Set(decisions.map(d => d.id));
+    // Clean Vectors
+    const cache = await loadVectorCache();
+    let vectorsRemoved = 0;
+    for (const id of Object.keys(cache)) {
+        if (!validIds.has(id)) {
+            delete cache[id];
+            vectorsRemoved++;
+        }
+    }
+    if (vectorsRemoved > 0) {
+        await saveVectorCache(cache);
+    }
+    // Clean Reviews
+    const reviewData = await loadReviewed();
+    // Use optional chaining just in case
+    const currentReviews = reviewData.reviewed || [];
+    const originalCount = currentReviews.length;
+    const cleanReviews = currentReviews.filter(id => validIds.has(id));
+    const reviewsRemoved = originalCount - cleanReviews.length;
+    if (reviewsRemoved > 0) {
+        reviewData.reviewed = cleanReviews;
+        await saveReviewed(reviewData);
+    }
+    return { vectorsRemoved, reviewsRemoved };
+}

package/dist/marketplace.d.ts

@@ -0,0 +1,46 @@
+/**
+ * DecisionNode Marketplace
+ *
+ * Download and install curated decision packs. Embeddings are generated locally.
+ */
+import { DecisionNode } from './types.js';
+/**
+ * A Decision Pack is a pre-made collection of decisions with vectors
+ */
+export interface DecisionPack {
+    id: string;
+    name: string;
+    description: string;
+    author: string;
+    version: string;
+    scope: string;
+    decisions: DecisionNode[];
+    vectors: Record<string, number[]>;
+}
+/**
+ * Marketplace index entry (lightweight metadata)
+ */
+export interface MarketplaceEntry {
+    id: string;
+    name: string;
+    description: string;
+    author: string;
+    scope: string;
+    decisionCount: number;
+    downloads: number;
+}
+/**
+ * Fetch the marketplace index from Supabase
+ */
+export declare function getMarketplaceIndex(): Promise<MarketplaceEntry[]>;
+/**
+ * Download and install a decision pack
+ */
+export declare function installPack(packId: string): Promise<{
+    installed: number;
+    skipped: number;
+}>;
+/**
+ * Search marketplace by query
+ */
+export declare function searchMarketplace(query: string): Promise<MarketplaceEntry[]>;