cokit-cli 1.0.0

package/skills/sequential-thinking/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: sequential-thinking
+description: Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis, revision capability, and hypothesis verification.
+---
+
+# Sequential Thinking
+
+Structured problem-solving via manageable, reflective thought sequences with dynamic adjustment.
+
+## When to Apply
+
+- Complex problem decomposition
+- Adaptive planning with revision capability
+- Analysis needing course correction
+- Problems with unclear/emerging scope
+- Multi-step solutions requiring context maintenance
+- Hypothesis-driven investigation/debugging
+
+## Core Process
+
+### 1. Start with Loose Estimate
+```
+Thought 1/5: [Initial analysis]
+```
+Adjust dynamically as understanding evolves.
+
+### 2. Structure Each Thought
+- Build on previous context explicitly
+- Address one aspect per thought
+- State assumptions, uncertainties, realizations
+- Signal what next thought should address
+
+### 3. Apply Dynamic Adjustment
+- **Expand**: More complexity discovered → increase total
+- **Contract**: Simpler than expected → decrease total
+- **Revise**: New insight invalidates previous → mark revision
+- **Branch**: Multiple approaches → explore alternatives
+
+### 4. Use Revision When Needed
+```
+Thought 5/8 [REVISION of Thought 2]: [Corrected understanding]
+- Original: [What was stated]
+- Why revised: [New insight]
+- Impact: [What changes]
+```
+
+### 5. Branch for Alternatives
+```
+Thought 4/7 [BRANCH A from Thought 2]: [Approach A]
+Thought 4/7 [BRANCH B from Thought 2]: [Approach B]
+```
+Compare explicitly, converge with decision rationale.
+
+### 6. Generate & Verify Hypotheses
+```
+Thought 6/9 [HYPOTHESIS]: [Proposed solution]
+Thought 7/9 [VERIFICATION]: [Test results]
+```
+Iterate until hypothesis verified.
+
+### 7. Complete Only When Ready
+Mark final: `Thought N/N [FINAL]`
+
+Complete when:
+- Solution verified
+- All critical aspects addressed
+- Confidence achieved
+- No outstanding uncertainties
+
+## Application Modes
+
+**Explicit**: Use visible thought markers when complexity warrants visible reasoning or user requests breakdown.
+
+**Implicit**: Apply methodology internally for routine problem-solving where thinking aids accuracy without cluttering response.
+
+## References
+
+Load when deeper understanding needed:
+- `references/core-patterns.md` - Revision & branching patterns
+- `references/advanced-techniques.md` - Spiral refinement, hypothesis testing, convergence

package/skills/sequential-thinking/references/advanced-techniques.md

@@ -0,0 +1,88 @@
+# Advanced Sequential Thinking Techniques
+
+Complex problem-solving patterns.
+
+## Spiral Refinement
+
+Return to concepts with progressively deeper understanding.
+
+```
+Thought 1/7: Initial design (surface)
+Thought 2/7: Discover constraint A
+Thought 3/7: Refine for A
+Thought 4/7: Discover constraint B
+Thought 5/7: Refine for both A and B
+Thought 6/7: Integration reveals edge case
+Thought 7/7: Final design addressing all constraints
+```
+
+**Use for**: Complex systems where constraints emerge iteratively.
+**Key**: Each return is refinement, not restart.
+
+## Hypothesis-Driven Investigation
+
+Systematic hypothesis generation and testing.
+
+```
+Thought 1/6: Observe symptoms
+Thought 2/6 [HYPOTHESIS]: Explanation X
+Thought 3/6 [VERIFICATION]: Test X—partial match
+Thought 4/6 [REFINED HYPOTHESIS]: Adjusted Y
+Thought 5/6 [VERIFICATION]: Test Y—confirmed
+Thought 6/6 [FINAL]: Solution based on verified Y
+```
+
+**Use for**: Debugging, root cause analysis, diagnostics.
+**Pattern**: Generate → Test → Refine → Re-test loop.
+
+## Multi-Branch Convergence
+
+Explore alternatives, then synthesize best approach.
+
+```
+Thought 2/8: Multiple viable approaches
+Thought 3/8 [BRANCH A]: Approach A benefits
+Thought 4/8 [BRANCH A]: Approach A drawbacks
+Thought 5/8 [BRANCH B]: Approach B benefits
+Thought 6/8 [BRANCH B]: Approach B drawbacks
+Thought 7/8 [CONVERGENCE]: Hybrid combining A's X with B's Y
+Thought 8/8 [FINAL]: Hybrid superior to either alone
+```
+
+**Use for**: Complex decisions where neither option clearly best.
+**Key**: Convergence often yields better solution than either branch.
+
+## Progressive Context Deepening
+
+Build understanding in layers from abstract to concrete.
+
+```
+Thought 1/9: High-level problem
+Thought 2/9: Identify major components
+Thought 3/9: Zoom into component A (detailed)
+Thought 4/9: Zoom into component B (detailed)
+Thought 5/9: Identify A-B interactions
+Thought 6/9: Discover emergent constraint
+Thought 7/9 [REVISION of 3-4]: Adjust for interaction
+Thought 8/9: Verify complete system
+Thought 9/9 [FINAL]: Integrated solution
+```
+
+**Use for**: System design, architecture, integration problems.
+**Pattern**: Abstract → Components → Details → Interactions → Integration.
+
+## Uncertainty Management
+
+For high-uncertainty problems:
+- Acknowledge uncertainty explicitly in thought markers
+- Use confidence levels (high/medium/low)
+- Branch when confidence diverges significantly
+- Verify high-impact assumptions early
+
+## Meta-Thinking Calibration
+
+Periodically assess:
+- Are thoughts advancing toward solution?
+- Is scope expanding appropriately?
+- Should approach be revised?
+- Is current depth sufficient?

package/skills/sequential-thinking/references/core-patterns.md

@@ -0,0 +1,87 @@
+# Core Sequential Thinking Patterns
+
+Essential revision and branching patterns.
+
+## Revision Patterns
+
+### Assumption Challenge
+Early assumption proves invalid with new data.
+```
+Thought 1/5: Assume X is bottleneck
+Thought 4/5 [REVISION of Thought 1]: X adequate; Y is actual bottleneck
+```
+
+### Scope Expansion
+Problem larger than initially understood.
+```
+Thought 1/4: Fix bug
+Thought 4/5 [REVISION of scope]: Architectural redesign needed, not patch
+```
+
+### Approach Shift
+Initial strategy inadequate for requirements.
+```
+Thought 2/6: Optimize query
+Thought 5/6 [REVISION of Thought 2]: Optimization + cache layer required
+```
+
+### Understanding Deepening
+Later insight fundamentally changes interpretation.
+```
+Thought 1/5: Feature broken
+Thought 4/5 [REVISION of Thought 1]: Not bug—UX confusion issue
+```
+
+## Branching Patterns
+
+### Trade-off Evaluation
+Compare approaches with different trade-offs.
+```
+Thought 3/7: Choose between X and Y
+Thought 4/7 [BRANCH A]: X—simpler, less scalable
+Thought 4/7 [BRANCH B]: Y—complex, scales better
+Thought 5/7: Choose Y for long-term needs
+```
+
+### Risk Mitigation
+Prepare backup for high-risk primary approach.
+```
+Thought 2/6: Primary: API integration
+Thought 3/6 [BRANCH A]: API details
+Thought 3/6 [BRANCH B]: Fallback: webhook
+Thought 4/6: Implement A with B contingency
+```
+
+### Parallel Exploration
+Investigate independent concerns separately.
+```
+Thought 3/8: Two unknowns—DB schema & API design
+Thought 4/8 [BRANCH DB]: DB options
+Thought 4/8 [BRANCH API]: API patterns
+Thought 5/8: Integrate findings
+```
+
+### Hypothesis Testing
+Test multiple explanations systematically.
+```
+Thought 2/6: Could be A, B, or C
+Thought 3/6 [BRANCH A]: Test A—not cause
+Thought 3/6 [BRANCH B]: Test B—confirmed
+Thought 4/6: Root cause via Branch B
+```
+
+## Adjustment Guidelines
+
+**Expand when**: Complexity discovered, multiple aspects identified, verification needed, alternatives require exploration.
+
+**Contract when**: Key insight solves earlier, problem simpler, steps merge naturally.
+
+## Anti-Patterns
+
+**Premature Completion**: Rushing without verification → Add verification thoughts.
+
+**Revision Cascade**: Repeated revisions without understanding why → Identify root cause.
+
+**Branching Explosion**: Too many branches → Limit to 2-3, converge before more.
+
+**Context Loss**: Ignoring earlier insights → Reference previous thoughts explicitly.

package/src/commands/add.js

@@ -0,0 +1,93 @@
+// add command - Add specific skills
+import { Command } from 'commander';
+import { copyDir, pathExists, listDirs } from '../utils/copy.js';
+import { getSkillsSourceDir, getUserSkillsDir } from '../utils/paths.js';
+import { success, error, info, done, hint, bold, cyan } from '../utils/colors.js';
+import { join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+
+// Validate skill name to prevent path traversal
+function validateSkillName(skill) {
+  if (!skill || !/^[a-zA-Z0-9_-]+$/.test(skill)) {
+    return false;
+  }
+  return true;
+}
+
+export const addCommand = new Command('add')
+  .description('Add a specific skill')
+  .argument('[skill]', 'Skill name to add')
+  .option('-l, --list', 'List available skills')
+  .option('-g, --global', 'Add to ~/.copilot/skills/ (default)')
+  .option('--local', 'Add to .github/skills/ in current project')
+  .option('--overwrite', 'Overwrite existing files')
+  .action(async (skill, options) => {
+    const skillsSrc = getSkillsSourceDir();
+
+    // List available skills
+    if (options.list || !skill) {
+      console.log();
+      console.log(bold(cyan('Available Skills:')));
+      console.log();
+
+      const skills = listDirs(skillsSrc);
+      if (skills.length === 0) {
+        info('No skills available.');
+      } else {
+        skills.forEach(s => {
+          console.log(`  • ${s}`);
+        });
+        console.log();
+        hint('Run: npx cokit add <skill-name>');
+      }
+      return;
+    }
+
+    // Validate skill name (prevent path traversal)
+    if (!validateSkillName(skill)) {
+      error('Invalid skill name. Use only letters, numbers, hyphens, and underscores.');
+      return;
+    }
+
+    // Validate skill exists
+    const skillSrc = join(skillsSrc, skill);
+    if (!pathExists(skillSrc)) {
+      error(`Skill "${skill}" not found.`);
+      hint('Run: npx cokit add --list');
+      return;
+    }
+
+    // Determine destination
+    let skillDest;
+    if (options.local) {
+      skillDest = join(process.cwd(), '.github', 'skills', skill);
+    } else {
+      skillDest = join(getUserSkillsDir(), skill);
+    }
+
+    // Ensure parent directory exists
+    const parentDir = join(skillDest, '..');
+    if (!existsSync(parentDir)) {
+      mkdirSync(parentDir, { recursive: true });
+    }
+
+    try {
+      console.log();
+      info(`Adding skill: ${skill}`);
+
+      await copyDir(skillSrc, skillDest, {
+        overwrite: options.overwrite,
+        prompt: true
+      });
+
+      console.log();
+      done(`Skill "${skill}" added!`);
+      if (options.local) {
+        hint('Skill added to .github/skills/');
+      } else {
+        hint('Skill added to ~/.copilot/skills/');
+      }
+    } catch (err) {
+      error(`Failed to add skill: ${err.message}`);
+    }
+  });

package/src/commands/doctor.js

@@ -0,0 +1,117 @@
+// doctor command - Diagnose setup issues
+import { Command } from 'commander';
+import { pathExists, listDirs, countFiles } from '../utils/copy.js';
+import { getUserSkillsDir, getRepoGithubDir, getRepoVscodeDir } from '../utils/paths.js';
+import { success, error, warn, info, hint, bold, cyan } from '../utils/colors.js';
+import { join } from 'path';
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import { execSync } from 'child_process';
+
+export const doctorCommand = new Command('doctor')
+  .description('Diagnose CoKit setup issues')
+  .action(async () => {
+    console.log();
+    console.log(bold(cyan('Checking CoKit setup...')));
+    console.log();
+
+    let hasIssues = false;
+
+    // Check project-level files
+    console.log(bold('Project Files:'));
+    const githubDir = getRepoGithubDir();
+
+    // Check copilot-instructions.md
+    const instructionsFile = join(githubDir, 'copilot-instructions.md');
+    if (pathExists(instructionsFile)) {
+      success('.github/copilot-instructions.md exists');
+    } else {
+      error('.github/copilot-instructions.md not found');
+      hint('Run: npx cokit init');
+      hasIssues = true;
+    }
+
+    // Check prompts directory
+    const promptsDir = join(githubDir, 'prompts');
+    if (pathExists(promptsDir)) {
+      const promptFiles = readdirSync(promptsDir).filter(f => f.endsWith('.prompt.md'));
+      if (promptFiles.length >= 6) {
+        success(`.github/prompts/ has ${promptFiles.length} prompts`);
+      } else {
+        warn(`.github/prompts/ has ${promptFiles.length} prompts (expected 6)`);
+        hasIssues = true;
+      }
+    } else {
+      error('.github/prompts/ not found');
+      hint('Run: npx cokit init');
+      hasIssues = true;
+    }
+
+    console.log();
+
+    // Check global skills
+    console.log(bold('Personal Skills:'));
+    const globalSkillsDir = getUserSkillsDir();
+
+    if (pathExists(globalSkillsDir)) {
+      const skills = listDirs(globalSkillsDir);
+      if (skills.length >= 5) {
+        success(`~/.copilot/skills/ has ${skills.length} skills`);
+      } else if (skills.length > 0) {
+        warn(`~/.copilot/skills/ has ${skills.length} skills (expected 5)`);
+      } else {
+        error('~/.copilot/skills/ is empty');
+        hint('Run: npx cokit init --global');
+        hasIssues = true;
+      }
+    } else {
+      error('~/.copilot/skills/ not found');
+      hint('Run: npx cokit init --global');
+      hasIssues = true;
+    }
+
+    console.log();
+
+    // Check VS Code
+    console.log(bold('Environment:'));
+
+    // Check if VS Code is installed
+    try {
+      execSync('code --version', { stdio: 'pipe' });
+      success('VS Code detected');
+    } catch {
+      warn('VS Code not detected in PATH');
+      hint('Install VS Code or add to PATH');
+    }
+
+    // Check .vscode/settings.json
+    const vscodeSettings = join(getRepoVscodeDir(), 'settings.json');
+    if (pathExists(vscodeSettings)) {
+      success('.vscode/settings.json exists');
+
+      // Check for Copilot settings
+      try {
+        const settings = JSON.parse(readFileSync(vscodeSettings, 'utf-8'));
+        if (settings['github.copilot.chat.useAgentSkills'] === true) {
+          success('Agent Skills enabled in settings');
+        } else {
+          warn('Agent Skills not enabled in settings');
+          hint('Add: "github.copilot.chat.useAgentSkills": true');
+          hasIssues = true;
+        }
+      } catch {
+        // Can't parse settings, skip
+      }
+    } else {
+      info('.vscode/settings.json not found (optional)');
+    }
+
+    console.log();
+
+    // Summary
+    if (hasIssues) {
+      console.log(bold('Found issues. Run suggested commands to fix.'));
+    } else {
+      console.log(bold(cyan('✓ Everything looks good!')));
+    }
+    console.log();
+  });

package/src/commands/init.js

@@ -0,0 +1,152 @@
+// init command - Setup CoKit in project or globally
+import { Command } from 'commander';
+import prompts from 'prompts';
+import { copyDir, pathExists } from '../utils/copy.js';
+import { getTemplatesDir, getSkillsSourceDir, getUserSkillsDir, getRepoGithubDir, getRepoVscodeDir } from '../utils/paths.js';
+import { success, error, done, info, hint, bold, cyan } from '../utils/colors.js';
+import { join } from 'path';
+import { mkdirSync, existsSync } from 'fs';
+
+export const initCommand = new Command('init')
+  .description('Set up CoKit in your project or globally')
+  .option('-g, --global', 'Install personal skills to ~/.copilot/')
+  .option('-a, --all', 'Install both project templates and personal skills')
+  .option('-y, --yes', 'Skip confirmation prompts')
+  .option('--overwrite', 'Overwrite existing files without prompting')
+  .action(async (options) => {
+    console.log();
+    console.log(bold(cyan('🚀 CoKit Setup')));
+    console.log();
+
+    try {
+      // Determine what to install
+      let installProject = false;
+      let installGlobal = false;
+
+      if (options.all) {
+        installProject = true;
+        installGlobal = true;
+      } else if (options.global) {
+        installGlobal = true;
+      } else if (!options.global && !options.all) {
+        // Interactive mode - ask user
+        const response = await prompts({
+          type: 'select',
+          name: 'mode',
+          message: 'What do you want to set up?',
+          choices: [
+            { title: 'Project templates (.github/)', value: 'project', description: 'For this project only - share via git' },
+            { title: 'Personal skills (~/.copilot/)', value: 'global', description: 'Works in all projects' },
+            { title: 'Both', value: 'both', description: 'Recommended for first-time setup' }
+          ],
+          initial: 0
+        });
+
+        if (!response.mode) {
+          console.log('Setup cancelled.');
+          return;
+        }
+
+        installProject = response.mode === 'project' || response.mode === 'both';
+        installGlobal = response.mode === 'global' || response.mode === 'both';
+      }
+
+      // Confirm before proceeding
+      if (!options.yes) {
+        const targets = [];
+        if (installProject) targets.push('.github/');
+        if (installGlobal) targets.push('~/.copilot/skills/');
+
+        const confirm = await prompts({
+          type: 'confirm',
+          name: 'proceed',
+          message: `This will create files in ${targets.join(' and ')}. Continue?`,
+          initial: true
+        });
+
+        if (!confirm.proceed) {
+          console.log('Setup cancelled.');
+          return;
+        }
+      }
+
+      console.log();
+
+      // Install project templates
+      if (installProject) {
+        info('Setting up project templates...');
+        await installProjectTemplates(options);
+        console.log();
+      }
+
+      // Install global skills
+      if (installGlobal) {
+        info('Setting up personal skills...');
+        await installGlobalSkills(options);
+        console.log();
+      }
+
+      // Success message
+      done('Done! Open VS Code and start using Copilot.');
+      hint('Try typing /fix in Copilot Chat.');
+      console.log();
+
+    } catch (err) {
+      error(`Setup failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+async function installProjectTemplates(options) {
+  const templatesDir = getTemplatesDir();
+  const cwd = process.cwd();
+
+  // Check if templates exist
+  if (!pathExists(templatesDir)) {
+    error('Templates not found. Package may be corrupted.');
+    return;
+  }
+
+  // Copy .github directory
+  const githubSrc = join(templatesDir, '.github');
+  const githubDest = getRepoGithubDir(cwd);
+
+  if (pathExists(githubSrc)) {
+    await copyDir(githubSrc, githubDest, {
+      overwrite: options.overwrite,
+      prompt: !options.yes
+    });
+  }
+
+  // Copy .vscode directory
+  const vscodeSrc = join(templatesDir, '.vscode');
+  const vscodeDest = getRepoVscodeDir(cwd);
+
+  if (pathExists(vscodeSrc)) {
+    await copyDir(vscodeSrc, vscodeDest, {
+      overwrite: options.overwrite,
+      prompt: !options.yes
+    });
+  }
+}
+
+async function installGlobalSkills(options) {
+  const skillsSrc = getSkillsSourceDir();
+  const skillsDest = getUserSkillsDir();
+
+  // Check if skills source exists
+  if (!pathExists(skillsSrc)) {
+    error('Skills not found. Package may be corrupted.');
+    return;
+  }
+
+  // Ensure ~/.copilot/skills/ directory exists
+  if (!existsSync(skillsDest)) {
+    mkdirSync(skillsDest, { recursive: true });
+  }
+
+  await copyDir(skillsSrc, skillsDest, {
+    overwrite: options.overwrite,
+    prompt: !options.yes
+  });
+}