# From the server project directory
npm run build
npm link

# Verify installation
which tbc-guidelines  # Should show the global path
tbc-guidelines        # Should start the server (Ctrl+C to exit)

npm install tbc-guidelines-mcp-server

tbc-guidelines

// guidelines-client.js
const { spawn } = require('child_process');

class GuidelinesClient {
  constructor() {
    this.requestId = 1;
    this.server = null;
  }

  async start() {
    // Start the global MCP server
    this.server = spawn('tbc-guidelines', [], {
      stdio: ['pipe', 'pipe', 'pipe']
    });
    
    // Initialize the server
    await this.sendRequest('initialize', {
      protocolVersion: '2024-11-05',
      capabilities: {},
      clientInfo: { name: 'guidelines-client', version: '1.0.0' }
    });
  }

  async sendRequest(method, params = {}) {
    return new Promise((resolve, reject) => {
      const request = {
        jsonrpc: '2.0',
        id: this.requestId++,
        method,
        params
      };

      let response = '';
      const onData = (data) => {
        response += data.toString();
        try {
          const parsed = JSON.parse(response);
          this.server.stdout.off('data', onData);
          resolve(parsed.result);
        } catch (e) {
          // Continue reading
        }
      };

      this.server.stdout.on('data', onData);
      this.server.stdin.write(JSON.stringify(request) + '\n');

      setTimeout(() => {
        this.server.stdout.off('data', onData);
        reject(new Error('Request timeout'));
      }, 5000);
    });
  }

  async getGuidelines() {
    return await this.sendRequest('resources/list');
  }

  async getGuideline(uri) {
    return await this.sendRequest('resources/read', { uri });
  }

  async reviewCode(code, language = 'typescript') {
    return await this.sendRequest('tools/call', {
      name: 'review_code',
      arguments: { code, language }
    });
  }

  close() {
    if (this.server) {
      this.server.kill();
    }
  }
}

// Usage example
async function main() {
  const client = new GuidelinesClient();
  await client.start();

  try {
    // List all guidelines
    const guidelines = await client.getGuidelines();
    console.log('Available guidelines:', guidelines.resources.map(r => r.name));

    // Get a specific guideline
    const guideline = await client.getGuideline('guideline://typescript-best-practices');
    console.log('TypeScript Guidelines:', guideline.contents[0].text.substring(0, 200) + '...');

    // Review some code
    const codeReview = await client.reviewCode(`
      function test() {
        var x = 1;
        return x;
      }
    `);
    console.log('Code Review:', codeReview.content[0].text);

  } finally {
    client.close();
  }
}

main().catch(console.error);

// direct-usage.js
const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');

// Import your server setup
const { setupServer } = require('tbc-guidelines-mcp-server/build/server');

async function createCustomServer() {
  const server = new McpServer({
    name: 'custom-guidelines-server',
    version: '1.0.0'
  });

  await setupServer(server);
  
  // Add your custom resources or tools here
  server.setRequestHandler(ResourceListRequestSchema, async () => {
    // Custom logic
  });

  const transport = new StdioServerTransport();
  await server.connect(transport);
}

{
  "mcpServers": {
    "tbc-guidelines": {
      "command": "tbc-guidelines"
    }
  }
}

// In your VS Code extension
const { spawn } = require('child_process');

function activateGuidelinesServer() {
  const server = spawn('tbc-guidelines', [], {
    stdio: ['pipe', 'pipe', 'pipe']
  });
  
  // Handle communication
  server.stdout.on('data', (data) => {
    // Process MCP responses
  });
  
  return server;
}

FROM node:18-alpine

# Install the guidelines server globally
RUN npm install -g tbc-guidelines-mcp-server

# Your app code
COPY . /app
WORKDIR /app
RUN npm install

# Start both your app and the guidelines server
CMD ["node", "your-app.js"]

# .github/workflows/test.yml
name: Test with Guidelines
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v2
        with:
          node-version: '18'
      
      - name: Install Guidelines Server
        run: npm install -g tbc-guidelines-mcp-server
      
      - name: Run Code Review
        run: |
          # Your test script that uses tbc-guidelines
          node scripts/review-changes.js

{
  "method": "resources/list",
  "params": {}
}

{
  "method": "resources/read",
  "params": {
    "uri": "guideline://typescript-best-practices"
  }
}

{
  "method": "tools/call",
  "params": {
    "name": "review_code",
    "arguments": {
      "code": "your code here",
      "language": "typescript"
    }
  }
}

# Check if it's in your PATH
which tbc-guidelines

# Or run directly
npx tbc-guidelines-mcp-server

# Make sure the binary is executable
chmod +x $(which tbc-guidelines)