@sbains2/lifeos 0.2.1 → 0.3.0

package/bin/lifeos.js

@@ -1,14 +1,52 @@
 #!/usr/bin/env node
+import { resolve } from 'node:path';
 import { run } from '../src/index.js';
 import { runDoctorCommand } from '../src/commands/doctor.js';
+import { runBrainCommand } from '../src/commands/brain.js';
+import { runContext } from '../src/commands/context.js';
+import { runSchedule } from '../src/commands/schedule.js';
 
 // Parse argv: optional subcommand + positional target dir + flags
 // Usage:
 //   lifeos [target-dir] [--minimal]              # wizard (default)
 //   lifeos doctor [target-dir] [--json] [--quiet] [--strict]
 const args = process.argv.slice(2);
-const flags = new Set(args.filter((a) => a.startsWith('--')));
-const positional = args.filter((a) => !a.startsWith('--') && !a.startsWith('-'));
+
+// `schedule` dispatches EARLY, before the global flag/positional parsing:
+// its value flags (--prompt <file>, --every 1d, ...) would otherwise be
+// misread as positional args and corrupt targetDir resolution. It also owns
+// its own --help (so `lifeos schedule --help` prints the schedule help, not
+// the global help). schedule operates on cwd — no positional target-dir arg.
+if (args[0] === 'schedule') {
+  const exitCode = await runSchedule(resolve(process.cwd()), args.slice(1));
+  process.exit(exitCode);
+}
+
+// `context`'s --quadrant takes a value; extract flag + value before the
+// global parser treats the value as a positional target dir.
+let quadrantId = null;
+let filteredArgs = args;
+const qIdx = args.indexOf('--quadrant');
+if (qIdx !== -1) {
+  const qVal = args[qIdx + 1];
+  if (qVal !== undefined && !qVal.startsWith('-')) {
+    quadrantId = qVal;
+    filteredArgs = args.filter((_, i) => i !== qIdx && i !== qIdx + 1);
+  } else {
+    // dangling `--quadrant` (no value, or followed by another flag): drop only
+    // the flag so a trailing --json/--help isn't swallowed as its value.
+    filteredArgs = args.filter((_, i) => i !== qIdx);
+  }
+} else {
+  const qEq = args.find((a) => a.startsWith('--quadrant='));
+  if (qEq) {
+    quadrantId = qEq.split('=')[1];
+    filteredArgs = args.filter((a) => a !== qEq);
+  }
+}
+
+const flags = new Set(filteredArgs.filter((a) => a.startsWith('--')));
+const positional = filteredArgs.filter((a) => !a.startsWith('--') && !a.startsWith('-'));
 
 if (flags.has('--help') || flags.has('-h') || positional[0] === 'help') {
   console.log(`lifeos — scaffold and verify a personal LifeOS
@@ -16,6 +54,8 @@ if (flags.has('--help') || flags.has('-h') || positional[0] === 'help') {
 Usage:
   lifeos [target-dir] [options]                   # run the wizard
   lifeos doctor [target-dir] [options]            # verify scaffold health
+  lifeos context [target-dir] [options]           # print the convening context block
+  lifeos schedule <add|list|remove> [options]     # run agent prompts on a schedule
   lifeos --help                                   # show this
 
 Wizard options:
@@ -32,6 +72,26 @@ 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)
+
+Context options:
+  --json            Emit the same data as structured JSON (for runtimes / scripting)
+  --quadrant <id>   Scope output to one quadrant (its council subset; foci stay global)
+
+Schedule subcommands (run \`lifeos schedule --help\` for full details):
+  add <name>    --prompt <file> (--every <n>{d|h} [--at HH:MM] | --cron "<expr>")
+                [--runtime claude-code|codex] [--dry-run]
+  list          Show installed schedules
+  remove <name> Uninstall a schedule (launchd unload on macOS)
+
+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)
 
@@ -42,14 +102,21 @@ Examples:
   lifeos doctor                                   # verify current dir
   lifeos doctor ~/my-lifeos                       # verify ~/my-lifeos
   lifeos doctor --json | jq '.summary'            # programmatic check
+  lifeos context ~/my-lifeos                      # convening block to stdout (pipe-friendly)
+  lifeos context --quadrant job-search            # scope to one quadrant's council
+  lifeos schedule add digest --prompt templates/prompts/weekly_digest.md --every 1d
 `);
   process.exit(0);
 }
 
-// Subcommand dispatch
-const subcommand = ['doctor', 'brain', 'migrate'].includes(positional[0]) ? positional[0] : null;
+// Subcommand dispatch (schedule handled earlier — see top of file)
+const subcommand = ['doctor', 'brain', 'migrate', 'context'].includes(positional[0]) ? positional[0] : null;
 const remainingPositional = subcommand ? positional.slice(1) : positional;
-const targetDir = remainingPositional[0] ?? process.cwd();
+// BUGFIX 2026-05-01: always resolve to absolute path. If user passes '.' as
+// the positional arg, downstream `path.join(targetDir, q.path)` collapses to a
+// relative string ('Classes' instead of '/.../lifeos-demo-clean/Classes'),
+// which breaks the validator's parent-writeable check (it walks up to '/').
+const targetDir = resolve(remainingPositional[0] ?? process.cwd());
 
 async function main() {
   if (subcommand === 'doctor') {
@@ -61,8 +128,22 @@ 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 === 'context') {
+    const exitCode = await runContext(targetDir, {
+      json: flags.has('--json'),
+      quadrant: quadrantId,
+    });
+    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.3.0",
   "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": {
@@ -18,8 +18,7 @@
   ],
   "scripts": {
     "start": "node bin/lifeos.js",
-    "test": "node --test test/*.test.js",
-    "sync-templates": "rm -rf templates && cp -R ../templates ./templates"
+    "test": "node --test test/*.test.js"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.2.0",

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/commands/context.js

@@ -0,0 +1,40 @@
+/**
+ * `lifeos context` subcommand orchestrator.
+ *
+ * Thin wrapper around src/context.js — handles flags, output formatting, and
+ * exit codes. The planning/rendering logic (rank foci/quadrants/council by
+ * priority) is pure and lives in context.js.
+ *
+ * Flags:
+ *   --json            Emit the same data as structured JSON (for runtimes / scripting)
+ *   --quadrant <id>   Scope output to one quadrant (its council subset + foci)
+ */
+
+import { planContext, renderContextMarkdown } from '../context.js';
+import { c } from '../utils/colors.js';
+
+export async function runContext(targetDir, flags = {}) {
+  const { json = false, quadrant = null } = flags;
+
+  const plan = planContext(targetDir, { quadrant });
+  if (!plan.ok) {
+    if (json) {
+      console.log(JSON.stringify(plan, null, 2));
+    } else {
+      console.log('');
+      console.log(`  ${c.err('✗')} ${plan.error}`);
+      if (plan.fix) console.log(c.cyan(`     → fix: ${plan.fix}`));
+      console.log('');
+    }
+    return 1;
+  }
+
+  if (json) {
+    console.log(JSON.stringify(plan, null, 2));
+    return 0;
+  }
+
+  // Plain markdown to stdout — no ANSI, so it pipes cleanly into a convening.
+  console.log(renderContextMarkdown(plan));
+  return 0;
+}