Supercode

https://supercode.sh/how-it-works
Admin
Supercode is an AI-powered coding assistant for Cursor and Antigravity that enables intelligent...
Tokens:16,125
Snippets:181
Trust Score:4.7
Update:8 months ago
Show doc for...
Tokens:
Raw
### Comprehensive Smart Action Example

Source: https://supercode.sh/how-it-works/smart-actions

A detailed example combining multiple Smart Actions features, including model selection, system prompt generation, external API calls, voice commands, and predefined actions.

```json
{
  "Full-Stack Code Review": {
    "icon": "🔍",
    "menu": ["prompts", "buttons"],
    "model": {
      "ai": "Select the best model for code review based on current context: $model"
    },
    "systemPrompt": {
      "ai": "Create a comprehensive system prompt for code review that considers the current project context and selected model ($model)"
    },
    "prompt": {
      "url": "https://your-company.com/api/enhance-review-prompt"
    },
    "voiceCommand": ["review code", "full stack review"],
    "actions": ["security_scan", "performance_check"]
  }
}
```

--------------------------------

### Basic Action Configuration Example

Source: https://supercode.sh/how-it-works/smart-actions

Demonstrates the fundamental structure for defining custom actions. It includes properties like 'icon', 'menu', 'mode', 'systemPrompt', 'prompt', 'model', and 'run' to configure action behavior and appearance.

```json
{
  "Security Review": {
    "icon": "🔒",
    "menu": "buttons",
    "mode": "SC:Architect",
    "systemPrompt": "You are a security expert. Focus on input validation, authentication, and potential attack vectors.",
    "prompt": "$prompt \n\n Implement it with a focus on security."
  },
  "Performance Analysis": {
    "icon": "⚡",
    "menu": ["prompts", "buttons"],
    "prompt": "Analyze the code for performance bottlenecks and suggest optimizations.",
    "model": "o3",
    "run": true
  }
}
```

--------------------------------

### Environment Variables Setup

Source: https://supercode.sh/how-it-works/workflows-examples

Specifies the required environment variables for connecting to Trello. These include the API key, API token, and board ID, which are necessary for Supercode.sh to interact with your Trello board.

```dotenv
TRELLO_API_KEY=your_api_key_here
TRELLO_API_TOKEN=your_token_here
TRELLO_BOARD_ID=your_board_id_here
```

--------------------------------

### Next.js Table Component Example

Source: https://supercode.sh/how-it-works/workflows

Illustrates a prompt for a Next.js project to create a table component with sorting, filtering, data loading, and animations, including page creation for users and products. This highlights the complexity of multi-step tasks.

```text
1. Look at what UI controls are in `src/controls`  
2. Understand how state management works in stores  
3. Create a basic table component: with sorting, filtering, data loading from the backend, and beautiful animation  
4. Create a `/users` page with a user table  
5. Create a `/products` page with a product table  
  
Do not stop executing the task until all the above items are successfully completed.
```

--------------------------------

### Workflow: Sequential Action Execution (Design & Implement)

Source: https://supercode.sh/how-it-works/smart-actions

Illustrates creating a workflow for sequential action execution. This example defines 'Architecture Design' and 'Implementation' actions that run sequentially when triggered.

```json
{
  "Architecture Design": {
    "icon": "🏗️",
    "mode": "SC:Architect",
    "model": "o3",
    "prompt": "Design the architecture and implementation plan for: $prompt",
    "systemPrompt": "Focus on system design, component relationships, and implementation strategy.",
    "run": true
  },
  "Implementation": {
    "icon": "⚙️",
    "model": "claude-4-sonnet",
    "prompt": "Implement the feature based on the architectural design: $prompt",
    "systemPrompt": "Focus on clean, maintainable code implementation.",
    "run": true
  },
  "Full Feature Workflow": {
    "icon": "🚀",
    "menu": ["prompts", "buttons"],
    "actions": ["Architecture Design", "Implementation"],
    "voiceCommand": ["build feature", "full workflow"]
  }
}
```

--------------------------------

### Dynamic Value Modification with Updaters

Source: https://supercode.sh/how-it-works/smart-actions

Illustrates how to use 'updaters' for dynamic value modification in actions. This example shows 'URL' and 'AI' updater types to fetch external data or use AI for prompt enhancement.

```json
{
  "Add Project Context": {
    "icon": "🌐",
    "menu": "enhancers",
    "prompt": {
      "url": "https://your-server.com/api/enhance"
    }
  },
  "Security Focus": {
    "icon": "🔐",
    "menu": "enhancers", 
    "prompt": {
      "ai": "Add security considerations and best practices to this prompt: $prompt"
    }
  }
}
```

--------------------------------

### Customizing Test Runner Commands

Source: https://supercode.sh/how-it-works/workflows-examples

Provides examples of how to modify the 'Run Tests' action in the 'Tests Must Pass' workflow to accommodate different test runners like Yarn, pytest, and Go tests.

```yaml
# For Yarn
- name: 🧪 Run Tests
  prompt:
    command: 'yarn test 2>&1; echo "Exit code: $?"'

# For Python/pytest
- name: 🧪 Run Tests
  prompt:
    command: 'pytest 2>&1; echo "Exit code: $?"'

# For Go
- name: 🧪 Run Tests
  prompt:
    command: 'go test ./... 2>&1; echo "Exit code: $?"'

```

--------------------------------

### Custom Enhancer Configuration Example (JSON)

Source: https://supercode.sh/how-it-works/prompt-enhancement

Defines a custom prompt enhancer by specifying its name and the prompt text to be used for enhancement. This allows for tailored prompt refinement based on specific project needs or coding standards.

```json
{
  "name": "React Best Practices",
  "prompt": "Please enhance the following prompt by adding React best practices, proper error handling, and performance optimization suggestions."
}
```

```json
{
  "name": "API Security Focus",
  "prompt": "Transform the following prompt by adding security considerations, input validation requirements, error handling patterns, and rate limiting suggestions."
}
```

--------------------------------

### Nested Workflow: Code Review, Fix, and Test Pipeline

Source: https://supercode.sh/how-it-works/smart-actions

Demonstrates a nested workflow for a complete code pipeline. This example chains 'Code Review & Fix', 'Apply Fixes', and 'Generate Tests' actions to run sequentially.

```json
{
  "Code Review & Fix": {
    "model": "claude-4-opus",
    "prompt": "Review this code for issues: $prompt",
    "systemPrompt": "Identify bugs, security issues, and improvement opportunities.",
    "run": true
  },
  "Apply Fixes": {
    "model": "claude-4-sonnet",
    "prompt": "Apply the suggested fixes from the review: $prompt",
    "run": true
  },
  "Generate Tests": {
    "model": "claude-4-sonnet",
    "prompt": "Create comprehensive tests for the fixed code: $prompt",
    "run": true
  },
  "Complete Code Pipeline": {
    "icon": "🔄",
    "menu": ["buttons"],
    "actions": ["Code Review & Fix", "Apply Fixes", "Generate Tests"],
    "voiceCommand": ["run pipeline", "complete workflow"]
  }
}
```

--------------------------------

### Electron App Memory Leak Detection Example

Source: https://supercode.sh/how-it-works/workflows

Demonstrates a task for an Electron application to identify and fix memory leaks. It specifies two common types of leaks: incorrect timer handling and improper global cache cleanup, found within the `src/watchers` directory.

```text
1. Study all files in the `src/watchers` directory (30 files)  
2. We clearly have a memory leak - 17gb occupied after an hour. Fix the detected leaks.

Let's say these files have two types of leaks:
  1. instead of deleting the timer, it's turned off: `setInterval(() => { if (!active) return; ... })
  2. incorrect cleanup of global cache (top-level `const map = new Map()`)
```

--------------------------------

### JavaScript Timer Leak Example

Source: https://supercode.sh/how-it-works/workflows

A code snippet illustrating a common memory leak pattern in JavaScript where a timer is disabled instead of being cleared. This is relevant for debugging applications like Electron apps.

```javascript
setInterval(() => {
  if (!active) return;
  // ... timer logic ...
})
```

--------------------------------

### Using Variables in Action Updaters

Source: https://supercode.sh/how-it-works/smart-actions

Shows how to leverage dollar-signed variables within action configurations to dynamically reference and modify current context like prompts, system prompts, models, and modes.

```json
{
  "Add Debug Logging": {
    "icon": "🐛",
    "menu": "prompts",
    "prompt": "Add comprehensive debug logging to this code. Original request: $prompt",
    "systemPrompt": "Focus on adding meaningful log statements that help with debugging. Current model: $model"
  },
  "Convert to TypeScript": {
    "icon": "🔷",
    "menu": "buttons",
    "prompt": {
      "ai": "Convert the following code to TypeScript with proper type definitions: $prompt"
    },
    "model": "claude-3-5-sonnet"
  }
}
```

--------------------------------

### Execute Shell Command and Use Output

Source: https://supercode.sh/how-it-works/workflows

This functionality allows for the execution of any shell command or a chain of commands. The standard output (stdout) of the command is then used as the new prompt. This can include running scripts like Node.js or Python. It provides access to current variables for dynamic command generation.

```shell
node ./my-script.js
python ./get-data.py
```

--------------------------------

### Context-Aware Assistant and Test External Action

Source: https://supercode.sh/how-it-works/smart-actions

Demonstrates creating a context-aware assistant and an external API call action. The assistant uses model and mode context, while the external action calls a specified URL.

```json
{
  "Context-Aware Assistant": {
    "icon": "🤖",
    "menu": "prompts",
    "systemPrompt": {
      "ai": "Create a system prompt optimized for the current model ($model) and mode ($mode)"
    },
    "prompt": "Help me with: $prompt"
  },
  "Test External": {
    "menu": "buttons",
    "icon": "🚀",
    "prompt": {
      "url": "https://api.supercode.sh/prompt-echo"
    },
    "systemPrompt": "You must start your response with 'Hello, world!'",
    "run": true
  }
}
```

--------------------------------

### Voice Commands and IDE Integration for Actions

Source: https://supercode.sh/how-it-works/smart-actions

Shows how to integrate actions with voice commands and specific IDE operations. This allows for triggering actions through natural language or predefined IDE commands.

```json
{
  "Run Tests": {
    "voiceCommand": ["run tests", "execute tests", "test project"],
    "ideCommand": {
      "name": "workbench.action.tasks.runTask", 
      "args": ["npm: test"]
    }
  },
  "Quick Fix": {
    "icon": "⚡",
    "menu": "prompts",
    "prompt": "Fix any obvious errors in the selected code",
    "run": true
  }
}
```

--------------------------------

### Conditional Step Execution (AI)

Source: https://supercode.sh/how-it-works/workflows

Steps can be conditionally executed based on the text response from an AI query. If the AI returns "true", "yes", or "1", the step will execute. Any other response will cause the step to be skipped. Variables can be used in the AI query.

```text
Does the following text indicate a critical issue? $response. Return 'yes' or 'no'.
```

--------------------------------

### IDE Command Execution

Source: https://supercode.sh/how-it-works/workflows

This feature allows for the execution of IDE commands at specific steps within a workflow. This enables management of the development environment, such as opening new chats, triggering compilations via npm tasks, or creating new files.

```ide
npm run build
open new chat
```

--------------------------------

### Configure Custom Commands with JSON

Source: https://supercode.sh/how-it-works/user-defined-prompts

Defines custom commands and AI prompts for Supercode. This JSON file allows you to specify menu names, icons, the prompt text, and whether the command should run instantly. It serves as the configuration for both user-defined prompts and voice commands.

```json
[
  {
    "menuName": "fix errors",
	"menuIcon": "brain",
    "prompt": "Please, identify the errors in the code and fix them.",
	"instantRun": true
  },
  {
    "menuName": "sync with backend",
	"menuIcon": "sync",
    "prompt": "Please, sync the API.md content with the actual API methods available in the code."
  }
]
```

--------------------------------

### Classic Ralph Wiggum Loop Implementation

Source: https://supercode.sh/how-it-works/workflows-examples

Shows the fundamental structure of the classic Ralph Wiggum iterative technique using a bash `while` loop and piping input to an AI model. This is the conceptual basis for Supercode's implementation.

```bash
while :; do cat PROMPT.md | claude ; done

```

--------------------------------

### AI Prompt Generation

Source: https://supercode.sh/how-it-works/workflows

This powerful feature uses a Supercode AI model to generate new prompt text based on a query. It supports using available variables (e.g., `$prompt`) and can instruct the AI to refine the task by breaking it down, translating, structuring, or adding details.

```text
Rework the following prompt to be more concise and add security considerations: $prompt
```

--------------------------------

### Conditional Step Execution (HTTP)

Source: https://supercode.sh/how-it-works/workflows

Steps can be conditionally executed based on the HTTP status code of a request. A 2xx status code indicates success, and the step will execute. Any other status code will cause the step to be skipped. Variables can be included in the request.

```http
GET /api/status?query=$prompt
Accept: application/json
```

--------------------------------

### Configure Custom Voice Commands in JSON

Source: https://supercode.sh/how-it-works/voice-commands

Define custom voice commands by creating a `.supercode/commands.json` file. This file maps spoken phrases to specific IDE commands, including arguments for tasks like compilation or testing. It allows for hands-free execution of development workflows.

```json
[
  {
    "voiceCommands": ["compile project", "build project"],
    "ideCommand": {
      "name": "workbench.action.tasks.runTask",
      "args": ["tsc: build - tsconfig.json"]
    }
  },
  {
    "voiceCommands": ["test project", "run tests"],
    "ideCommand": {
      "name": "workbench.action.tasks.runTask",
      "args": ["npm: test"]
    }
  }
]
```

--------------------------------

### Trello Task Processor Workflow Description

Source: https://supercode.sh/how-it-works/workflows-examples

This text describes the functionality of the Trello Task Processor workflow, detailing its automated process for handling Trello tasks from initiation to completion, including AI-driven analysis and execution.

```text
A fully automated workflow for processing Trello tasks: takes a task from the Todo column, executes it with an AI agent, generates a summary, and moves it to Done.

**Trello Task Processor** is an advanced integration workflow that automates the entire task lifecycle:
  1. **Loads a task** from the Trello Todo column (marks it as "in progress")
  2. **Analyzes and decomposes** the task using SC:Architect mode
  3. **Creates an implementation plan** with checkboxes in a file
  4. **Executes step by step** through an internal loop with testing after each step
  5. **Generates a summary** of completed work
  6. **Moves to Done** and adds the summary as a comment
```

--------------------------------

### Configure Environment Variables for Telegram Notifications

Source: https://supercode.sh/how-it-works/workflows-examples

Sets up environment variables for Telegram bot token and chat ID in a .env file. This is crucial for the 'Send Telegram message at the end of work' workflow to authenticate and send messages to the correct chat.

```bash
touch .env
echo 'TELEGRAM_BOT_TOKEN="YOUR_BOT_TOKEN_HERE"' >> .env
echo 'TELEGRAM_CHAT_ID="YOUR_CHAT_ID_HERE"' >> .env

echo ".env" >> .gitignore
```

--------------------------------

### Trello Task Implementation Loop

Source: https://supercode.sh/how-it-works/workflows-examples

Details the internal loop for executing implementation steps of a Trello task. It includes reading the plan, checking for remaining steps, and implementing the next step, ensuring tests pass before proceeding.

```yaml
Trello Task Implementation Loop:
  - 📖 Read Plan
  - 🔍 Check if More Steps
    if: has [ ] steps
    - 🚀 Implement Next Step
      - Tests Must Pass
      - Loop recursion
```

--------------------------------

### Make URL Request and Use Response

Source: https://supercode.sh/how-it-works/workflows

This mechanism allows for making a POST request to a specified URL. The JSON response from the URL is then used as the new value. The current variables are sent in the request body with the 'application/json' content type.

```http
POST /api/process
Content-Type: application/json

{
  "prompt": "$prompt",
  "model": "$model"
}
```

--------------------------------

### Trello Task Processor Workflow

Source: https://supercode.sh/how-it-works/workflows-examples

Defines the main workflow for processing Trello tasks, including loading, parsing, analyzing, planning, executing, and completing tasks. It outlines the sequence of actions and sub-actions involved in automating a task from Trello.

```yaml
Trello Task Processor:
  icon: 📋
  menu: buttons
  actions:
    - 🔍 Load Task from Trello
    - ❌ No Tasks Available
    - ✅ Process Task
      - 📊 Parse Task Data
      - 🧠 Analyze & Decompose
      - 📋 Create Plan
      - 🛠️ Execute Implementation
      - 📝 Generate Summary
      - ✅ Complete Task
      - 📤 Move to Done
      - 🧹 Cleanup
```

--------------------------------

### Conditional Step Execution (JavaScript)

Source: https://supercode.sh/how-it-works/workflows

Steps can be executed conditionally based on a JavaScript expression. The JavaScript code must return a boolean value (`true` or `false`). If the condition evaluates to true, the step proceeds; otherwise, it is skipped. Variables are accessible within the script.

```javascript
return $response.includes("error");
```

--------------------------------

### Execute JavaScript Code and Use Result

Source: https://supercode.sh/how-it-works/workflows

This feature enables the execution of arbitrary JavaScript code. The result of the code execution is used as the new value for the prompt or step. Current variables are accessible directly as global variables within the JavaScript scope.

```javascript
const result = prompt + " processed";
return result;
```

--------------------------------

### Conditional Step Execution (Shell)

Source: https://supercode.sh/how-it-works/workflows

Steps can be conditionally executed based on the exit code of a shell command. An exit code of 0 indicates success and the step will execute. Any non-zero exit code signifies an error, and the step will be skipped. Variables can be used in the shell command.

```shell
grep -q "success" $packedResponses && exit 0 || exit 1
```

--------------------------------

### Integrating 'Tests Must Pass' into Other Workflows

Source: https://supercode.sh/how-it-works/workflows-examples

Demonstrates how to include the 'Tests Must Pass' workflow within another workflow to ensure test success before the main workflow completes. This guarantees code quality.

```yaml
Your Workflow:
  icon: 🚀
  menu: buttons
  actions:
    - name: Implement Feature
      prompt: 'Implement user authentication'
      instantRun: true

    - name: Add Tests
      prompt: 'Write tests for authentication functionality'
      instantRun: true

    - 'Tests Must Pass'  # Guarantees test success before completion

```

--------------------------------

### Workflow Structure for Deep Refactoring

Source: https://supercode.sh/how-it-works/workflows-examples

This YAML snippet outlines the structure of the 'Deep Refactoring' workflow, detailing its main actions and the internal 'Deep Refactoring Iteration' loop. It includes steps for code analysis, duplication detection, plan creation, execution, and cleanup.

```yaml
Deep Refactoring:
  icon: 🏗️
  menu: buttons
  actions:
    - 🔍 Analyze Code Structure
    - 🔎 Find Explicit Duplications
    - 🧩 Find Implicit Duplications
    - 📋 Create Refactoring Plan
    - 🔧 Execute Refactorings Loop
    - 📝 Save Summary
    - 🧹 Cleanup

Deep Refactoring Iteration:
  actions:
    - 📖 Read Current Plan
    - 🔍 Check if More Items
    - 🛠️ Implement Next Item
    - Loop Recursion
```

--------------------------------

### Send Telegram Message using Bash Script

Source: https://supercode.sh/how-it-works/workflows-examples

A bash script designed to send a message to a Telegram chat using a bot token. It takes the message content from the prompt and clears the prompt after sending.

```bash
#!/bin/bash

# Check if TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID are set
if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
  echo "Error: TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID must be set."
  exit 1
fi

# Get the message from the prompt (assuming it's passed as an argument or available in a variable)
MESSAGE="$1"

# If message is empty, try to read from stdin or a default
if [ -z "$MESSAGE" ]; then
  if [ -p /dev/stdin ]; then
    MESSAGE=$(cat)
  else
    MESSAGE="Task completed."
  fi
fi

# URL encode the message
ENCODED_MESSAGE=$(echo -n "$MESSAGE" | jq -sRr @uri)

# Construct the Telegram API URL
API_URL="https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/sendMessage?chat_id=$TELEGRAM_CHAT_ID&text=$ENCODED_MESSAGE"

# Send the message using curl
curl -s "$API_URL"

# Clear the prompt (this part depends on the Supercode environment, often done by the workflow runner)
# For demonstration, we'll just indicate it:
# echo "Prompt cleared."

exit 0
```

--------------------------------

### Workflow Structure for 'Tests Must Pass'

Source: https://supercode.sh/how-it-works/workflows-examples

Defines the 'Tests Must Pass' workflow, which runs tests, clears the prompt if tests pass, or triggers a fix-and-loop mechanism if tests fail. It uses shell and JavaScript conditions to manage the flow.

```yaml
Tests Must Pass:
  icon: ✅
  menu: buttons
  actions:
    - name: 🧪 Run Tests
      prompt:
        command: 'npm test 2>&1; echo "Exit code: $?"'

    - name: ✓ Clear if Passed
      if:
        type: shell
        value: 'echo "$prompt" | grep -q "Exit code: 0"'
      prompt: ''

    - name: ❌ Fix and Loop
      if:
        type: js
        value: 'prompt.trim() !== ""'
      actions:
        - name: 🔧 Fix Test Issues
          prompt: |
            The tests failed with the following output:

            $prompt

            Analyze the test failures and fix all issues.
          instantRun: true
          actions:
            - 'Tests Must Pass'  # Reference to self = loop

```
Tokens:
Raw