@aabadin/project-memory-context 0.1.2 → 0.1.4

package/cli/setup.mjs

@@ -12,13 +12,22 @@ import { installAgentTemplates } from '../src/template-installer.mjs';
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 
+const AGENT_FLAGS = {
+  '--opencode': 'opencode',
+  '--claude': 'claude-code',
+  '--cursor': 'cursor',
+  '--generic': 'generic',
+};
+
 function installGraphify() {
   const candidates = process.platform === 'win32' ? ['python', 'py'] : ['python3', 'python'];
   for (const command of candidates) {
     const result = spawnSync(command, ['-m', 'pip', 'install', 'graphifyy'], { stdio: 'inherit' });
     if (result.status === 0) return command;
   }
-  console.warn('\n⚠  Could not install graphifyy automatically. Run: pip install graphifyy\n');
+  console.warn(`\n⚠  Could not install graphifyy automatically.`);
+  console.warn(`   Python not found? Download it from: https://www.python.org/downloads/`);
+  console.warn(`   Then run: pip install graphifyy\n`);
   return null;
 }
 
@@ -28,13 +37,13 @@ function spawnCheck(bin, args) {
 }
 
 function parseArgs(args) {
-  const parsed = { agent: null };
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--agent' && args[i + 1]) {
-      parsed.agent = args[++i];
+  const agents = [];
+  for (const arg of args) {
+    if (AGENT_FLAGS[arg]) {
+      agents.push(AGENT_FLAGS[arg]);
     }
   }
-  return parsed;
+  return { agents };
 }
 
 const rl = createInterface({ input, output });
@@ -42,7 +51,17 @@ const cwd = resolve(process.cwd());
 
 try {
   console.log('\n─── pmc setup ───────────────────────────────────────\n');
-  const { agent: requestedAgent } = parseArgs(process.argv.slice(2));
+  const { agents: requestedAgents } = parseArgs(process.argv.slice(2));
+
+  let agents;
+  if (requestedAgents.length > 0) {
+    agents = [...new Set(requestedAgents)];
+    console.log(`  Target agents: ${agents.join(', ')}`);
+  } else {
+    const detected = detectSetupAgentType(cwd);
+    agents = [detected];
+    console.log(`  Auto-detected agent: ${detected}`);
+  }
 
   const ollamaBaseUrl =
     (await rl.question('Ollama base URL [http://localhost:11434]: ')).trim() ||
@@ -54,31 +73,33 @@ try {
 
   installGraphify();
 
+  const { globalConfig } = resolveConfigDirs(cwd);
+
   const result = await bootstrapProjectInstall({
     projectRoot: cwd,
     packageRoot,
     ollamaBaseUrl,
     ollamaModel,
+    agents,
   });
 
-  const agent = detectSetupAgentType(cwd, { requestedAgent });
-  const { globalConfig } = resolveConfigDirs(cwd);
-  console.log(`\n  Detected agent: ${agent}`);
-  await installAgentTemplates({
-    projectRoot: cwd,
-    agent,
-    packageRoot,
-    globalConfigDir: agent === 'opencode' ? globalConfig : undefined,
-  });
-  console.log(`  Installed ${agent} templates.`);
+  for (const agent of agents) {
+    await installAgentTemplates({
+      projectRoot: cwd,
+      agent,
+      packageRoot,
+      globalConfigDir: agent === 'opencode' ? globalConfig : undefined,
+    });
+    console.log(`  ✓ Installed ${agent} templates.`);
+  }
 
   console.log('\n─── Installation complete ───────────────────────────\n');
   console.log(`  Memory DB path:     ${result.installState.memoryDbPath}`);
   console.log(`  Embedding cache:    ${result.installState.embeddingCachePath}`);
   console.log(`  MCP config:         ${result.configPath}`);
   console.log(`  Command template:   ${result.commandPath}`);
+  console.log(`  Agents configured:  ${agents.join(', ')}`);
 
-  // Run doctor to surface any remaining issues
   console.log('\n─── Environment check ───────────────────────────────\n');
   const env = {
     ...process.env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aabadin/project-memory-context",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Portable project memory context CLI — bootstraps semantic enrichment workflows for any AI coding agent.",
   "license": "GPL-3.0-or-later",
   "type": "module",

package/src/doctor.mjs

@@ -34,7 +34,7 @@ async function checkNodeVersion() {
 async function checkPython(resolvePythonBin, spawnCheck) {
   const bin = resolvePythonBin?.() ?? null;
   if (!bin) {
-    return { name: 'python', status: 'fail', message: 'Python 3 not found in PATH — install python3 or set PATH' };
+    return { name: 'python', status: 'fail', message: 'Python 3 not found — download from https://www.python.org/downloads/ or set PATH' };
   }
   if (!spawnCheck) {
     return { name: 'python', status: 'ok', message: `${bin} found (not verified — no spawn check provided)` };

package/src/setup-bootstrap.mjs

@@ -1,9 +1,8 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { basename, dirname, join } from 'node:path';
+import { dirname, join } from 'node:path';
 
 import { ensureProjectMemoryContextDirs, writeJsonArtifact } from './artifacts.mjs';
 import { PMC_ENRICHMENT_CONFIG_FILE } from './enrichment-config.mjs';
-import { resolveConfigDirs } from './platform.mjs';
 
 async function readJson(filePath, fallback) {
   try {
@@ -63,52 +62,65 @@ async function writeMcpJson(projectRoot, installState) {
   return mcpPath;
 }
 
-async function ensureAgentConfigRegistration(projectRoot, installState) {
-  const { projectConfig } = resolveConfigDirs(projectRoot);
-  const agentDir = basename(projectConfig);
-
-  if (agentDir === '.opencode') {
-    const configPath = join(projectConfig, 'opencode.json');
-    const config = await readJson(configPath, { $schema: 'https://opencode.ai/config.json' });
-    const existing = Array.isArray(config.plugin) ? config.plugin : [];
-    if (!existing.includes('@aabadin/project-memory-context')) {
-      config.plugin = [...existing, '@aabadin/project-memory-context'];
-    }
-    config.mcp = {
-      ...(config.mcp ?? {}),
-      ...buildOpencodeMcpConfig(installState).mcp,
-    };
-    await mkdir(dirname(configPath), { recursive: true });
-    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
-    // Also write .mcp.json so agent-memory is available immediately
-    await writeMcpJson(projectRoot, installState);
-    return configPath;
+async function ensureOpencodeConfig(projectRoot, installState) {
+  const opencodeDir = join(projectRoot, '.opencode');
+  await mkdir(opencodeDir, { recursive: true });
+  const configPath = join(opencodeDir, 'opencode.json');
+  const config = await readJson(configPath, { $schema: 'https://opencode.ai/config.json' });
+  const existing = Array.isArray(config.plugin) ? config.plugin : [];
+  if (!existing.includes('@aabadin/project-memory-context')) {
+    config.plugin = [...existing, '@aabadin/project-memory-context'];
   }
+  config.mcp = {
+    ...(config.mcp ?? {}),
+    ...buildOpencodeMcpConfig(installState).mcp,
+  };
+  await mkdir(dirname(configPath), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+  return configPath;
+}
 
-  if (agentDir === '.claude' || agentDir === '.cursor' || agentDir === '.pmc') {
-    // For Claude Code, Cursor, and generic PMC setups: write .mcp.json directly
-    const mcpPath = await writeMcpJson(projectRoot, installState);
-    // Also persist enrichment config
-    const enrichPath = join(projectConfig, PMC_ENRICHMENT_CONFIG_FILE);
-    const existingConfig = await readJson(enrichPath, {});
-    const config = {
-      ...existingConfig,
-      enrichment: {
-        ...existingConfig.enrichment,
-        localModel: {
-          ...existingConfig.enrichment?.localModel,
-          baseUrl: installState.ollamaBaseUrl,
-          model: installState.ollamaModel,
-        },
+async function ensureEnrichmentConfig(projectRoot, configDir, installState) {
+  const enrichPath = join(configDir, PMC_ENRICHMENT_CONFIG_FILE);
+  const existingConfig = await readJson(enrichPath, {});
+  const config = {
+    ...existingConfig,
+    enrichment: {
+      ...existingConfig.enrichment,
+      localModel: {
+        ...existingConfig.enrichment?.localModel,
+        baseUrl: installState.ollamaBaseUrl,
+        model: installState.ollamaModel,
       },
-    };
-    await mkdir(dirname(enrichPath), { recursive: true });
-    await writeFile(enrichPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
-    return mcpPath;
+    },
+  };
+  await mkdir(dirname(enrichPath), { recursive: true });
+  await writeFile(enrichPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+}
+
+async function ensureAgentConfigs(projectRoot, installState, agents) {
+  let primaryConfigPath = null;
+
+  for (const agent of agents) {
+    if (agent === 'opencode') {
+      primaryConfigPath = primaryConfigPath ?? await ensureOpencodeConfig(projectRoot, installState);
+    }
+    if (agent === 'claude-code') {
+      const claudeDir = join(projectRoot, '.claude');
+      await mkdir(claudeDir, { recursive: true });
+      await ensureEnrichmentConfig(projectRoot, claudeDir, installState);
+      primaryConfigPath = primaryConfigPath ?? join(projectRoot, '.mcp.json');
+    }
+    if (agent === 'cursor') {
+      const cursorDir = join(projectRoot, '.cursor');
+      await mkdir(cursorDir, { recursive: true });
+      await ensureEnrichmentConfig(projectRoot, cursorDir, installState);
+      primaryConfigPath = primaryConfigPath ?? join(projectRoot, '.mcp.json');
+    }
   }
 
-  // Fallback: no agent dir detected — write .mcp.json at project root
-  return writeMcpJson(projectRoot, installState);
+  await writeMcpJson(projectRoot, installState);
+  return primaryConfigPath ?? join(projectRoot, '.mcp.json');
 }
 
 async function copyTemplate(packageRoot, templateName, projectRoot) {
@@ -126,7 +138,10 @@ export async function bootstrapProjectInstall({
   ollamaBaseUrl,
   ollamaModel,
   embeddingCachePath,
+  agents = [],
+  agent,
 }) {
+  const resolvedAgents = agents.length > 0 ? agents : (agent ? [agent] : ['generic']);
   const dirs = await ensureProjectMemoryContextDirs(projectRoot);
   const memoryDbPath = join(dirs.base, 'memory-db');
   const installState = {
@@ -140,7 +155,7 @@ export async function bootstrapProjectInstall({
 
   await mkdir(memoryDbPath, { recursive: true });
   await writeJsonArtifact(join(dirs.base, 'install.json'), installState);
-  const configPath = await ensureAgentConfigRegistration(projectRoot, installState);
+  const configPath = await ensureAgentConfigs(projectRoot, installState, resolvedAgents);
   const commandPath = await copyTemplate(packageRoot, 'project-memory-context.md', projectRoot);
   const workflowPath = await copyTemplate(packageRoot, 'project-memory-context workflow.md', projectRoot);
 
@@ -149,5 +164,6 @@ export async function bootstrapProjectInstall({
     configPath,
     commandPath,
     workflowPath,
+    agents: resolvedAgents,
   };
 }