cairn-work 0.2.0

package/lib/commands/update-skill.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { detectAgents, getAgentName } from '../agents/detect.js';
+import { setupClawdbot } from '../agents/clawdbot.js';
+import { setupClaudeCode } from '../agents/claude-code.js';
+import { setupCursor } from '../agents/cursor.js';
+import { resolveWorkspace } from '../setup/workspace.js';
+
+export default async function updateSkill(options) {
+  console.log(chalk.bold.cyan('\n🏔️  Updating Agent Skill\n'));
+
+  const workspacePath = resolveWorkspace();
+
+  if (!workspacePath) {
+    console.error(chalk.red('Error:'), 'No workspace found. Run:', chalk.cyan('cairn init'));
+    process.exit(1);
+  }
+  
+  // Determine which agents to update
+  let agentsToUpdate = [];
+  
+  if (options.agent) {
+    agentsToUpdate = [options.agent];
+  } else {
+    const { detected } = detectAgents();
+    if (detected.length === 0) {
+      console.log(chalk.yellow('⚠'), 'No agents detected');
+      console.log(chalk.dim('Specify agent:'), chalk.cyan('cairn update-skill --agent <type>'));
+      return;
+    }
+    agentsToUpdate = detected;
+  }
+  
+  // Update each agent
+  for (const agent of agentsToUpdate) {
+    const spinner = ora(`Updating ${getAgentName(agent)}`).start();
+    
+    try {
+      switch (agent) {
+        case 'clawdbot':
+          await setupClawdbot(workspacePath);
+          spinner.succeed(`${getAgentName(agent)} skill updated`);
+          break;
+          
+        case 'claude-code':
+          await setupClaudeCode(workspacePath);
+          spinner.succeed(`${getAgentName(agent)} skill updated`);
+          break;
+          
+        case 'cursor':
+          await setupCursor(workspacePath);
+          spinner.succeed(`${getAgentName(agent)} skill updated`);
+          break;
+          
+        default:
+          spinner.info(`${getAgentName(agent)} - no auto-update available`);
+      }
+    } catch (error) {
+      spinner.fail(`Failed to update ${getAgentName(agent)}`);
+      console.error(chalk.red('Error:'), error.message);
+    }
+  }
+  
+  console.log();
+  console.log(chalk.green('✓'), 'Agent skills updated');
+  console.log(chalk.dim('Your agents now have the latest Cairn workflow documentation.'));
+  console.log();
+}

package/lib/commands/update.js

@@ -0,0 +1,84 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Check npm registry for latest version and prompt to update
+ */
+export default async function update() {
+  console.log(chalk.bold.cyan('\n🏔️  Checking for updates...\n'));
+  
+  // Get current version
+  const packageJson = JSON.parse(
+    readFileSync(join(__dirname, '../../package.json'), 'utf8')
+  );
+  const currentVersion = packageJson.version;
+  
+  try {
+    // Check npm registry for latest version
+    const { stdout } = await execAsync('npm view cairn version');
+    const latestVersion = stdout.trim();
+    
+    console.log(chalk.dim('Current version:'), chalk.cyan(currentVersion));
+    console.log(chalk.dim('Latest version:'), chalk.cyan(latestVersion));
+    console.log();
+    
+    if (currentVersion === latestVersion) {
+      console.log(chalk.green('✓'), 'You are running the latest version!');
+      console.log();
+      return;
+    }
+    
+    // Prompt to update
+    const { shouldUpdate } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'shouldUpdate',
+      message: `Update to v${latestVersion}?`,
+      default: true
+    }]);
+    
+    if (!shouldUpdate) {
+      console.log(chalk.yellow('\nUpdate cancelled.'));
+      return;
+    }
+    
+    // Perform update
+    console.log();
+    console.log(chalk.dim('Running:'), chalk.cyan('npm install -g cairn@latest'));
+    console.log();
+    
+    const updateProcess = exec('npm install -g cairn@latest');
+    updateProcess.stdout.pipe(process.stdout);
+    updateProcess.stderr.pipe(process.stderr);
+    
+    updateProcess.on('exit', (code) => {
+      if (code === 0) {
+        console.log();
+        console.log(chalk.green('✓'), 'Update complete!');
+        console.log(chalk.dim('Run'), chalk.cyan('cairn --version'), chalk.dim('to verify.'));
+        console.log();
+      } else {
+        console.log();
+        console.error(chalk.red('✗'), 'Update failed');
+        console.log(chalk.dim('Try running manually:'), chalk.cyan('npm install -g cairn@latest'));
+        console.log();
+        process.exit(1);
+      }
+    });
+    
+  } catch (error) {
+    console.error(chalk.red('Error checking for updates:'), error.message);
+    console.log(chalk.dim('\nYou can update manually:'));
+    console.log(chalk.cyan('  npm install -g cairn@latest'));
+    console.log();
+    process.exit(1);
+  }
+}

package/lib/setup/workspace.js

@@ -0,0 +1,147 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import chalk from 'chalk';
+import ora from 'ora';
+
+/**
+ * Create Cairn workspace structure
+ */
+export function createWorkspace(path) {
+  const spinner = ora('Creating workspace structure').start();
+  
+  const folders = [
+    '',
+    'projects',
+    'inbox',
+    '_drafts',
+    '_conflicts',
+    '_abandoned',
+  ];
+  
+  for (const folder of folders) {
+    const fullPath = join(path, folder);
+    if (!existsSync(fullPath)) {
+      mkdirSync(fullPath, { recursive: true });
+    }
+  }
+  
+  spinner.succeed('Workspace structure created');
+  return path;
+}
+
+/**
+ * Create welcome README in workspace
+ */
+export function createWelcomeFile(path) {
+  const readmePath = join(path, 'README.md');
+  
+  if (existsSync(readmePath)) {
+    return; // Don't overwrite existing README
+  }
+  
+  const content = `# Welcome to Cairn 🏔️
+
+You've successfully set up Cairn!
+
+## Your Workspace
+
+This folder (\`${path}\`) contains all your project files.
+
+### Structure
+
+- \`projects/\` - Your projects (e.g., "launch-my-app")
+- \`inbox/\` - Ideas and incoming tasks to triage
+- \`_drafts/\` - Work in progress
+- \`_conflicts/\` - Sync conflicts (if using multi-device sync)
+
+## Getting Started
+
+### Create Your First Project
+
+\`\`\`bash
+cairn create project "My First Project"
+\`\`\`
+
+Or create manually:
+- Create folder: \`projects/my-first-project/\`
+- Create file: \`charter.md\`
+- Add frontmatter (see examples below)
+
+### Work with Your AI Agent
+
+Your AI agent is configured to work with Cairn! Try:
+
+\`\`\`
+"Help me create a project called Launch My App"
+\`\`\`
+
+## File Format
+
+Cairn uses markdown files with YAML frontmatter:
+
+\`\`\`yaml
+---
+title: My Project
+description: What we're building
+status: active
+priority: 1
+owner: me
+---
+
+## Why This Matters
+
+[Your goals]
+
+## Success Criteria
+
+[What does done look like?]
+\`\`\`
+
+## Learn More
+
+- **Commands:** \`cairn --help\`
+- **Check health:** \`cairn doctor\`
+- **Update skill:** \`cairn update-skill\`
+
+Happy building! 🏔️
+`;
+  
+  writeFileSync(readmePath, content);
+  console.log(chalk.green('✓'), 'Welcome file created');
+}
+
+/**
+ * Check if workspace exists
+ */
+export function workspaceExists(path) {
+  return existsSync(join(path, 'projects'));
+}
+
+/**
+ * Find an existing workspace by checking known locations.
+ * Returns the first match, or null if none found.
+ */
+export function resolveWorkspace() {
+  const candidates = [
+    process.cwd(),
+    join(homedir(), 'cairn'),
+  ];
+  return candidates.find(p => workspaceExists(p)) || null;
+}
+
+/**
+ * Validate workspace structure
+ */
+export function validateWorkspace(path) {
+  const requiredFolders = ['projects', 'inbox'];
+  const missing = [];
+  
+  for (const folder of requiredFolders) {
+    if (!existsSync(join(path, folder))) {
+      missing.push(folder);
+    }
+  }
+  
+  return { valid: missing.length === 0, missing };
+}

package/lib/setup/workspace.test.js

@@ -0,0 +1,123 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { 
+  createWorkspace, 
+  workspaceExists, 
+  validateWorkspace,
+  createWelcomeFile 
+} from './workspace.js';
+import { existsSync, rmSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('Workspace Management', () => {
+  let testPath;
+  
+  beforeEach(() => {
+    // Create unique test directory
+    testPath = join(tmpdir(), `cairn-test-workspace-${Date.now()}`);
+  });
+  
+  afterEach(() => {
+    // Clean up test directory
+    if (existsSync(testPath)) {
+      rmSync(testPath, { recursive: true, force: true });
+    }
+  });
+  
+  test('createWorkspace creates all required folders', () => {
+    createWorkspace(testPath);
+    
+    const expectedFolders = [
+      '',
+      'projects',
+      'inbox',
+      '_drafts',
+      '_conflicts',
+      '_abandoned',
+    ];
+    
+    for (const folder of expectedFolders) {
+      const fullPath = join(testPath, folder);
+      expect(existsSync(fullPath)).toBe(true);
+    }
+  });
+  
+  test('createWorkspace returns workspace path', () => {
+    const result = createWorkspace(testPath);
+    expect(result).toBe(testPath);
+  });
+  
+  test('createWorkspace is idempotent', () => {
+    // Create workspace twice
+    createWorkspace(testPath);
+    createWorkspace(testPath);
+    
+    // Should still exist and be valid
+    expect(existsSync(join(testPath, 'projects'))).toBe(true);
+  });
+  
+  test('workspaceExists returns false for non-existent workspace', () => {
+    expect(workspaceExists(testPath)).toBe(false);
+  });
+  
+  test('workspaceExists returns true after creation', () => {
+    createWorkspace(testPath);
+    expect(workspaceExists(testPath)).toBe(true);
+  });
+  
+  test('validateWorkspace detects valid workspace', () => {
+    createWorkspace(testPath);
+    
+    const result = validateWorkspace(testPath);
+    
+    expect(result.valid).toBe(true);
+    expect(result.missing).toHaveLength(0);
+  });
+  
+  test('validateWorkspace detects missing folders', () => {
+    // Create workspace but remove a required folder
+    createWorkspace(testPath);
+    rmSync(join(testPath, 'inbox'), { recursive: true, force: true });
+    
+    const result = validateWorkspace(testPath);
+    
+    expect(result.valid).toBe(false);
+    expect(result.missing).toContain('inbox');
+  });
+  
+  test('validateWorkspace detects completely invalid workspace', () => {
+    const result = validateWorkspace(testPath);
+    
+    expect(result.valid).toBe(false);
+    expect(result.missing.length).toBeGreaterThan(0);
+  });
+  
+  test('createWelcomeFile creates README', () => {
+    createWorkspace(testPath);
+    createWelcomeFile(testPath);
+    
+    const readmePath = join(testPath, 'README.md');
+    expect(existsSync(readmePath)).toBe(true);
+    
+    const content = readFileSync(readmePath, 'utf-8');
+    expect(content).toContain('Welcome to Cairn');
+    expect(content).toContain('projects/');
+  });
+  
+  test('createWelcomeFile does not overwrite existing README', () => {
+    createWorkspace(testPath);
+    
+    const readmePath = join(testPath, 'README.md');
+    const originalContent = '# My Custom README';
+    
+    // Create custom README first
+    require('fs').writeFileSync(readmePath, originalContent);
+    
+    // Try to create welcome file
+    createWelcomeFile(testPath);
+    
+    // Should still have original content
+    const content = readFileSync(readmePath, 'utf-8');
+    expect(content).toBe(originalContent);
+  });
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "cairn-work",
+  "version": "0.2.0",
+  "description": "AI-native project management - work with AI agents using markdown files",
+  "type": "module",
+  "bin": {
+    "cairn": "bin/cairn.js"
+  },
+  "scripts": {
+    "test": "bun test",
+    "dev": "bun link",
+    "build": "echo 'No build step needed'",
+    "prepublishOnly": "bun test"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "skills/",
+    "templates/"
+  ],
+  "keywords": [
+    "project-management",
+    "ai",
+    "agents",
+    "markdown",
+    "task-management",
+    "productivity",
+    "clawdbot",
+    "claude-code",
+    "cursor"
+  ],
+  "author": "Gregory Hill",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gregoryehill/cairn.git"
+  },
+  "homepage": "https://cairn.app",
+  "bugs": {
+    "url": "https://github.com/gregoryehill/cairn/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^11.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.0",
+    "inquirer": "^9.2.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "@types/inquirer": "^9.0.0"
+  }
+}