Sequential Thinking

# Sequential Thinking Configuration

# Disable thought logging output (useful for automated processing)
# Set to "true" to disable console logging
DISABLE_THOUGHT_LOGGING=false

# History file location (optional, defaults to scripts/.thought-history.json)
# THOUGHT_HISTORY_FILE=/path/to/custom/history.json

# Dependencies
node_modules/
package-lock.json

# Environment
.env

# Thought history (generated during use)
scripts/.thought-history.json

# Test coverage
coverage/

# Logs
*.log

{
  "name": "sequential-thinking-skill",
  "version": "1.0.0",
  "description": "Sequential thinking methodology with thought processing scripts",
  "main": "scripts/process-thought.js",
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage"
  },
  "keywords": [
    "sequential-thinking",
    "problem-solving",
    "agent-skill"
  ],
  "author": "Converted from Anthropic MCP Server",
  "license": "MIT",
  "devDependencies": {
    "jest": "^29.7.0"
  },
  "jest": {
    "testEnvironment": "node",
    "testMatch": [
      "**/tests/**/*.test.js"
    ],
    "coveragePathIgnorePatterns": [
      "/node_modules/",
      "/tests/"
    ]
  }
}

#!/usr/bin/env node

/**
 * Sequential Thinking Thought Formatter
 *
 * Formats thoughts for display with visual indicators for type (regular/revision/branch).
 * Provides consistent, readable output for thought sequences.
 *
 * Usage:
 *   node format-thought.js --thought "Analysis" --number 1 --total 5
 *   node format-thought.js --thought "Revision" --number 2 --total 5 --revision 1
 *   node format-thought.js --thought "Branch A" --number 3 --total 5 --branch 2 --branchId "a"
 */

class ThoughtFormatter {
  static format(thoughtData) {
    const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId } = thoughtData;

    let prefix = '';
    let context = '';
    let emoji = '';

    if (isRevision && revisesThought) {
      emoji = '🔄';
      prefix = 'REVISION';
      context = ` (revising thought ${revisesThought})`;
    } else if (branchFromThought) {
      emoji = '🌿';
      prefix = 'BRANCH';
      context = branchId ? ` (from thought ${branchFromThought}, ID: ${branchId})` : ` (from thought ${branchFromThought})`;
    } else {
      emoji = '💭';
      prefix = 'Thought';
      context = '';
    }

    const header = `${emoji} ${prefix} ${thoughtNumber}/${totalThoughts}${context}`;
    const maxLength = Math.max(header.length, thought.length);
    const border = '─'.repeat(maxLength + 4);

    // Wrap long thoughts
    const wrappedThought = this.wrapText(thought, maxLength);
    const thoughtLines = wrappedThought.map(line => `│ ${line.padEnd(maxLength + 2)} │`).join('\n');

    return `
┌${border}┐
│ ${header.padEnd(maxLength + 2)} │
├${border}┤
${thoughtLines}
└${border}┘`;
  }

  static wrapText(text, maxWidth) {
    if (text.length <= maxWidth) {
      return [text];
    }

    const words = text.split(' ');
    const lines = [];
    let currentLine = '';

    for (const word of words) {
      if ((currentLine + ' ' + word).trim().length <= maxWidth) {
        currentLine = currentLine ? currentLine + ' ' + word : word;
      } else {
        if (currentLine) lines.push(currentLine);
        currentLine = word;
      }
    }

    if (currentLine) lines.push(currentLine);
    return lines;
  }

  static formatSimple(thoughtData) {
    const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId } = thoughtData;

    let marker = '';
    if (isRevision && revisesThought) {
      marker = ` [REVISION of Thought ${revisesThought}]`;
    } else if (branchFromThought) {
      marker = branchId ? ` [BRANCH ${branchId.toUpperCase()} from Thought ${branchFromThought}]` : ` [BRANCH from Thought ${branchFromThought}]`;
    }

    return `Thought ${thoughtNumber}/${totalThoughts}${marker}: ${thought}`;
  }

  static formatMarkdown(thoughtData) {
    const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId } = thoughtData;

    let marker = '';
    if (isRevision && revisesThought) {
      marker = ` **[REVISION of Thought ${revisesThought}]**`;
    } else if (branchFromThought) {
      marker = branchId ? ` **[BRANCH ${branchId.toUpperCase()} from Thought ${branchFromThought}]**` : ` **[BRANCH from Thought ${branchFromThought}]**`;
    }

    return `**Thought ${thoughtNumber}/${totalThoughts}**${marker}\n\n${thought}\n`;
  }
}

// CLI Interface
if (require.main === module) {
  const args = process.argv.slice(2);

  const parseArgs = (args) => {
    const parsed = {};
    for (let i = 0; i < args.length; i++) {
      const arg = args[i];
      if (arg.startsWith('--')) {
        const key = arg.slice(2);
        const value = args[i + 1];

        if (value && !value.startsWith('--')) {
          // Parse boolean
          if (value === 'true') parsed[key] = true;
          else if (value === 'false') parsed[key] = false;
          // Parse number
          else if (!isNaN(value)) parsed[key] = parseFloat(value);
          // String
          else parsed[key] = value;
          i++;
        }
      }
    }
    return parsed;
  };

  const input = parseArgs(args);

  const thoughtData = {
    thought: input.thought || 'No thought provided',
    thoughtNumber: input.number || 1,
    totalThoughts: input.total || 1,
    isRevision: input.revision !== undefined,
    revisesThought: input.revision,
    branchFromThought: input.branch,
    branchId: input.branchId
  };

  const format = input.format || 'box';

  let output;
  switch (format) {
    case 'simple':
      output = ThoughtFormatter.formatSimple(thoughtData);
      break;
    case 'markdown':
      output = ThoughtFormatter.formatMarkdown(thoughtData);
      break;
    case 'box':
    default:
      output = ThoughtFormatter.format(thoughtData);
  }

  console.log(output);
}

module.exports = { ThoughtFormatter };

#!/usr/bin/env node

/**
 * Sequential Thinking Thought Processor
 *
 * Validates and tracks sequential thoughts with revision and branching support.
 * Provides deterministic validation and context management.
 *
 * Usage:
 *   node process-thought.js --thought "Analysis text" --number 1 --total 5 --next true
 *   node process-thought.js --thought "Revision" --number 2 --total 5 --next true --revision 1
 *   node process-thought.js --reset  # Reset thought history
 */

const fs = require('fs');
const path = require('path');

// Configuration
const HISTORY_FILE = path.join(__dirname, '.thought-history.json');
const DISABLE_LOGGING = process.env.DISABLE_THOUGHT_LOGGING?.toLowerCase() === 'true';

class ThoughtProcessor {
  constructor() {
    this.loadHistory();
  }

  loadHistory() {
    try {
      if (fs.existsSync(HISTORY_FILE)) {
        const data = JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf8'));
        this.thoughtHistory = data.thoughtHistory || [];
        this.branches = data.branches || {};
      } else {
        this.thoughtHistory = [];
        this.branches = {};
      }
    } catch (error) {
      this.thoughtHistory = [];
      this.branches = {};
    }
  }

  saveHistory() {
    fs.writeFileSync(
      HISTORY_FILE,
      JSON.stringify({
        thoughtHistory: this.thoughtHistory,
        branches: this.branches
      }, null, 2)
    );
  }

  resetHistory() {
    this.thoughtHistory = [];
    this.branches = {};
    if (fs.existsSync(HISTORY_FILE)) {
      fs.unlinkSync(HISTORY_FILE);
    }
  }

  validateThought(input) {
    const errors = [];

    if (!input.thought || typeof input.thought !== 'string' || input.thought.trim() === '') {
      errors.push('Invalid thought: must be a non-empty string');
    }

    if (!input.thoughtNumber || typeof input.thoughtNumber !== 'number' || input.thoughtNumber < 1) {
      errors.push('Invalid thoughtNumber: must be a positive number');
    }

    if (!input.totalThoughts || typeof input.totalThoughts !== 'number' || input.totalThoughts < 1) {
      errors.push('Invalid totalThoughts: must be a positive number');
    }

    if (typeof input.nextThoughtNeeded !== 'boolean') {
      errors.push('Invalid nextThoughtNeeded: must be a boolean');
    }

    // Optional field validations
    if (input.isRevision !== undefined && typeof input.isRevision !== 'boolean') {
      errors.push('Invalid isRevision: must be a boolean');
    }

    if (input.revisesThought !== undefined && (typeof input.revisesThought !== 'number' || input.revisesThought < 1)) {
      errors.push('Invalid revisesThought: must be a positive number');
    }

    if (input.branchFromThought !== undefined && (typeof input.branchFromThought !== 'number' || input.branchFromThought < 1)) {
      errors.push('Invalid branchFromThought: must be a positive number');
    }

    if (input.branchId !== undefined && typeof input.branchId !== 'string') {
      errors.push('Invalid branchId: must be a string');
    }

    if (input.needsMoreThoughts !== undefined && typeof input.needsMoreThoughts !== 'boolean') {
      errors.push('Invalid needsMoreThoughts: must be a boolean');
    }

    return errors;
  }

  processThought(input) {
    const errors = this.validateThought(input);

    if (errors.length > 0) {
      return {
        success: false,
        errors,
        status: 'failed'
      };
    }

    // Auto-adjust totalThoughts if thoughtNumber exceeds it
    if (input.thoughtNumber > input.totalThoughts) {
      input.totalThoughts = input.thoughtNumber;
    }

    // Create thought data
    const thoughtData = {
      thought: input.thought,
      thoughtNumber: input.thoughtNumber,
      totalThoughts: input.totalThoughts,
      nextThoughtNeeded: input.nextThoughtNeeded,
      isRevision: input.isRevision,
      revisesThought: input.revisesThought,
      branchFromThought: input.branchFromThought,
      branchId: input.branchId,
      needsMoreThoughts: input.needsMoreThoughts,
      timestamp: new Date().toISOString()
    };

    // Add to history
    this.thoughtHistory.push(thoughtData);

    // Track branches
    if (thoughtData.branchFromThought && thoughtData.branchId) {
      if (!this.branches[thoughtData.branchId]) {
        this.branches[thoughtData.branchId] = [];
      }
      this.branches[thoughtData.branchId].push(thoughtData);
    }

    // Save history
    this.saveHistory();

    return {
      success: true,
      thoughtNumber: thoughtData.thoughtNumber,
      totalThoughts: thoughtData.totalThoughts,
      nextThoughtNeeded: thoughtData.nextThoughtNeeded,
      branches: Object.keys(this.branches),
      thoughtHistoryLength: this.thoughtHistory.length,
      timestamp: thoughtData.timestamp
    };
  }

  getHistory() {
    return {
      thoughts: this.thoughtHistory,
      branches: this.branches,
      totalThoughts: this.thoughtHistory.length
    };
  }
}

// CLI Interface
if (require.main === module) {
  const args = process.argv.slice(2);
  const processor = new ThoughtProcessor();

  // Parse arguments
  const parseArgs = (args) => {
    const parsed = {};
    for (let i = 0; i < args.length; i++) {
      const arg = args[i];
      if (arg.startsWith('--')) {
        const key = arg.slice(2);
        const value = args[i + 1];

        if (key === 'reset') {
          return { reset: true };
        }

        if (key === 'history') {
          return { history: true };
        }

        if (value && !value.startsWith('--')) {
          // Parse boolean
          if (value === 'true') parsed[key] = true;
          else if (value === 'false') parsed[key] = false;
          // Parse number
          else if (!isNaN(value)) parsed[key] = parseFloat(value);
          // String
          else parsed[key] = value;
          i++;
        }
      }
    }
    return parsed;
  };

  const input = parseArgs(args);

  if (input.reset) {
    processor.resetHistory();
    console.log(JSON.stringify({ success: true, message: 'History reset' }, null, 2));
    process.exit(0);
  }

  if (input.history) {
    console.log(JSON.stringify(processor.getHistory(), null, 2));
    process.exit(0);
  }

  // Map CLI args to expected field names
  const thoughtInput = {
    thought: input.thought,
    thoughtNumber: input.number,
    totalThoughts: input.total,
    nextThoughtNeeded: input.next,
    isRevision: input.revision !== undefined ? true : input.isRevision,
    revisesThought: input.revision,
    branchFromThought: input.branch,
    branchId: input.branchId,
    needsMoreThoughts: input.needsMore
  };

  const result = processor.processThought(thoughtInput);
  console.log(JSON.stringify(result, null, 2));
  process.exit(result.success ? 0 : 1);
}

module.exports = { ThoughtProcessor };

/**
 * Tests for Sequential Thinking Thought Formatter
 *
 * Run with: npm test
 */

const { ThoughtFormatter } = require('../scripts/format-thought');

describe('ThoughtFormatter', () => {
  describe('Simple Format', () => {
    test('formats regular thought', () => {
      const result = ThoughtFormatter.formatSimple({
        thought: 'Test thought',
        thoughtNumber: 1,
        totalThoughts: 5
      });

      expect(result).toBe('Thought 1/5: Test thought');
    });

    test('formats revision thought', () => {
      const result = ThoughtFormatter.formatSimple({
        thought: 'Revised thought',
        thoughtNumber: 2,
        totalThoughts: 5,
        isRevision: true,
        revisesThought: 1
      });

      expect(result).toContain('[REVISION of Thought 1]');
      expect(result).toContain('Revised thought');
    });

    test('formats branch thought', () => {
      const result = ThoughtFormatter.formatSimple({
        thought: 'Branch thought',
        thoughtNumber: 3,
        totalThoughts: 5,
        branchFromThought: 2,
        branchId: 'a'
      });

      expect(result).toContain('[BRANCH A from Thought 2]');
      expect(result).toContain('Branch thought');
    });
  });

  describe('Markdown Format', () => {
    test('formats regular thought', () => {
      const result = ThoughtFormatter.formatMarkdown({
        thought: 'Test thought',
        thoughtNumber: 1,
        totalThoughts: 5
      });

      expect(result).toContain('**Thought 1/5**');
      expect(result).toContain('Test thought');
    });

    test('formats revision thought', () => {
      const result = ThoughtFormatter.formatMarkdown({
        thought: 'Revised thought',
        thoughtNumber: 2,
        totalThoughts: 5,
        isRevision: true,
        revisesThought: 1
      });

      expect(result).toContain('**[REVISION of Thought 1]**');
    });
  });

  describe('Box Format', () => {
    test('formats with border', () => {
      const result = ThoughtFormatter.format({
        thought: 'Test thought',
        thoughtNumber: 1,
        totalThoughts: 5
      });

      expect(result).toContain('┌');
      expect(result).toContain('└');
      expect(result).toContain('💭');
      expect(result).toContain('Test thought');
    });

    test('formats revision with emoji', () => {
      const result = ThoughtFormatter.format({
        thought: 'Revised',
        thoughtNumber: 2,
        totalThoughts: 5,
        isRevision: true,
        revisesThought: 1
      });

      expect(result).toContain('🔄');
      expect(result).toContain('REVISION');
    });

    test('formats branch with emoji', () => {
      const result = ThoughtFormatter.format({
        thought: 'Branch',
        thoughtNumber: 3,
        totalThoughts: 5,
        branchFromThought: 2,
        branchId: 'a'
      });

      expect(result).toContain('🌿');
      expect(result).toContain('BRANCH');
    });
  });

  describe('Text Wrapping', () => {
    test('wraps long text', () => {
      const longText = 'This is a very long thought that should be wrapped across multiple lines when it exceeds the maximum width specified for the formatter';
      const wrapped = ThoughtFormatter.wrapText(longText, 50);

      expect(wrapped.length).toBeGreaterThan(1);
      wrapped.forEach(line => {
        expect(line.length).toBeLessThanOrEqual(50);
      });
    });

    test('does not wrap short text', () => {
      const shortText = 'Short thought';
      const wrapped = ThoughtFormatter.wrapText(shortText, 50);

      expect(wrapped.length).toBe(1);
      expect(wrapped[0]).toBe(shortText);
    });
  });
});

/**
 * Tests for Sequential Thinking Thought Processor
 *
 * Run with: npm test
 */

const { ThoughtProcessor } = require('../scripts/process-thought');
const fs = require('fs');
const path = require('path');

// Mock history file for testing
const TEST_HISTORY_FILE = path.join(__dirname, '../scripts/.thought-history.json');

describe('ThoughtProcessor', () => {
  let processor;

  beforeEach(() => {
    // Clean up any existing history file
    if (fs.existsSync(TEST_HISTORY_FILE)) {
      fs.unlinkSync(TEST_HISTORY_FILE);
    }
    processor = new ThoughtProcessor();
  });

  afterEach(() => {
    // Clean up after tests
    if (fs.existsSync(TEST_HISTORY_FILE)) {
      fs.unlinkSync(TEST_HISTORY_FILE);
    }
  });

  describe('Validation', () => {
    test('rejects missing thought', () => {
      const result = processor.processThought({
        thoughtNumber: 1,
        totalThoughts: 5,
        nextThoughtNeeded: true
      });

      expect(result.success).toBe(false);
      expect(result.errors).toContain('Invalid thought: must be a non-empty string');
    });

    test('rejects empty thought string', () => {
      const result = processor.processThought({
        thought: '   ',
        thoughtNumber: 1,
        totalThoughts: 5,
        nextThoughtNeeded: true
      });

      expect(result.success).toBe(false);
      expect(result.errors).toContain('Invalid thought: must be a non-empty string');
    });

    test('rejects invalid thoughtNumber', () => {
      const result = processor.processThought({
        thought: 'Test',
        thoughtNumber: 0,
        totalThoughts: 5,
        nextThoughtNeeded: true
      });

      expect(result.success).toBe(false);
      expect(result.errors).toContain('Invalid thoughtNumber: must be a positive number');
    });

    test('rejects missing nextThoughtNeeded', () => {
      const result = processor.processThought({
        thought: 'Test',
        thoughtNumber: 1,
        totalThoughts: 5
      });

      expect(result.success).toBe(false);
      expect(result.errors).toContain('Invalid nextThoughtNeeded: must be a boolean');
    });

    test('accepts valid thought', () => {
      const result = processor.processThought({
        thought: 'Valid thought',
        thoughtNumber: 1,
        totalThoughts: 5,
        nextThoughtNeeded: true
      });

      expect(result.success).toBe(true);
      expect(result.thoughtNumber).toBe(1);
      expect(result.totalThoughts).toBe(5);
    });
  });

  describe('Thought Processing', () => {
    test('tracks thought history', () => {
      processor.processThought({
        thought: 'First thought',
        thoughtNumber: 1,
        totalThoughts: 3,
        nextThoughtNeeded: true
      });

      processor.processThought({
        thought: 'Second thought',
        thoughtNumber: 2,
        totalThoughts: 3,
        nextThoughtNeeded: true
      });

      const result = processor.processThought({
        thought: 'Third thought',
        thoughtNumber: 3,
        totalThoughts: 3,
        nextThoughtNeeded: false
      });

      expect(result.thoughtHistoryLength).toBe(3);
    });

    test('auto-adjusts totalThoughts when exceeded', () => {
      const result = processor.processThought({
        thought: 'Thought 5',
        thoughtNumber: 5,
        totalThoughts: 3,
        nextThoughtNeeded: true
      });

      expect(result.totalThoughts).toBe(5);
    });

    test('tracks revisions', () => {
      processor.processThought({
        thought: 'Original thought',
        thoughtNumber: 1,
        totalThoughts: 5,
        nextThoughtNeeded: true
      });

      const result = processor.processThought({
        thought: 'Revised thought',
        thoughtNumber: 2,
        totalThoughts: 5,
        nextThoughtNeeded: true,
        isRevision: true,
        revisesThought: 1
      });

      expect(result.success).toBe(true);
      expect(result.thoughtHistoryLength).toBe(2);
    });

    test('tracks branches', () => {
      processor.processThought({
        thought: 'Main thought',
        thoughtNumber: 1,
        totalThoughts: 5,
        nextThoughtNeeded: true
      });

      processor.processThought({
        thought: 'Branch A',
        thoughtNumber: 2,
        totalThoughts: 5,
        nextThoughtNeeded: true,
        branchFromThought: 1,
        branchId: 'branch-a'
      });

      const result = processor.processThought({
        thought: 'Branch B',
        thoughtNumber: 2,
        totalThoughts: 5,
        nextThoughtNeeded: false,
        branchFromThought: 1,
        branchId: 'branch-b'
      });

      expect(result.branches).toContain('branch-a');
      expect(result.branches).toContain('branch-b');
      expect(result.branches.length).toBe(2);
    });
  });

  describe('History Management', () => {
    test('resets history', () => {
      processor.processThought({
        thought: 'First thought',
        thoughtNumber: 1,
        totalThoughts: 5,
        nextThoughtNeeded: true
      });

      processor.resetHistory();

      const history = processor.getHistory();
      expect(history.totalThoughts).toBe(0);
      expect(history.thoughts.length).toBe(0);
    });

    test('persists and loads history', () => {
      processor.processThought({
        thought: 'Persisted thought',
        thoughtNumber: 1,
        totalThoughts: 5,
        nextThoughtNeeded: true
      });

      // Create new processor instance (should load from file)
      const newProcessor = new ThoughtProcessor();
      const history = newProcessor.getHistory();

      expect(history.totalThoughts).toBe(1);
      expect(history.thoughts[0].thought).toBe('Persisted thought');
    });
  });
});