@sbains2/lifeos 0.2.1 → 0.2.2

package/bin/lifeos.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { run } from '../src/index.js';
 import { runDoctorCommand } from '../src/commands/doctor.js';
+import { runBrainCommand } from '../src/commands/brain.js';
 
 // Parse argv: optional subcommand + positional target dir + flags
 // Usage:
@@ -32,6 +33,16 @@ Doctor options:
   --quiet       Suppress ✓ lines, only show warnings and errors
   --strict      Exit code 1 even on warnings (default: warnings are 0)
 
+Brain options:
+  --dry-run     Show what would run without invoking graphify
+  --json        Emit machine-readable JSON (for CI / scripting)
+
+Note on brain: lifeos brain shells out to graphify (https://github.com/
+safishamsi/graphify), an OSS knowledge-graph tool. Install once with
+"pip install graphifyy && graphify install". Code parsing is 100% local;
+semantic extraction uses your existing AI-assistant session (no separate
+API key, no incremental cost).
+
 Arguments:
   target-dir    Directory to scaffold into / verify (default: current working dir)
 
@@ -61,8 +72,15 @@ async function main() {
     });
     process.exit(exitCode);
   }
-  if (subcommand === 'brain' || subcommand === 'migrate') {
-    console.error(`\nNot yet implemented: \`lifeos ${subcommand}\`. See docs/COMMANDS.md for the design.`);
+  if (subcommand === 'brain') {
+    const exitCode = await runBrainCommand(targetDir, {
+      dryRun: flags.has('--dry-run'),
+      json: flags.has('--json'),
+    });
+    process.exit(exitCode);
+  }
+  if (subcommand === 'migrate') {
+    console.error(`\nNot yet implemented: \`lifeos migrate\`. See docs/COMMANDS.md for the design.`);
     process.exit(2);
   }
   // Default: run the wizard

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sbains2/lifeos",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Scaffold a personal LifeOS — life-quadrant folders, a council of AI agent voices, and curated MCP wiring. Generates a working lifeos.config.json + .claude/agents/council/ in 2-4 minutes (or <60s with --minimal). BETA — early seed release.",
   "type": "module",
   "bin": {

package/src/brain.js

@@ -0,0 +1,129 @@
+/**
+ * `lifeos brain` — thin wrapper around graphify (https://github.com/safishamsi/graphify).
+ *
+ * Why graphify (decision rationale):
+ * - Open-source, MIT-licensed
+ * - Runs entirely on the user's machine: code parsing is 100% local via tree-sitter
+ *   AST + NetworkX + Leiden clustering
+ * - For semantic content (docs, images, PDFs), uses the user's EXISTING AI-assistant
+ *   session — Claude Code, Cursor, Codex, etc. — via credentials they've already
+ *   configured. No separate API key, no incremental cost beyond their existing
+ *   subscription.
+ * - Cost to LifeOS project: $0 (we don't host or proxy anything)
+ * - Cost to friends installing LifeOS: $0 incremental (their Claude Code subscription
+ *   is already paying for any LLM calls graphify makes)
+ *
+ * This module is a thin shell-out wrapper. It does not re-implement graphify;
+ * it just invokes it with the right paths from lifeos.config.json.
+ */
+
+import { execSync, spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, isAbsolute } from 'node:path';
+
+/**
+ * Check if graphify is installed and available in PATH.
+ * Pure side-effect-free check. Returns boolean.
+ */
+export function isGraphifyInstalled() {
+  try {
+    execSync('command -v graphify', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Determine what `lifeos brain` would do for a given scaffold, without executing.
+ * Returns { ok, paths, cwd, outputHint } on success or { ok: false, error } on failure.
+ */
+export function planBrainRun(targetDir) {
+  const configPath = join(targetDir, 'lifeos.config.json');
+  if (!existsSync(configPath)) {
+    return { ok: false, error: `lifeos.config.json not found at ${configPath}` };
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, 'utf8'));
+  } catch (err) {
+    return { ok: false, error: `lifeos.config.json parse failed: ${err.message}` };
+  }
+
+  // Prefer brain.graphify.paths (explicit config); fall back to active quadrant paths
+  const configuredPaths = config.brain?.graphify?.paths;
+  const activeQuadrantPaths = (config.quadrants ?? []).filter((q) => q.active).map((q) => q.path);
+  const paths = configuredPaths && configuredPaths.length > 0 ? configuredPaths : activeQuadrantPaths;
+
+  if (paths.length === 0) {
+    return {
+      ok: false,
+      error:
+        'No paths to index. Add at least one active quadrant to lifeos.config.json or set brain.graphify.paths explicitly.',
+    };
+  }
+
+  // Resolve relative paths against targetDir for display + check existence (warn, not error)
+  const resolvedPaths = paths.map((p) => (isAbsolute(p) ? p : join(targetDir, p)));
+  const missingPaths = resolvedPaths.filter((p) => !existsSync(p));
+
+  return {
+    ok: true,
+    paths,
+    resolvedPaths,
+    missingPaths,
+    cwd: targetDir,
+    outputHint: config.brain?.graphify?.output ?? './graphify-out',
+  };
+}
+
+/**
+ * Invoke graphify with the planned paths. Inherits stdio so the user sees graphify's
+ * own output stream. Returns { ok, exitCode, paths, outputDir } or { ok: false, error }.
+ *
+ * Does NOT auto-install graphify (too invasive — pip install requires user consent).
+ * If graphify is missing, returns ok:false with install instructions.
+ */
+export function runBrain(targetDir, options = {}) {
+  const { dryRun = false } = options;
+
+  const plan = planBrainRun(targetDir);
+  if (!plan.ok) return plan;
+
+  if (!isGraphifyInstalled()) {
+    return {
+      ok: false,
+      error: 'graphify not installed',
+      installCommand: 'pip install graphifyy && graphify install',
+      installUrl: 'https://github.com/safishamsi/graphify',
+    };
+  }
+
+  if (dryRun) {
+    return {
+      ok: true,
+      dryRun: true,
+      command: 'graphify',
+      args: plan.paths,
+      cwd: plan.cwd,
+      outputDir: join(plan.cwd, 'graphify-out'),
+    };
+  }
+
+  // Shell out to graphify; let it write to its default `graphify-out/` in the
+  // working directory. We deliberately don't try to redirect output — graphify's
+  // CLI surface evolves and we don't want to fight it. Output location is
+  // surfaced to the user in our wrapper's "next steps" message.
+  const result = spawnSync('graphify', plan.paths, {
+    cwd: plan.cwd,
+    stdio: 'inherit',
+    encoding: 'utf8',
+  });
+
+  return {
+    ok: result.status === 0,
+    exitCode: result.status,
+    paths: plan.paths,
+    outputDir: join(plan.cwd, 'graphify-out'),
+  };
+}

package/src/commands/brain.js

@@ -0,0 +1,148 @@
+/**
+ * `lifeos brain` subcommand orchestrator.
+ *
+ * Thin wrapper around src/brain.js — handles flag parsing, output formatting,
+ * and exit codes. The actual graphify invocation is in brain.js.
+ *
+ * Flags:
+ *   --dry-run    Show what would run without invoking graphify
+ *                (does NOT require graphify to be installed — useful for previewing)
+ *   --json       Emit machine-readable JSON (for CI / scripting)
+ */
+
+import { runBrain, planBrainRun, isGraphifyInstalled } from '../brain.js';
+import { c } from '../utils/colors.js';
+
+export async function runBrainCommand(targetDir, options = {}) {
+  const { dryRun = false, json = false } = options;
+
+  // Step 1: plan first (no external deps — works without graphify)
+  const plan = planBrainRun(targetDir);
+  if (!plan.ok) {
+    if (json) {
+      console.log(JSON.stringify(plan, null, 2));
+    } else {
+      console.log('');
+      console.log(c.err(`✗ ${plan.error}`));
+      console.log('');
+    }
+    return 1;
+  }
+
+  // Step 2: if dry-run, print plan and exit (graphify install not required)
+  if (dryRun) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          {
+            ok: true,
+            dryRun: true,
+            command: 'graphify',
+            args: plan.paths,
+            cwd: plan.cwd,
+            outputDir: `${plan.cwd}/graphify-out`,
+            graphifyInstalled: isGraphifyInstalled(),
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log('');
+      console.log(c.bold('lifeos brain --dry-run') + c.dim(' — would invoke:'));
+      console.log('');
+      console.log(`  ${c.cyan('cd')} ${plan.cwd}`);
+      console.log(`  ${c.cyan('graphify')} ${plan.paths.join(' ')}`);
+      console.log('');
+      console.log(c.dim(`  Output would land in: ${plan.cwd}/graphify-out/`));
+      if (plan.missingPaths && plan.missingPaths.length > 0) {
+        console.log('');
+        console.log(c.warn(`  ⚠ ${plan.missingPaths.length} path(s) don't exist — graphify may skip them:`));
+        for (const p of plan.missingPaths) {
+          console.log(c.dim(`     ${p}`));
+        }
+      }
+      if (!isGraphifyInstalled()) {
+        console.log('');
+        console.log(c.warn('  ⚠ graphify not installed yet — actual run would fail.'));
+        console.log(c.dim('     Install: pip install graphifyy && graphify install'));
+      }
+      console.log('');
+    }
+    return 0;
+  }
+
+  // Step 3: check graphify installed (only required for real execution)
+  if (!isGraphifyInstalled()) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          {
+            ok: false,
+            error: 'graphify not installed',
+            installCommand: 'pip install graphifyy && graphify install',
+            installUrl: 'https://github.com/safishamsi/graphify',
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log('');
+      console.log(c.bold('lifeos brain') + c.dim(' — knowledge graph via graphify'));
+      console.log('');
+      console.log(`  ${c.err('✗')} graphify not installed`);
+      console.log(c.dim(`     graphify is the OSS knowledge-graph builder LifeOS uses for the brain.`));
+      console.log(c.dim(`     It runs entirely on your machine — code parsing is 100% local`));
+      console.log(c.dim(`     (tree-sitter AST), and semantic extraction goes through your`));
+      console.log(c.dim(`     existing Claude Code / Cursor / Codex session (no separate API`));
+      console.log(c.dim(`     key, no incremental cost).`));
+      console.log('');
+      console.log(`     ${c.cyan('→ install:  ')}pip install graphifyy && graphify install`);
+      console.log(`     ${c.cyan('→ docs:     ')}https://github.com/safishamsi/graphify`);
+      console.log(`     ${c.cyan('→ preview:  ')}lifeos brain --dry-run ${targetDir}`);
+      console.log('');
+    }
+    return 1;
+  }
+
+  // Step 4: real invocation
+  console.log('');
+  console.log(c.bold('lifeos brain') + c.dim(` — indexing ${plan.paths.length} path(s) via graphify`));
+  console.log(c.dim(`  paths: ${plan.paths.join(', ')}`));
+  console.log(c.dim(`  cwd:   ${plan.cwd}`));
+  if (plan.missingPaths && plan.missingPaths.length > 0) {
+    console.log(c.warn(`  ⚠ ${plan.missingPaths.length} path(s) don't exist — graphify may skip them: ${plan.missingPaths.join(', ')}`));
+  }
+  console.log('');
+  console.log(c.dim('--- graphify output below ---'));
+  console.log('');
+
+  const result = runBrain(targetDir, { dryRun: false });
+
+  console.log('');
+  if (result.ok) {
+    if (json) {
+      console.log(JSON.stringify({ ok: true, paths: result.paths, outputDir: result.outputDir }, null, 2));
+    } else {
+      console.log(c.bold(c.ok('✓ brain built')));
+      console.log(c.dim(`  Output: ${result.outputDir}`));
+      console.log(c.dim(`  View graph:    open ${result.outputDir}/graph.html`));
+      console.log(c.dim(`  Read summary:  cat ${result.outputDir}/GRAPH_REPORT.md`));
+      console.log(c.dim(`  Query graph:   graphify query "your question"`));
+      console.log('');
+    }
+    return 0;
+  } else {
+    if (json) {
+      console.log(JSON.stringify({ ok: false, exitCode: result.exitCode }, null, 2));
+    } else {
+      console.log(c.err(`✗ graphify exited with code ${result.exitCode}`));
+      console.log(c.dim('  Check graphify output above for details. Common issues:'));
+      console.log(c.dim('    - Paths not readable / outside scope'));
+      console.log(c.dim('    - graphify install incomplete (run `graphify install` again)'));
+      console.log(c.dim('    - Underlying AI assistant session not configured'));
+    }
+    return result.exitCode || 1;
+  }
+}

package/src/doctor.js

@@ -253,7 +253,33 @@ export function runDoctor(targetDir) {
     }
   }
 
-  // Check 9: MCP runtimes available (npx / uvx / docker)
+  // Check 9: graphify installed (only if brain is enabled — graphify powers `lifeos brain`)
+  if (config.brain?.graphify?.enabled) {
+    let graphifyInstalled = false;
+    try {
+      execSync('command -v graphify', { stdio: 'ignore' });
+      graphifyInstalled = true;
+    } catch {
+      /* not installed */
+    }
+    if (graphifyInstalled) {
+      checks.push({
+        id: 'graphify_installed',
+        name: 'graphify installed (powers `lifeos brain`)',
+        status: 'ok',
+      });
+    } else {
+      checks.push({
+        id: 'graphify_installed',
+        name: 'graphify installed (powers `lifeos brain`)',
+        status: 'warn',
+        message: 'graphify CLI not in PATH — brain command will fail',
+        fix: 'Install (no API key needed; uses your existing Claude Code session):\n     pip install graphifyy && graphify install\n     docs: https://github.com/safishamsi/graphify',
+      });
+    }
+  }
+
+  // Check 10: MCP runtimes available (npx / uvx / docker)
   const wiredRuntimes = new Set();
   if (registry) {
     const byId = new Map(registry.servers.map((s) => [s.id, s]));

package/src/index.js

@@ -26,7 +26,7 @@ export async function run(targetDir, options = {}) {
   const { minimal = false } = options;
 
   console.log('');
-  console.log(c.bold('lifeos') + c.dim(' v0.2.1 — scaffold a personal LifeOS'));
+  console.log(c.bold('lifeos') + c.dim(' v0.2.2 — scaffold a personal LifeOS'));
   console.log(c.dim(`Target directory: ${targetDir}`));
   if (minimal) {
     console.log(c.dim('Mode: --minimal (speed-optimized; using template defaults for quadrants, council, MCPs)'));