decisionnode 0.2.0

package/dist/setup.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+// Load environment variables first
+import './env.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Prompt user for input
+ */
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Get the MCP config file path
+ */
+function getMCPConfigPath() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    return path.join(homeDir, '.gemini', 'antigravity', 'mcp_config.json');
+}
+/**
+ * Read existing MCP config
+ */
+async function readMCPConfig(configPath) {
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        // File doesn't exist or is invalid, return empty config
+        return { mcpServers: {} };
+    }
+}
+/**
+ * Write MCP config
+ */
+async function writeMCPConfig(configPath, config) {
+    // Ensure directory exists
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+/**
+ * Try to read API key from environment (already loaded by env.ts)
+ */
+function getApiKeyFromEnv() {
+    return process.env.GEMINI_API_KEY || null;
+}
+/**
+ * Main setup flow
+ */
+export async function runSetup() {
+    console.log('🧠 DecisionNode MCP Setup\n');
+    // 1. Try to auto-detect API key from .env
+    let apiKey = getApiKeyFromEnv();
+    if (apiKey) {
+        console.log('✓ Found GEMINI_API_KEY in .env file\n');
+    }
+    else {
+        console.log('Step 1: Gemini API Key');
+        console.log('Get your free API key from: https://aistudio.google.com/api-keys\n');
+        apiKey = await prompt('Enter your GEMINI_API_KEY (or press Enter to skip): ');
+        if (!apiKey) {
+            console.log('\n⚠️  Skipping API key for now. You can add it later in the MCP config file.');
+        }
+    }
+    // 2. Get MCP config path
+    const configPath = getMCPConfigPath();
+    console.log(`\nStep 2: Updating MCP config at:\n${configPath}\n`);
+    // 3. Read existing config
+    let config;
+    try {
+        config = await readMCPConfig(configPath);
+        console.log('✓ Found existing MCP config');
+    }
+    catch (error) {
+        config = { mcpServers: {} };
+        console.log('✓ Creating new MCP config');
+    }
+    // 4. Add/update DecisionNode entry for THIS project
+    if (!config.mcpServers) {
+        config.mcpServers = {};
+    }
+    // Single entry - Antigravity sets cwd based on active workspace
+    config.mcpServers.decisionnode = {
+        command: 'npx',
+        args: ['decide-mcp'],
+        ...(apiKey ? { env: { GEMINI_API_KEY: apiKey } } : {})
+    };
+    // 5. Write config
+    try {
+        await writeMCPConfig(configPath, config);
+        console.log('✓ Updated MCP config\n');
+    }
+    catch (error) {
+        console.error('✗ Failed to write MCP config:', error);
+        process.exit(1);
+    }
+    // 6. Success message
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const globalStore = path.join(homeDir, '.decisionnode');
+    console.log('✅ DecisionNode MCP setup complete!\n');
+    console.log('📁 Global store: ' + globalStore);
+    console.log('   Each project gets its own isolated folder automatically.\n');
+    if (!apiKey) {
+        console.log('📝 To add your API key later, edit:');
+        console.log(`   ${configPath}\n`);
+        console.log('   Add this to the "decisionnode" entry:');
+        console.log('   "env": { "GEMINI_API_KEY": "your-key-here" }\n');
+    }
+    console.log('🚀 Next steps:');
+    console.log('   1. Restart Antigravity (or reload MCP servers)');
+    console.log('   2. Open any project - decisions are automatically isolated!');
+    console.log('   3. Try asking: "Add a decision about our architecture"\n');
+}
+// Run setup if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runSetup().catch((error) => {
+        console.error('Setup failed:', error);
+        process.exit(1);
+    });
+}

package/dist/store.d.ts

@@ -0,0 +1,126 @@
+import { DecisionNode, DecisionCollection } from './types.js';
+import { SourceType } from './history.js';
+/**
+ * Get all available scopes by scanning the .decisions directory
+ */
+export declare function getAvailableScopes(): Promise<string[]>;
+/**
+ * Get all available scopes in the global decisions folder
+ */
+export declare function getGlobalScopes(): Promise<string[]>;
+/**
+ * Load all decisions for a given scope from the global folder
+ */
+export declare function loadGlobalDecisions(scope: string): Promise<DecisionCollection>;
+/**
+ * Save decisions for a given scope in the global folder
+ */
+export declare function saveGlobalDecisions(collection: DecisionCollection): Promise<void>;
+/**
+ * List all global decisions, optionally filtered by scope
+ * Returns decisions with "global:" prefix on IDs
+ */
+export declare function listGlobalDecisions(scope?: string): Promise<DecisionNode[]>;
+/**
+ * Get a global decision by ID (with or without "global:" prefix)
+ */
+export declare function getGlobalDecisionById(id: string): Promise<DecisionNode | null>;
+/**
+ * Generate the next decision ID for a global scope
+ * Returns ID without the "global:" prefix (prefix is added on read)
+ */
+export declare function getNextGlobalDecisionId(scope: string): Promise<string>;
+/**
+ * Add a new global decision
+ */
+export declare function addGlobalDecision(decision: DecisionNode, source?: SourceType): Promise<{
+    embedded: boolean;
+}>;
+/**
+ * Update an existing global decision
+ */
+export declare function updateGlobalDecision(id: string, updates: Partial<DecisionNode>): Promise<DecisionNode | null>;
+/**
+ * Delete a global decision
+ */
+export declare function deleteGlobalDecision(id: string): Promise<boolean>;
+/**
+ * Normalize scope to consistent capitalized format
+ * e.g., 'ui', 'UI', 'Ui', 'uI' all become 'UI'
+ * e.g., 'backend', 'Backend', 'BACKEND' all become 'Backend'
+ */
+export declare function normalizeScope(scope: string): string;
+export interface ProjectInfo {
+    name: string;
+    decisionCount: number;
+    scopes: string[];
+    lastModified?: string;
+}
+/**
+ * List all available projects in the global store
+ * Returns project name, decision count, and available scopes
+ */
+export declare function listProjects(): Promise<ProjectInfo[]>;
+/**
+ * Load all decisions for a given scope
+ */
+export declare function loadDecisions(scope: string): Promise<DecisionCollection>;
+/**
+ * Save decisions for a given scope
+ */
+export declare function saveDecisions(collection: DecisionCollection): Promise<void>;
+/**
+ * Get a single decision by ID across all scopes
+ */
+export declare function getDecisionById(id: string): Promise<DecisionNode | null>;
+/**
+ * List all decisions, optionally filtered by scope
+ */
+export declare function listDecisions(scope?: string): Promise<DecisionNode[]>;
+/**
+ * Add a new decision
+ * Auto-embeds and logs the action
+ * @param decision - The decision to add
+ * @param source - Where this action originated (default: 'cli')
+ */
+export declare function addDecision(decision: DecisionNode, source?: SourceType): Promise<{
+    embedded: boolean;
+}>;
+/**
+ * Update an existing decision
+ * Auto-embeds and logs the action
+ */
+export declare function updateDecision(id: string, updates: Partial<DecisionNode>): Promise<DecisionNode | null>;
+/**
+ * Delete a decision by ID
+ * Clears embedding and logs the action
+ */
+export declare function deleteDecision(id: string): Promise<boolean>;
+/**
+ * Delete an entire scope (all decisions within it)
+ * Deletes the scope file, embeddings, and optionally from cloud
+ */
+export declare function deleteScope(scope: string): Promise<{
+    deleted: number;
+    decisionIds: string[];
+}>;
+/**
+ * Generate the next decision ID for a scope
+ */
+export declare function getNextDecisionId(scope: string): Promise<string>;
+/**
+ * Renumber decisions in a scope after deletion
+ * Also updates embeddings for renamed IDs
+ */
+export declare function renumberDecisions(scope: string): Promise<string[]>;
+/**
+ * Import decisions from a JSON file or object
+ * Auto-embeds all imported decisions
+ */
+export declare function importDecisions(decisions: DecisionNode[], options?: {
+    overwrite?: boolean;
+}): Promise<{
+    added: number;
+    skipped: number;
+    embedded: number;
+}>;