SuperDuck.AI CLI Tutorials

1.1 Installation Guide Beginner

Follow these steps to install the SuperDuck.AI CLI on your system:

Prerequisites

Before installation, ensure you have the following:

• libcurl - The only external dependency required
• A compatible operating system (macOS, Linux, or WSL on Windows)
• Git installed on your system
• An API key from SuperDuck.AI (sign up at superduck.ai if you don't have one)

Installation Steps

# Clone the repository
git clone https://github.com/codycodes/cli.git codycodes-cli

# Change to the directory
cd codycodes-cli

# Compile the program
make

# Initialize environment variables
cp example_env.sh codycodes_env.sh

# Edit the environment file to add your API key
nano codycodes_env.sh

# Source the environment file
source codycodes_env.sh

Verifying Installation

To verify that SuperDuck.AI CLI is installed correctly, run:

cody 'Hello, world!'

If installation was successful, you should see a response from Cody.

1.2 Configuration & Setup Beginner

Environment Variables

SuperDuck.AI CLI uses several environment variables for configuration:

• SUPERDUCK_API_KEY - Your API key from SuperDuck.AI
• SUPERDUCK_BASE_URL - The API endpoint (default: https://api.superduck.ai)
• SUPERDUCK_DEFAULT_MODEL - The default AI model to use (e.g., gpt-4)
• SUPERDUCK_TIMEOUT - Request timeout in seconds (default: 60)

These variables should be set in your codycodes_env.sh file:

export SUPERDUCK_API_KEY="your_api_key_here"
export SUPERDUCK_BASE_URL="https://api.superduck.ai"
export SUPERDUCK_DEFAULT_MODEL="gpt-4"
export SUPERDUCK_TIMEOUT=60

Checking Configuration

To verify your configuration:

echo $SUPERDUCK_API_KEY
echo $SUPERDUCK_DEFAULT_MODEL

1.3 Basic Commands & Syntax Beginner

Basic Syntax

The general syntax for using SuperDuck.AI CLI is:

cody 'Your question or request'

Here, cody is the default AI persona, and your request is enclosed in quotes.

Example Commands

cody 'Write a hello world program in Python'

cody 'Explain what a closure is in JavaScript'

emmy 'Write a professional email to reschedule a meeting'

Default Personas

SuperDuck.AI comes with two default personas:

• cody - Optimized for coding tasks, technical explanations, and debugging
• emmy - Specializes in content creation, writing, and communication tasks

2.1 Piping Content Intermediate

One of the most powerful features of SuperDuck.AI CLI is the ability to pipe content from files or other commands directly into your prompts.

Basic Piping

You can pipe content to Cody using the standard Unix pipe operator (|):

cat complex_code.py | cody 'explain this code'

This sends the contents of complex_code.py to Cody for analysis.

Piping from Command Output

You can also pipe the output of other commands:

ls -la | cody 'Explain what these files and permissions mean'

npm run build 2>&1 | cody 'What might be causing this error?'

Working with Large Files

For large files, you may want to extract only the relevant portions:

grep -A 10 "function calculateTotal" app.js | cody 'Explain this function'

2.2 Chaining Commands Intermediate

Chaining allows you to create multi-step workflows by connecting several AI commands together.

Basic Command Chaining

You can chain commands by piping the output of one AI command to another:

cody 'Write a simple Python script that calculates prime numbers' | emmy 'Explain this code for a beginner'

In this example, Cody generates the Python code, and Emmy explains it in beginner-friendly terms.

Complex Chaining Examples

cat data.csv | cody 'analyze this data and create a summary' | emmy 'create a latex presentation based on this analysis'

cat mycode.js | cody 'Review this code and suggest improvements' | cody 'Generate documentation based on the review'

2.3 Understanding AI Personas Intermediate

AI personas in SuperDuck.AI are specialized versions of the AI model tailored for different types of tasks.

Default Personas

• cody - Technical focus with programming expertise
  • Coding: Writing, debugging, and explaining code
  • Technical problem-solving
  • System design and architecture
• emmy - Writing and communication focus
  • Content creation: emails, reports, presentations
  • Text summarization and formatting
  • Creative writing and documentation

Choosing the Right Persona

Consider the nature of your task when selecting a persona:

• Use cody for programming tasks, code explanations, debugging
• Use emmy for writing documents, emails, or creating presentations
• Use custom personas (covered later) for specialized tasks

3.1 Creating Custom Personas Advanced

You can create custom AI personas tailored to specific tasks or domains.

Creating a New Persona

To create a custom persona:

1. Create a symbolic link to the main CLI executable
2. Define persona-specific environment variables

# Create a symbolic link
ln -s /path/to/codycodes/cli /usr/local/bin/newpersona

# Add persona-specific environment variables to your env file
echo 'export NEWPERSONA_SYSTEM_PROMPT="You are an expert in..."' >> codycodes_env.sh
echo 'export NEWPERSONA_MODEL="gpt-4"' >> codycodes_env.sh
echo 'export NEWPERSONA_TEMPERATURE="0.7"' >> codycodes_env.sh

# Source the updated env file
source codycodes_env.sh

Example: Creating a Documentation Specialist

ln -s /usr/local/bin/cody /usr/local/bin/docgen

# Add to your env file:
export DOCGEN_SYSTEM_PROMPT="You are a documentation specialist. Your task is to create clear, comprehensive documentation for code. Include usage examples, parameter descriptions, and return value information. Format documentation in markdown."
export DOCGEN_MODEL="gpt-4"
export DOCGEN_TEMPERATURE="0.3"

cat myfunction.js | docgen 'Create documentation for this code'

Persona Configuration Options

Each persona can have its own configuration through environment variables:

• PERSONANAME_SYSTEM_PROMPT - Sets the system prompt/instructions
• PERSONANAME_MODEL - Specifies which AI model to use
• PERSONANAME_TEMPERATURE - Controls randomness (0.0-1.0)
• PERSONANAME_MAX_TOKENS - Sets maximum response length

3.2 Scripting with CodyCodes Advanced

SuperDuck.AI CLI can be integrated into shell scripts to automate complex tasks.

Basic Script Integration

Here's a simple shell script that uses CodyCodes:

#!/bin/bash

# Source the environment
source ~/codycodes_env.sh

# Get file to analyze from argument
FILE=$1

# Analyze code and generate documentation
cat $FILE | cody "Analyze this code and identify potential bugs" > analysis.txt
cat $FILE | docgen "Generate comprehensive documentation" > docs.md

echo "Analysis and documentation completed!"

Error Handling in Scripts

When using CodyCodes in scripts, it's important to handle potential errors:

#!/bin/bash

# Source the environment
source ~/codycodes_env.sh

# Get file to analyze from argument
FILE=$1

if [ ! -f "$FILE" ]; then
    echo "Error: File not found!"
    exit 1
fi

# Analyze code with error handling
if cat $FILE | cody "Analyze this code" > analysis.txt; then
    echo "Analysis completed successfully"
else
    echo "Error during analysis"
    exit 1
fi

3.3 Complex Workflows Advanced

Create sophisticated multi-step workflows that combine CodyCodes with other command-line tools.

Code Analysis Workflow Example

#!/bin/bash

# Source environment
source ~/codycodes_env.sh

# Find all JavaScript files
JSFILES=$(find ./src -name "*.js")

# Iterate through files
for file in $JSFILES; do
    echo "Analyzing $file..."
    
    # Get complexity metrics
    COMPLEXITY=$(node complexity-analyzer.js $file)
    
    # If complexity is high, request refactoring
    if [[ $COMPLEXITY -gt 10 ]]; then
        echo "High complexity detected in $file, requesting refactoring suggestions..."
        cat $file | cody "This file has high complexity ($COMPLEXITY). Suggest refactoring to simplify it." > "refactoring-suggestions/$(basename $file).md"
    fi
done

Data Processing Workflow

#!/bin/bash

# Source environment
source ~/codycodes_env.sh

# Process raw data
cat raw_data.csv | cody "Clean this CSV data, removing duplicates and normalizing values" > clean_data.csv

# Analyze the data
cat clean_data.csv | cody "Analyze this data and identify key trends" > analysis.txt

# Create visualization code
cat analysis.txt | cody "Generate Python code using matplotlib to visualize these trends" > visualize.py

# Create final report
cat analysis.txt | emmy "Create a comprehensive report with an executive summary based on this analysis" > final_report.md

echo "Data processing workflow completed!"

4.1 Code Generation Beginner

CodyCodes excels at generating code snippets and full programs based on your specifications.

Basic Code Generation

cody 'Write a function that calculates the Fibonacci sequence up to n terms in Python'

cody 'Create a JavaScript function that validates email addresses with the following requirements:
- Must have an @ symbol and a domain
- Domain must have at least one period
- Username part must be at least 3 characters
- No special characters except underscore and period in username'

Generating Complete Programs

cody 'Create a Python command-line tool that takes a CSV file as input and outputs summary statistics for each numeric column. Include error handling for file not found and malformed CSV files.'

Starting from Existing Code

cat starter_code.js | cody 'Complete this code by adding the missing functionality for user authentication described in the comments'

4.2 Debugging & Code Review Intermediate

Use CodyCodes to help identify and fix bugs in your code, or to get code review feedback.

Debugging Code

cat buggy_function.js | cody 'This function has a bug. It should sort an array of objects by a specified property, but it's not working. Please identify and fix the issue.'

cat error_log.txt my_script.py | cody 'My script is throwing this error. Please explain what might be causing it and how to fix it.'

Code Review

cat pull_request.diff | cody 'Review this code change. Highlight any potential issues with performance, security, or maintainability.'

Performance Optimization

cat slow_function.py | cody 'This function is running slowly. Suggest optimizations to improve its performance while maintaining the same functionality.'

4.3 Content Creation Beginner

The emmy persona is specialized for content creation tasks, from emails to comprehensive documentation.

Writing Professional Communications

emmy 'Write a professional email to decline a project opportunity due to scheduling conflicts. Express gratitude for the consideration and leave the door open for future collaboration.'

cat meeting_notes.txt | emmy 'Create a structured summary of these meeting notes with action items and responsibilities highlighted.'

Documentation Creation

cat project_outline.md | emmy 'Create a detailed README.md for this project that includes installation instructions, usage examples, and API documentation.'

Converting Between Formats

cat report.txt | emmy 'Convert this plain text report into a well-formatted markdown document with proper headings, lists, and emphasis.'

4.4 Data Analysis Intermediate

CodyCodes can help analyze data, identify patterns, and generate visualization code.

Basic Data Analysis

cat sales_data.csv | cody 'Analyze this CSV data. Identify trends in monthly sales and suggest possible factors affecting performance.'

cat experiment_results.csv | cody 'Calculate key statistical measures for this data: mean, median, standard deviation, and identify any outliers.'

Generating Visualization Code

cat weather_data.csv | cody 'Generate Python code using matplotlib to create a line chart showing temperature trends over time, with separate lines for max and min temperature.'

Multi-step Data Workflow

cat raw_data.csv | cody 'Clean this data by removing duplicates, handling missing values, and normalizing the numeric columns' > clean_data.csv
cat clean_data.csv | cody 'Analyze this cleaned data and generate insights about customer behavior' > analysis.txt
cat analysis.txt | emmy 'Create a business-friendly report based on these technical insights' > final_report.md

5.1 Common Issues & Solutions Beginner

Environment Variable Issues

Compilation and Installation Issues

Usage Issues

5.2 Debugging Mode Intermediate

When troubleshooting issues with SuperDuck.AI CLI, the debug mode can provide valuable insights.

Enabling Debug Mode

To enable debug mode:

make debug

This will rebuild the CLI with debug logging enabled.

Interpreting Debug Output

Debug output includes:

• Environment variable values
• API request details
• Response headers and status codes
• Error messages with more context

DEBUG: Initializing with API key: XXXX...
DEBUG: Using model: gpt-4
DEBUG: Request URL: https://api.superduck.ai/v1/completions
DEBUG: Request payload: {"prompt":"You are a helpful assistant...","max_tokens":1500}
DEBUG: Response status: 200
...

Common Debug Patterns

Look for these patterns in debug output to identify issues:

• Missing or invalid API key errors (401 responses)
• Timeout issues (connection timeouts or 504 responses)
• Model availability issues (404 or specific error messages)
• Rate limiting (429 responses)

5.3 Best Practices Beginner

Writing Effective Prompts

• Be specific - Clearly define what you want, including format, structure, and purpose
• Provide context - Include relevant background information
• Use examples - When possible, include examples of desired output
• Break down complex tasks - Use chaining for multi-step problems

cody 'Write a sort function'

cody 'Write a JavaScript function that sorts an array of objects by a specific property. The function should:
1. Take an array and a property name as parameters
2. Handle nested properties using dot notation
3. Support ascending and descending order
4. Handle missing properties gracefully
Include examples of the function in use.'

Performance Optimization

• Limit input size - Extract only relevant portions of large files
• Use appropriate personas - Match the persona to the task type
• Cache responses - Save outputs for frequently used queries
• Set appropriate timeouts - Increase for complex tasks

Integration Tips

• Create aliases - For frequently used commands
• Use in git hooks - For automated code reviews
• Combine with other tools - Integrate with grep, sed, awk for powerful workflows
• Create shell functions - For complex, multi-step processes

# Example shell function for code review
codereview() {
    git diff $1 | cody "Review this code change and highlight potential issues"
}

# Usage: codereview HEAD~3

7.1 Custom System Prompts

Advanced users can customize system prompts to create highly specialized AI personas:

export EXPERT_SYSTEM_PROMPT="You are an expert in cybersecurity, specializing in code security reviews. 
You focus on identifying security vulnerabilities including:
- SQL injection
- XSS vulnerabilities
- CSRF issues
- Authentication flaws
- Authorization problems
- Data exposure risks
For each vulnerability found, explain the issue, its potential impact, and suggest a fix with code example."

Usage:

cat web_app.js | expert 'Perform a security review of this code'

7.2 Automating Development Workflows

Integrate CodyCodes into your development workflow with git hooks:

#!/bin/bash
# Pre-commit hook for automated code review
# Save as .git/hooks/pre-commit and make executable

source ~/codycodes_env.sh

# Get staged files
FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(js|py|ts|tsx|jsx)
                )

if [ -n "$FILES" ]; then
    for FILE in $FILES; do
        echo "Reviewing $FILE..."
        REVIEW=$(git show ":$FILE" | cody "Review this code for bugs, security issues, and code style problems. Be concise.")
        echo "$REVIEW" > "code_reviews/$(basename "$FILE").review.md"
    done
    
    read -p "Code reviews generated. Continue with commit? (y/n) " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        exit 1
    fi
fi

exit 0

Conclusion

SuperDuck.AI CLI is a powerful tool that brings AI capabilities directly to your terminal. By mastering the techniques in this tutorial series, you can integrate AI assistance seamlessly into your workflow, whether you're coding, writing, or analyzing data.

Remember that effective prompts are key to getting the best results. Be specific, provide context, and consider using different personas for different tasks. For complex workflows, break tasks down and use chaining to create powerful multi-step processes.

As you become more comfortable with the CLI, explore creating custom personas and integrating CodyCodes into your scripts and automation tools. This will unlock even more productivity benefits and help you leverage AI throughout your development process.