@nolrm/contextkit 0.7.3

package/lib/commands/note.js

@@ -0,0 +1,120 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+
+class NoteCommand {
+  constructor() {
+    this.correctionsPath = '.contextkit/corrections.md';
+  }
+
+  async run(message, options = {}) {
+    if (!message) {
+      console.log(chalk.red('❌ Please provide a message'));
+      console.log(chalk.yellow('Usage: contextkit note "<message>"'));
+      return;
+    }
+
+    if (!await fs.pathExists(this.correctionsPath)) {
+      console.log(chalk.red('❌ Corrections log not found'));
+      console.log(chalk.yellow('   Run: contextkit install'));
+      return;
+    }
+
+    try {
+      const content = await fs.readFile(this.correctionsPath, 'utf-8');
+      const today = new Date().toISOString().split('T')[0];
+      
+      // Find or create today's session
+      const sessionHeader = `### ${today} - ${options.task || 'Development Session'}`;
+      
+      let updatedContent = content;
+      
+      // Check if today's session exists
+      if (content.includes(sessionHeader)) {
+        // Add to existing session
+        const category = options.category || 'AI Behavior';
+        const priority = options.priority || 'MEDIUM';
+        const note = `- ${category} | ${message} [${priority}]`;
+        
+        // Find the session and add note to appropriate section
+        const sections = ['Rule Updates', 'AI Behavior', 'Preferences', 'Trend Indicators'];
+        let sectionFound = false;
+        
+        for (const section of sections) {
+          if (category.toLowerCase().includes(section.toLowerCase().substring(0, 5))) {
+            const sectionHeader = `#### ${section}`;
+            const sectionRegex = new RegExp(`(${sectionHeader}[\\s\\S]*?)(?=####|###|##|$)`, 'm');
+            const match = content.match(sectionRegex);
+            
+            if (match) {
+              updatedContent = content.replace(
+                sectionRegex,
+                `$1\n${note}`
+              );
+              sectionFound = true;
+              break;
+            }
+          }
+        }
+        
+        if (!sectionFound) {
+          // Add to AI Behavior section as default
+          const aiBehaviorRegex = /(#### AI Behavior[\s\S]*?)(?=####|###|##|$)/m;
+          if (content.match(aiBehaviorRegex)) {
+            updatedContent = content.replace(
+              aiBehaviorRegex,
+              `$1\n${note}`
+            );
+          }
+        }
+      } else {
+        // Create new session
+        const newSession = `
+${sessionHeader}
+
+**Changes**: ${options.changes || 'Development work'}
+
+#### Rule Updates
+
+- [No updates yet]
+
+#### AI Behavior
+
+- ${options.category || 'AI Behavior'} | ${message} [${options.priority || 'MEDIUM'}]
+
+#### Preferences
+
+- [No preferences yet]
+
+#### Trend Indicators
+
+- [No trends yet]
+
+`;
+        
+        // Insert after "## Recent Sessions"
+        const sessionsRegex = /(## Recent Sessions\n)/;
+        if (content.match(sessionsRegex)) {
+          updatedContent = content.replace(sessionsRegex, `$1${newSession}`);
+        } else {
+          // Fallback: add at the beginning
+          updatedContent = `## Recent Sessions${newSession}\n${content}`;
+        }
+      }
+      
+      await fs.writeFile(this.correctionsPath, updatedContent);
+      console.log(chalk.green('✅ Note added to corrections log'));
+      console.log(chalk.dim(`   ${message}`));
+    } catch (error) {
+      console.log(chalk.red('❌ Failed to add note:'), error.message);
+    }
+  }
+}
+
+async function note(message, options) {
+  const cmd = new NoteCommand();
+  await cmd.run(message, options);
+}
+
+module.exports = note;
+

package/lib/commands/publish.js

@@ -0,0 +1,184 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const { execSync } = require('child_process');
+
+class PublishCommand {
+  constructor() {
+    this.registryPath = path.join(process.env.HOME || process.env.USERPROFILE, '.contextkit-registry');
+  }
+
+  async run(options = {}) {
+    console.log(chalk.magenta('📦 Publishing ContextKit Configuration\n'));
+
+    // Check if .contextkit exists
+    if (!await fs.pathExists('.contextkit/config.yml')) {
+      console.log(chalk.red('❌ ContextKit not installed in this directory'));
+      console.log(chalk.yellow('   Run: contextkit install'));
+      return;
+    }
+
+    // Get package name and version
+    const name = options.name || await this.promptName();
+    const version = options.version || await this.promptVersion();
+    
+    if (!name || !version) {
+      console.log(chalk.red('❌ Package name and version are required'));
+      return;
+    }
+
+    // Validate version format
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+      console.log(chalk.red('❌ Invalid version format. Use semantic versioning (e.g., 1.0.0)'));
+      return;
+    }
+
+    // Create registry structure
+    await this.ensureRegistry();
+
+    // Create package directory
+    const packageDir = path.join(this.registryPath, name.replace('@', '').replace('/', '-'), version);
+    await fs.ensureDir(packageDir);
+
+    // Copy .contextkit files (exclude some)
+    const excludePatterns = [
+      'corrections.md',
+      'status.json',
+      'node_modules',
+      '.git'
+    ];
+
+    await this.copyVibeKitFiles('.contextkit', packageDir, excludePatterns);
+
+    // Create package.json for the published package
+    const config = await this.loadConfig();
+    const packageJson = {
+      name: name,
+      version: version,
+      description: `ContextKit configuration for ${config.project_name || 'project'}`,
+      vibeKit: {
+        vk: config.vk || 1,
+        profile: config.profile,
+        generated_at: new Date().toISOString(),
+        published_at: new Date().toISOString()
+      },
+      files: [
+        '**/*.md',
+        '**/*.yml',
+        '**/*.yaml',
+        '**/*.ts',
+        '**/*.tsx',
+        '**/*.sh'
+      ]
+    };
+
+    await fs.writeJson(path.join(packageDir, 'package.json'), packageJson, { spaces: 2 });
+
+    // Create README
+    const readme = `# ${name} v${version}
+
+ContextKit configuration package.
+
+## Installation
+
+\`\`\`bash
+contextkit pull ${name}@${version}
+\`\`\`
+
+## Contents
+
+This package includes:
+- Standards files
+- Templates
+- Commands
+- Product context
+- Policies
+
+## Version
+
+${version} - Published ${new Date().toISOString().split('T')[0]}
+`;
+
+    await fs.writeFile(path.join(packageDir, 'README.md'), readme);
+
+    console.log(chalk.green(`\n✅ Published ${name}@${version}`));
+    console.log(chalk.dim(`   Location: ${packageDir}`));
+    console.log(chalk.blue(`\n💡 To use: contextkit pull ${name}@${version}`));
+  }
+
+  async promptName() {
+    const readline = require('readline').createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+      readline.question(chalk.yellow('Package name (e.g., @company/react-standards): '), (name) => {
+        readline.close();
+        resolve(name.trim() || null);
+      });
+    });
+  }
+
+  async promptVersion() {
+    const readline = require('readline').createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+      readline.question(chalk.yellow('Version (e.g., 1.0.0): '), (version) => {
+        readline.close();
+        resolve(version.trim() || null);
+      });
+    });
+  }
+
+  async ensureRegistry() {
+    await fs.ensureDir(this.registryPath);
+    console.log(chalk.dim(`Registry location: ${this.registryPath}`));
+  }
+
+  async copyVibeKitFiles(sourceDir, targetDir, excludePatterns) {
+    const files = await fs.readdir(sourceDir, { withFileTypes: true });
+
+    for (const file of files) {
+      const sourcePath = path.join(sourceDir, file.name);
+      const targetPath = path.join(targetDir, file.name);
+
+      // Check if should exclude
+      const shouldExclude = excludePatterns.some(pattern => 
+        file.name.includes(pattern) || sourcePath.includes(pattern)
+      );
+
+      if (shouldExclude) {
+        continue;
+      }
+
+      if (file.isDirectory()) {
+        await fs.ensureDir(targetPath);
+        await this.copyVibeKitFiles(sourcePath, targetPath, excludePatterns);
+      } else {
+        await fs.copy(sourcePath, targetPath);
+      }
+    }
+  }
+
+  async loadConfig() {
+    try {
+      const configContent = await fs.readFile('.contextkit/config.yml', 'utf-8');
+      return yaml.load(configContent);
+    } catch (error) {
+      return {};
+    }
+  }
+}
+
+async function publish(options) {
+  const cmd = new PublishCommand();
+  await cmd.run(options);
+}
+
+module.exports = publish;
+

package/lib/commands/pull.js

@@ -0,0 +1,191 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+
+class PullCommand {
+  constructor() {
+    this.registryPath = path.join(process.env.HOME || process.env.USERPROFILE, '.contextkit-registry');
+  }
+
+  async run(packageSpec, options = {}) {
+    console.log(chalk.magenta(`📥 Pulling ContextKit Configuration: ${packageSpec}\n`));
+
+    // Parse package spec (name@version or just name)
+    const [packageName, version] = packageSpec.includes('@') 
+      ? packageSpec.split('@')
+      : [packageSpec, 'latest'];
+
+    // Find package
+    const packageDir = await this.findPackage(packageName, version);
+    
+    if (!packageDir) {
+      console.log(chalk.red(`❌ Package not found: ${packageSpec}`));
+      console.log(chalk.yellow('\n💡 Available packages:'));
+      await this.listPackages();
+      return;
+    }
+
+    // Check if .contextkit exists
+    const backupDir = options.backup ? `.contextkit.backup.${Date.now()}` : null;
+    
+    if (await fs.pathExists('.contextkit') && !options.force) {
+      if (backupDir) {
+        await fs.copy('.contextkit', backupDir);
+        console.log(chalk.green(`✅ Backed up existing .contextkit to ${backupDir}`));
+      } else {
+        const { confirm } = await this.promptOverwrite();
+        if (!confirm) {
+          console.log(chalk.yellow('⏭️  Cancelled'));
+          return;
+        }
+      }
+    }
+
+    // Copy package files
+    await this.copyPackageFiles(packageDir, '.contextkit', options);
+
+    // Update config.yml with package info
+    await this.updateConfig(packageName, version);
+
+    console.log(chalk.green(`\n✅ Pulled ${packageSpec} successfully!`));
+    
+    if (backupDir) {
+      console.log(chalk.dim(`   Backup: ${backupDir}`));
+    }
+  }
+
+  async findPackage(packageName, version) {
+    const packagePath = path.join(this.registryPath, packageName.replace('@', '').replace('/', '-'));
+    
+    if (!await fs.pathExists(packagePath)) {
+      return null;
+    }
+
+    if (version === 'latest') {
+      // Find latest version
+      const versions = await fs.readdir(packagePath);
+      const sortedVersions = versions
+        .filter(v => /^\d+\.\d+\.\d+$/.test(v))
+        .sort((a, b) => {
+          const aParts = a.split('.').map(Number);
+          const bParts = b.split('.').map(Number);
+          for (let i = 0; i < 3; i++) {
+            if (aParts[i] !== bParts[i]) {
+              return bParts[i] - aParts[i];
+            }
+          }
+          return 0;
+        });
+      
+      if (sortedVersions.length > 0) {
+        return path.join(packagePath, sortedVersions[0]);
+      }
+    } else {
+      const versionPath = path.join(packagePath, version);
+      if (await fs.pathExists(versionPath)) {
+        return versionPath;
+      }
+    }
+
+    return null;
+  }
+
+  async listPackages() {
+    if (!await fs.pathExists(this.registryPath)) {
+      console.log(chalk.dim('   (No packages in registry)'));
+      return;
+    }
+
+    const packages = await fs.readdir(this.registryPath, { withFileTypes: true });
+    
+    for (const pkg of packages.filter(p => p.isDirectory())) {
+      const packagePath = path.join(this.registryPath, pkg.name);
+      const versions = await fs.readdir(packagePath);
+      const validVersions = versions.filter(v => /^\d+\.\d+\.\d+$/.test(v));
+      
+      if (validVersions.length > 0) {
+        const latest = validVersions.sort().reverse()[0];
+        console.log(chalk.cyan(`   ${pkg.name.replace('-', '/')}@${latest}`));
+      }
+    }
+  }
+
+  async promptOverwrite() {
+    const readline = require('readline').createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+      readline.question(chalk.yellow('⚠️  .contextkit already exists. Overwrite? (y/N): '), (answer) => {
+        readline.close();
+        resolve({ confirm: answer.toLowerCase() === 'y' });
+      });
+    });
+  }
+
+  async copyPackageFiles(sourceDir, targetDir, options) {
+    // Read package.json if exists
+    const packageJsonPath = path.join(sourceDir, 'package.json');
+    let packageJson = {};
+    
+    if (await fs.pathExists(packageJsonPath)) {
+      packageJson = await fs.readJson(packageJsonPath);
+    }
+
+    // Copy all files from package
+    const files = await fs.readdir(sourceDir, { withFileTypes: true });
+
+    for (const file of files) {
+      const sourcePath = path.join(sourceDir, file.name);
+      const targetPath = path.join(targetDir, file.name);
+
+      // Skip package.json and README.md
+      if (file.name === 'package.json' || file.name === 'README.md') {
+        continue;
+      }
+
+      if (file.isDirectory()) {
+        await fs.ensureDir(targetPath);
+        await this.copyPackageFiles(sourcePath, targetPath, options);
+      } else {
+        await fs.copy(sourcePath, targetPath);
+      }
+    }
+  }
+
+  async updateConfig(packageName, version) {
+    const configPath = '.contextkit/config.yml';
+    
+    if (!await fs.pathExists(configPath)) {
+      return;
+    }
+
+    try {
+      const configContent = await fs.readFile(configPath, 'utf-8');
+      const config = yaml.load(configContent);
+      
+      // Add package info
+      if (!config.metadata) {
+        config.metadata = {};
+      }
+      
+      config.metadata.pulled_from = packageName;
+      config.metadata.pulled_version = version;
+      config.metadata.pulled_at = new Date().toISOString();
+
+      await fs.writeFile(configPath, yaml.dump(config, { lineWidth: 120 }));
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Could not update config.yml: ${error.message}`));
+    }
+  }
+}
+
+async function pull(packageSpec, options) {
+  const cmd = new PullCommand();
+  await cmd.run(packageSpec, options);
+}
+
+module.exports = pull;
+