vibesuite 1.0.0

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "vibesuite",
+  "version": "1.0.0",
+  "description": "A Complete System for AI-Human Software Development Collaboration",
+  "type": "module",
+  "bin": {
+    "vibesuite": "./bin/vibesuite.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    ".agent",
+    "VibeCode-Agents (e.g Kilo-code)",
+    "Legacy (Manual Method)"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JStaRFilms/VibeCode-Protocol-Suite.git"
+  },
+  "keywords": [
+    "ai",
+    "vibecode",
+    "cursor",
+    "windsurf",
+    "protocols"
+  ],
+  "author": "J StaR Films Studios",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^13.1.0",
+    "figlet": "^1.8.0",
+    "fs-extra": "^11.3.0",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2"
+  },
+  "bugs": {
+    "url": "https://github.com/JStaRFilms/VibeCode-Protocol-Suite/issues"
+  },
+  "homepage": "https://github.com/JStaRFilms/VibeCode-Protocol-Suite#readme"
+}

package/src/cli.js

@@ -0,0 +1,159 @@
+import { Command } from 'commander';
+import prompts from 'prompts';
+import pc from 'picocolors';
+import figlet from 'figlet';
+import fs from 'fs-extra';
+import path from 'path';
+import { PATHS, getWorkflows, getSkills, copyToDestination, copySpecificWorkflows, copySpecificSkills } from './utils.js';
+
+const program = new Command();
+
+async function init() {
+  console.log(pc.magenta(figlet.textSync('VibeSuite', { horizontalLayout: 'full' })));
+  console.log(pc.cyan('   J StaR Films Studios VibeCode Protocol Suite\n'));
+
+  const response = await prompts([
+    {
+      type: 'multiselect',
+      name: 'components',
+      message: 'What components do you want to spawn?',
+      choices: [
+        { title: '.agent Folder (Workflows & Skills)', value: 'agent', selected: true, description: 'Recommended for Cursor/Windsurf' },
+        { title: 'Agent YAMLs', value: 'yamls', description: 'For Kilo Code / Deep Source' },
+        { title: 'Legacy Manual Protocols', value: 'legacy', description: 'Browser-based prompts' }
+      ],
+      min: 1,
+      hint: '- Space to select. Return to submit'
+    },
+    // Workflow Selection (Only if .agent is selected)
+    {
+      type: (prev, values) => values.components.includes('agent') ? 'select' : null,
+      name: 'workflowMode',
+      message: 'How should we install Workflows?',
+      choices: [
+        { title: 'Install All Workflows', value: 'all' },
+        { title: 'Install All (Exclude Legacy)', value: 'no-legacy' },
+        { title: 'Select Specific Workflows', value: 'custom' }
+      ]
+    },
+    {
+      type: (prev, values) => values.workflowMode === 'custom' ? 'multiselect' : null,
+      name: 'selectedWorkflows',
+      message: 'Select workflows to install:',
+      choices: async () => {
+        const workflows = await getWorkflows();
+        return workflows.map(w => ({ title: w, value: w }));
+      },
+      hint: '- Space to select. Return to submit'
+    },
+    // Skill Selection (Only if .agent is selected)
+    {
+      type: (prev, values) => values.components.includes('agent') ? 'select' : null,
+      name: 'skillMode',
+      message: 'How should we install Skills?',
+      choices: [
+        { title: 'Install All Skills', value: 'all' },
+        { title: 'Select Specific Skills', value: 'custom' }
+      ]
+    },
+    {
+      type: (prev, values) => values.skillMode === 'custom' ? 'multiselect' : null,
+      name: 'selectedSkills',
+      message: 'Select skills to install:',
+      choices: async () => {
+        const skills = await getSkills();
+        return skills.map(s => ({ title: s, value: s }));
+      },
+      hint: '- Space to select. Return to submit'
+    },
+    // Destination
+    {
+      type: 'text',
+      name: 'path',
+      message: 'Where should we spawn these files?',
+      initial: './'
+    }
+  ]);
+
+  if (!response.components) return; // User cancelled
+
+  const destRoot = path.resolve(process.cwd(), response.path);
+  console.log(pc.dim(`\nSpawning resources into: ${destRoot}...\n`));
+
+  try {
+    // 1. Handle .agent Folder
+    if (response.components.includes('agent')) {
+      const agentDest = path.join(destRoot, '.agent');
+      const workflowsDest = path.join(agentDest, 'workflows');
+      const skillsDest = path.join(agentDest, 'skills');
+
+      await fs.ensureDir(agentDest);
+      
+      // Handle Workflows
+      if (response.workflowMode === 'all') {
+        console.log(pc.green('✔ Copying all workflows...'));
+        await fs.copy(PATHS.workflows, workflowsDest);
+      } else if (response.workflowMode === 'no-legacy') {
+        console.log(pc.green('✔ Copying workflows (skipping legacy)...'));
+        await fs.copy(PATHS.workflows, workflowsDest);
+        // Remove LEGACY folder if it exists in the copy
+        const legacyPath = path.join(workflowsDest, 'LEGACY');
+        if (await fs.pathExists(legacyPath)) {
+            await fs.remove(legacyPath);
+        }
+      } else if (response.workflowMode === 'custom' && response.selectedWorkflows) {
+        console.log(pc.green(`✔ Copying ${response.selectedWorkflows.length} specific workflows...`));
+        await copySpecificWorkflows(response.selectedWorkflows, workflowsDest);
+      }
+
+      // Handle Skills
+      if (response.skillMode === 'all') {
+        console.log(pc.green('✔ Copying all skills...'));
+        await fs.copy(PATHS.skills, skillsDest);
+      } else if (response.skillMode === 'custom' && response.selectedSkills) {
+        console.log(pc.green(`✔ Copying ${response.selectedSkills.length} specific skills...`));
+        await copySpecificSkills(response.selectedSkills, skillsDest);
+      }
+      
+      // Copy .agent/README.md if it exists
+      const readmeSrc = path.join(PATHS.agent, 'README.md');
+      if (await fs.pathExists(readmeSrc)) {
+         await fs.copy(readmeSrc, path.join(agentDest, 'README.md'));
+      }
+    }
+
+    // 2. Handle Agent YAMLs
+    if (response.components.includes('yamls')) {
+      console.log(pc.green('✔ Copying Agent YAMLs...'));
+      const yamlDest = path.join(destRoot, 'VibeCode-Agents');
+      await fs.copy(PATHS.agentsYaml, yamlDest);
+    }
+
+    // 3. Handle Legacy Manual
+    if (response.components.includes('legacy')) {
+      console.log(pc.green('✔ Copying Legacy Protocols...'));
+      const legacyDest = path.join(destRoot, 'Legacy-Protocols');
+      await fs.copy(PATHS.manual, legacyDest);
+    }
+
+    console.log(pc.magenta('\n✨ VibeCode Protocol Suite spawned successfully! ✨'));
+    console.log(pc.white(`\nNext steps:`));
+    if (response.components.includes('agent')) {
+        console.log(pc.gray(`1. If using Cursor/Windsurf, the .agent folder is ready.`));
+        console.log(pc.gray(`2. Try typing '/init_vibecode_genesis' in your IDE.`));
+    }
+    
+  } catch (error) {
+    console.error(pc.red('Error during installation:'), error);
+  }
+}
+
+program
+  .name('vibesuite')
+  .description('VibeCode Protocol Suite CLI')
+  .version('1.0.0')
+  .command('init')
+  .description('Initialize VibeCode in the current directory')
+  .action(init);
+
+program.parse();

package/src/utils.js

@@ -0,0 +1,76 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Root of the package (up one level from src/)
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+export const PATHS = {
+  root: PACKAGE_ROOT,
+  agent: path.join(PACKAGE_ROOT, '.agent'),
+  workflows: path.join(PACKAGE_ROOT, '.agent', 'workflows'),
+  skills: path.join(PACKAGE_ROOT, '.agent', 'skills'),
+  agentsYaml: path.join(PACKAGE_ROOT, 'VibeCode-Agents (e.g Kilo-code)'),
+  manual: path.join(PACKAGE_ROOT, 'Legacy (Manual Method)'),
+};
+
+export async function getWorkflows() {
+  try {
+    const files = await fs.readdir(PATHS.workflows);
+    // filter out directories if any, keep .md files
+    return files.filter(f => f.endsWith('.md'));
+  } catch (error) {
+    return [];
+  }
+}
+
+export async function getSkills() {
+  try {
+    const files = await fs.readdir(PATHS.skills);
+    // skills are directories
+    const skills = [];
+    for (const file of files) {
+      const stats = await fs.stat(path.join(PATHS.skills, file));
+      if (stats.isDirectory()) {
+        skills.push(file);
+      }
+    }
+    return skills;
+  } catch (error) {
+    return [];
+  }
+}
+
+export async function copyToDestination(source, dest) {
+  try {
+    await fs.copy(source, dest, { overwrite: true });
+    return true;
+  } catch (error) {
+    console.error(`Error copying ${source} to ${dest}:`, error);
+    return false;
+  }
+}
+
+export async function copySpecificWorkflows(selectedWorkflows, destFolder) {
+  // Ensure dest folder exists
+  await fs.ensureDir(destFolder);
+  
+  for (const workflow of selectedWorkflows) {
+    const src = path.join(PATHS.workflows, workflow);
+    const dest = path.join(destFolder, workflow);
+    await fs.copy(src, dest, { overwrite: true });
+  }
+}
+
+export async function copySpecificSkills(selectedSkills, destFolder) {
+  // Ensure dest folder exists
+  await fs.ensureDir(destFolder);
+
+  for (const skill of selectedSkills) {
+    const src = path.join(PATHS.skills, skill);
+    const dest = path.join(destFolder, skill);
+    await fs.copy(src, dest, { overwrite: true });
+  }
+}