claude-autopm 3.23.2 → 3.24.1

package/bin/autopm.js

@@ -208,6 +208,8 @@ function main() {
     .command(require('../lib/cli/commands/agent'))
     // Context management command (STANDALONE)
     .command(require('../lib/cli/commands/context'))
+    // Obsidian vault integration (STANDALONE)
+    .command(require('../lib/cli/commands/obsidian'))
     // Validation command
     .command('validate', 'Validate ClaudeAutoPM configuration and setup',
       (yargs) => {

package/install/install.js

@@ -127,6 +127,44 @@ class Installer {
     console.log(`${this.colors.RED}✗${this.colors.NC} ${msg}`);
   }
 
+  /**
+   * Print scenario-specific next steps after installation
+   */
+  printScenarioNextSteps() {
+    const scenario = this.currentScenario;
+    if (!scenario) return;
+
+    console.log(`${this.colors.CYAN}📋 Next Steps for "${scenario}" scenario:${this.colors.NC}`);
+    console.log('');
+
+    if (scenario === 'obsidian') {
+      console.log('   1. Configure your Obsidian vault:');
+      console.log(`      ${this.colors.BOLD}autopm obsidian setup --vault-path "<your-vault-path>"${this.colors.NC}`);
+      console.log('');
+      console.log(`      ${this.colors.DIM}Use quotes around the path. Examples per platform:${this.colors.NC}`);
+      console.log(`      ${this.colors.DIM}  WSL:   --vault-path "/mnt/c/Users/You/Documents/My Vault"${this.colors.NC}`);
+      console.log(`      ${this.colors.DIM}  macOS: --vault-path "/Users/you/Documents/My Vault"${this.colors.NC}`);
+      console.log(`      ${this.colors.DIM}  Linux: --vault-path "/home/you/Obsidian/My Vault"${this.colors.NC}`);
+      console.log('');
+      console.log('   2. Open the vault folder in Obsidian and install recommended plugins');
+      console.log(`      ${this.colors.DIM}(Dataview, Templater, Excalidraw, Mermaid Tools)${this.colors.NC}`);
+      console.log('');
+      console.log('   3. For continuous sync:');
+      console.log(`      ${this.colors.BOLD}autopm obsidian sync --watch${this.colors.NC}`);
+      console.log('');
+      console.log(`   ${this.colors.DIM}Verify setup:     autopm validate${this.colors.NC}`);
+      console.log(`   ${this.colors.DIM}Troubleshooting:  autopm obsidian doctor${this.colors.NC}`);
+      console.log('');
+    } else {
+      console.log('   1. Open your project in Claude Code:');
+      console.log(`      ${this.colors.BOLD}cd your-project && claude${this.colors.NC}`);
+      console.log('');
+      console.log('   2. Start working! Slash commands are available inside Claude Code.');
+      console.log(`      ${this.colors.DIM}Example: /pm:status, /pm:next, /pm:help${this.colors.NC}`);
+      console.log('');
+    }
+  }
+
   async confirm(prompt) {
     // In test mode or auto-accept mode, auto-answer yes
     if (process.env.AUTOPM_TEST_MODE === '1' || process.env.AUTOPM_AUTO_ACCEPT === '1') {
@@ -561,6 +599,7 @@ ${this.colors.BOLD}Select installation scenario:${this.colors.NC}
    • Core + PM + Obsidian vault sync
    • Unidirectional project → vault mirroring
    • Best for: Knowledge management, documentation-heavy projects
+   • After install, run: ${this.colors.BOLD}autopm obsidian setup --vault-path "<path>"${this.colors.NC}
    ${this.colors.DIM}• Plugins: core, pm, obsidian (3 plugins)${this.colors.NC}
 `);
 
@@ -1525,6 +1564,9 @@ See: https://github.com/rafeekpro/ClaudeAutoPM
     this.printMsg('GREEN', '╚══════════════════════════════════════════╝');
     console.log('');
 
+    // Scenario-specific next steps
+    this.printScenarioNextSteps();
+
     // Run post-installation configuration check
     await this.runPostInstallCheck();
 

package/install/post-install-check.js

@@ -343,7 +343,7 @@ class PostInstallChecker {
   checkObsidianVault() {
     const configPath = path.join(this.projectRoot, '.claude', 'config.json');
     let configured = false;
-    let message = 'Not configured — run: obsidian:setup';
+    let message = 'Not configured — run: autopm obsidian setup --vault-path "<path>"';
 
     if (fs.existsSync(configPath)) {
       try {

package/lib/cli/commands/obsidian.js

@@ -0,0 +1,220 @@
+/**
+ * CLI Obsidian Commands
+ * Manage Obsidian vault integration — setup, sync, diagnostics
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Find project root by walking up from cwd
+ */
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, '.claude', 'config.json')) ||
+        fs.existsSync(path.join(dir, 'CLAUDE.md'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+/**
+ * Find scripts directory — checks installed location first, then source repo
+ */
+function findScriptsDir(root) {
+  const installed = path.join(root, '.claude', 'scripts', 'obsidian');
+  if (fs.existsSync(installed)) return installed;
+
+  const source = path.join(root, 'packages', 'plugin-obsidian', 'scripts', 'obsidian');
+  if (fs.existsSync(source)) return source;
+
+  return null;
+}
+
+/**
+ * Check if plugin-obsidian is installed, return scripts dir
+ */
+function checkPlugin(root) {
+  const scriptsDir = findScriptsDir(root);
+  if (!scriptsDir) {
+    console.error('❌ plugin-obsidian not installed.');
+    console.error('   Run: autopm install --scenario=obsidian');
+    process.exit(1);
+  }
+  return scriptsDir;
+}
+
+/**
+ * autopm obsidian setup
+ */
+async function obsidianSetup(argv) {
+  const root = findProjectRoot();
+  const scriptsDir = checkPlugin(root);
+
+  const scriptPath = path.join(scriptsDir, 'setup.js');
+  if (!fs.existsSync(scriptPath)) {
+    console.error('❌ Setup script not found:', scriptPath);
+    process.exit(1);
+  }
+
+  const args = [];
+  if (argv.vaultPath) args.push('--vault-path', argv.vaultPath);
+  if (argv.prefix) args.push('--prefix', argv.prefix);
+  if (argv.watch === true) args.push('--watch');
+  if (argv.watch === false) args.push('--no-watch');
+  args.push('--project-root', root);
+
+  const child = spawn('node', [scriptPath, ...args], {
+    stdio: 'inherit',
+    cwd: root
+  });
+
+  child.on('close', (code) => process.exit(code || 0));
+}
+
+/**
+ * autopm obsidian sync
+ */
+async function obsidianSync(argv) {
+  const root = findProjectRoot();
+  const scriptsDir = checkPlugin(root);
+
+  // Prefer shell script, fall back to Node
+  const shPath = path.join(scriptsDir, 'sync-to-obsidian.sh');
+  const jsPath = path.join(scriptsDir, 'sync-to-obsidian.js');
+
+  const args = [];
+  if (argv.watch) args.push('--watch');
+  if (argv.check) args.push('--check');
+  if (argv.safeMode) args.push('--safe-mode');
+  args.push('--project-root', root);
+
+  let cmd, cmdArgs;
+  if (fs.existsSync(shPath)) {
+    cmd = 'bash';
+    cmdArgs = [shPath, ...args];
+  } else if (fs.existsSync(jsPath)) {
+    cmd = 'node';
+    cmdArgs = [jsPath, ...args];
+  } else {
+    console.error('❌ Sync script not found. Reinstall plugin-obsidian.');
+    process.exit(1);
+  }
+
+  const child = spawn(cmd, cmdArgs, {
+    stdio: 'inherit',
+    cwd: root
+  });
+
+  child.on('close', (code) => process.exit(code || 0));
+}
+
+/**
+ * autopm obsidian doctor
+ */
+async function obsidianDoctor(argv) {
+  const root = findProjectRoot();
+  const scriptsDir = checkPlugin(root);
+
+  const scriptPath = path.join(scriptsDir, 'doctor.js');
+  if (!fs.existsSync(scriptPath)) {
+    console.error('❌ Doctor script not found:', scriptPath);
+    process.exit(1);
+  }
+
+  const args = ['--project-root', root];
+
+  const child = spawn('node', [scriptPath, ...args], {
+    stdio: 'inherit',
+    cwd: root
+  });
+
+  child.on('close', (code) => process.exit(code || 0));
+}
+
+/**
+ * Command builder — registers subcommands
+ */
+function builder(yargs) {
+  return yargs
+    .command(
+      'setup',
+      'Configure Obsidian vault integration',
+      (yargs) => {
+        return yargs
+          .option('vault-path', {
+            describe: 'Path to your Obsidian vault folder (use quotes if path has spaces)',
+            type: 'string',
+            demandOption: true
+          })
+          .option('prefix', {
+            describe: 'Subfolder name in vault (default: project directory name)',
+            type: 'string'
+          })
+          .option('watch', {
+            describe: 'Enable continuous sync after setup',
+            type: 'boolean'
+          })
+          .example('autopm obsidian setup --vault-path "/mnt/c/Users/You/My Vault"', 'WSL')
+          .example('autopm obsidian setup --vault-path "/Users/you/My Vault"', 'macOS')
+          .example('autopm obsidian setup --vault-path "/home/you/My Vault" --prefix my-project', 'Linux with prefix');
+      },
+      obsidianSetup
+    )
+    .command(
+      'sync',
+      'Sync project files to Obsidian vault',
+      (yargs) => {
+        return yargs
+          .option('watch', {
+            describe: 'Continuous sync on file changes',
+            type: 'boolean',
+            default: false
+          })
+          .option('check', {
+            describe: 'Dry-run: show what would be synced',
+            type: 'boolean',
+            default: false
+          })
+          .option('safe-mode', {
+            describe: 'Never delete vault files (omit --delete from rsync)',
+            type: 'boolean',
+            default: false
+          })
+          .example('autopm obsidian sync', 'One-shot sync')
+          .example('autopm obsidian sync --watch', 'Continuous sync')
+          .example('autopm obsidian sync --check', 'Dry-run');
+      },
+      obsidianSync
+    )
+    .command(
+      'doctor',
+      'Diagnose common Obsidian integration issues',
+      (yargs) => {
+        return yargs
+          .example('autopm obsidian doctor', 'Run all diagnostic checks');
+      },
+      obsidianDoctor
+    )
+    .demandCommand(1, 'You must specify an obsidian command')
+    .strictCommands()
+    .help();
+}
+
+module.exports = {
+  command: 'obsidian',
+  describe: 'Manage Obsidian vault integration (setup, sync, diagnostics)',
+  builder,
+  handler: (argv) => {
+    console.log('\nUsage: autopm obsidian <command>\n');
+    console.log('Commands:');
+    console.log('  setup    Configure Obsidian vault integration');
+    console.log('  sync     Sync project files to Obsidian vault');
+    console.log('  doctor   Diagnose common integration issues');
+    console.log('\nRun autopm obsidian <command> --help for details\n');
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autopm",
-  "version": "3.23.2",
+  "version": "3.24.1",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "workspaces": [

package/packages/plugin-obsidian/README.md

@@ -50,26 +50,32 @@ autopm install
 
 ## Commands
 
-### `obsidian:setup`
+Available from your terminal via `autopm obsidian <command>` and as `/obsidian:<command>` slash commands inside Claude Code.
 
-Interactive vault configuration wizard. Run once after install.
+### `autopm obsidian setup`
+
+Configure your Obsidian vault. Run once after install:
 
 ```bash
-/obsidian:setup --vault-path /path/to/vault --prefix my-project
+autopm obsidian setup --vault-path "/path/to/your vault" --prefix my-project
+
+# WSL:   --vault-path "/mnt/c/Users/You/Documents/My Vault"
+# macOS: --vault-path "/Users/you/Documents/My Vault"
+# Linux: --vault-path "/home/you/Obsidian/My Vault"
 ```
 
-### `obsidian:sync`
+### `autopm obsidian sync`
 
 Sync project files to the Obsidian vault.
 
 ```bash
-/obsidian:sync              # One-shot sync
-/obsidian:sync --watch      # Continuous sync on file changes
-/obsidian:sync --check      # Dry-run (show what would sync)
-/obsidian:sync --safe-mode  # Don't delete vault files
+autopm obsidian sync              # One-shot sync
+autopm obsidian sync --watch      # Continuous sync on file changes
+autopm obsidian sync --check      # Dry-run (show what would sync)
+autopm obsidian sync --safe-mode  # Don't delete vault files
 ```
 
-### `obsidian:doctor`
+### `autopm obsidian doctor`
 
 Diagnose common integration problems:
 

package/packages/plugin-obsidian/plugin.json

@@ -20,6 +20,24 @@
     "tags": ["obsidian", "vault", "sync", "dataview", "integration"]
   },
   "scripts": [
+    {
+      "name": "setup",
+      "file": "scripts/obsidian/setup.js",
+      "description": "Interactive vault configuration wizard",
+      "type": "workflow",
+      "executable": true,
+      "category": "setup",
+      "tags": ["setup", "wizard", "vault"]
+    },
+    {
+      "name": "doctor",
+      "file": "scripts/obsidian/doctor.js",
+      "description": "Diagnostic checks for common integration issues",
+      "type": "utility",
+      "executable": true,
+      "category": "diagnostics",
+      "tags": ["doctor", "diagnostics", "vault"]
+    },
     {
       "name": "sync-to-obsidian",
       "file": "scripts/obsidian/sync-to-obsidian.sh",

package/packages/plugin-obsidian/scripts/obsidian/setup.js

@@ -158,7 +158,12 @@ function substituteTemplate(content, vars) {
 // ─── Template generation ────────────────────────────────────────────
 
 function generateTemplates(vaultDest, prefix, projectRoot) {
-  const templatesDir = join(__dirname, '..', '..', 'templates');
+  // Find templates: check relative to script first, then source repo from project root
+  const candidates = [
+    join(__dirname, '..', '..', 'templates'),
+    join(projectRoot, 'packages', 'plugin-obsidian', 'templates'),
+  ];
+  const templatesDir = candidates.find(d => existsSync(join(d, 'MOC.md.tmpl'))) || candidates[0];
   const createdDate = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
   const projectName = prefix;
 

package/packages/plugin-obsidian/tests/docs.test.js

@@ -36,27 +36,27 @@ describe('plugin-obsidian documentation', () => {
   describe('packages/plugin-obsidian/README.md', () => {
     const readmePath = resolve(root, 'packages', 'plugin-obsidian', 'README.md');
 
-    it('mentions obsidian:setup', () => {
+    it('mentions obsidian setup command', () => {
       const content = readFileSync(readmePath, 'utf8');
       assert.ok(
-        content.includes('obsidian:setup'),
-        'README must mention obsidian:setup'
+        content.includes('obsidian setup'),
+        'README must mention obsidian setup'
       );
     });
 
-    it('mentions obsidian:sync', () => {
+    it('mentions obsidian sync command', () => {
       const content = readFileSync(readmePath, 'utf8');
       assert.ok(
-        content.includes('obsidian:sync'),
-        'README must mention obsidian:sync'
+        content.includes('obsidian sync'),
+        'README must mention obsidian sync'
       );
     });
 
-    it('mentions obsidian:doctor', () => {
+    it('mentions obsidian doctor command', () => {
       const content = readFileSync(readmePath, 'utf8');
       assert.ok(
-        content.includes('obsidian:doctor'),
-        'README must mention obsidian:doctor'
+        content.includes('obsidian doctor'),
+        'README must mention obsidian doctor'
       );
     });
   });
@@ -64,21 +64,11 @@ describe('plugin-obsidian documentation', () => {
   describe('CHANGELOG.md', () => {
     const changelogPath = resolve(root, 'CHANGELOG.md');
 
-    it('mentions plugin-obsidian under Unreleased', () => {
+    it('mentions plugin-obsidian', () => {
       const content = readFileSync(changelogPath, 'utf8');
-      const unreleasedIdx = content.indexOf('## [Unreleased]');
-      assert.ok(unreleasedIdx !== -1, 'CHANGELOG must have an [Unreleased] section');
-
-      // Find the next version heading after Unreleased
-      const afterUnreleased = content.slice(unreleasedIdx + '## [Unreleased]'.length);
-      const nextVersionIdx = afterUnreleased.indexOf('\n## [');
-      const unreleasedSection = nextVersionIdx !== -1
-        ? afterUnreleased.slice(0, nextVersionIdx)
-        : afterUnreleased;
-
       assert.ok(
-        unreleasedSection.includes('plugin-obsidian'),
-        'Unreleased section must mention plugin-obsidian'
+        content.includes('plugin-obsidian'),
+        'CHANGELOG must mention plugin-obsidian'
       );
     });
   });