Codestin Search App

Codestin Search App https://commandcode.ai/docs/to-be-deleted/why-command-code/ import { generateMetadata } from '@/lib/generate-metadata'; # Why Command Code? Because you're still teaching your coding agent how to code in every session. You've felt the friction when you start coding with coding agents and ask it to build a CLI it gives you yargs because that's what "most developers" use. But assume you don't use yargs you use commander. You spend more time prompt engineering than building. This is the state of AI coding tools right now they have powerful models but zero memory about your preferences and taste. Every other coding agent treats you like a first-day intern. You have to: - Specify your stack: I use pnpm, tsup, and ESM. Not npm in every session. - Nitpick the details: Wait, why are you using yargs? I use commander for building CLIs. - Repeat yourself: In the next session you have to do it all again because the agent remembers nothing. Command Code ends this loop with Taste. We know this pain because we lived it. We watched our own productivity drown in repetitive corrections, teaching the same agent the same preferences day after day, just to get code that almost felt right. Taste is a meta neuro-symbolic reasoning space with continuous reinforcement learning (RL). We combined reasoning with neural intuition to create an invisible architecture of choices. - **Continuously learning** side learns the texture of your code (explicit & implicit feedback) - **Meta Neuro-Symbolic space** enforces the invisible logic of your choices. - **Reflective Context Engineering** of a self-aware RL feedback loop to build skills. Codestin Search App https://commandcode.ai/docs/to-be-deleted/usage-limits/ import { generateMetadata } from '@/lib/generate-metadata'; # Usage & Limits Command Code usage & limits. Codestin Search App https://commandcode.ai/docs/to-be-deleted/pricing/ import { generateMetadata } from '@/lib/generate-metadata'; # Pricing Command Code pricing. Codestin Search App https://commandcode.ai/docs/to-be-deleted/how-it-works/ import { generateMetadata } from '@/lib/generate-metadata'; import { TasteDemo } from '@/components/taste-demo'; # How Taste works Taste is a living model of your coding preferences. It watches your corrections and builds an invisible architecture of your choices. ## You Teach by Doing Once you start coding, Command Code will learn your preferences from your corrections. Every time you correct Command Code's output, it learns. Every time you state a preference, it remembers. Every time you refactor something, it notices the pattern. ```bash > I prefer bun instead of npm ``` Your preferences are saved in `.commandcode/taste/taste.md` so that next time you code, it will use bun instead of npm. ## The Neuro-Symbolic Engine Taste is a meta neuro-symbolic reasoning space with continuous reinforcement learning (RL). We combined reasoning with neural intuition to create an invisible architecture of choices. - **Continuously learning** side learns the texture of your code (explicit & implicit feedback) - **Meta Neuro-Symbolic space** enforces the invisible logic of your choices. - **Reflective Context Engineering** of a self-aware RL feedback loop to build skills. Neuro-Symbolic Formula

## How `taste.md` works When you enable taste learning, Command Code will create a `taste.md` file in your `.commandcode/taste/` directory. ```bash .commandcode/ └── taste/ ├── taste.md # Main taste profile ├── cli/ # CLI-specific learnings ├── typescript/ # TypeScript preferences └── architecture/ # Architecture patterns ``` ### 1. Learning from explicit preferences Tell Command Code what you prefer: ```bash > Please always use TypeScript for new files > I prefer functional components over class components > Use async/await instead of promises ``` Command Code remembers these preferences and applies them automatically. ### 2. Learning from corrections When you correct Command Code's output, it learns: ```bash > Actually, I prefer const over let > Can you use arrow functions instead? > This should be a functional component ``` Every correction teaches Command Code more about your preferences. ### 3. Confidence scores Taste rules have confidence scores betweet 0.0 to 1.0. This means: - One-off preferences don't become rules - Repeated patterns become stronger rules - Your taste profile gets better over time --- ## Next steps - Explore the [Taste Studio](/studio) to visualize your taste and manage your learnings. - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/installation/ import { generateMetadata } from '@/lib/generate-metadata'; # Installation Guide This installation guide will get you started with Command Code in 90 seconds. ```bash {{ title: 'npm' }} npm i -g command-code ``` ```bash {{ title: 'pnpm' }} pnpm i -g command-code ``` ```bash {{ title: 'yarn' }} yarn global add command-code ``` ```bash cmd auth login ``` ```bash Terminal asks: Would you like to sign in? (y/n) → Type y and hit Enter. ``` ```bash > Open the authentication page? (y/n) → Type y and hit Enter. ``` Command Code Login

Your browser opens to the API keys page. Click "Generate API Key", **copy the API key**. Command Code Login

Return to your terminal and paste the key, press Enter. You're authenticated. Command Code Login

## Next Steps Now you're ready to start coding with Command Code. - **[Quickstart](/command-code/quickstart)** - Get started with Command Code - **[Commands](/command-code/commands)** - CLI command reference - **[Command Code Studio](/command-code/studio)** - Visualize and manage your taste - **[Examples](/command-code/examples)** - See Command Code in action Codestin Search App https://commandcode.ai/docs/to-be-deleted/features/ import { generateMetadata } from '@/lib/generate-metadata'; # Features Your coding agent should be as capable as you are. Here's what Command Code brings to your terminal. | Feature | Description | | --- | --- | | [Taste](/features/taste) | Stop repeating yourself. Command Code learns your patterns once. | | [Resume](/features/resume) | Pick up where you left off. No context lost between sessions. | | [Images](/features/images) | Drop a screenshot, get code. Vision-native debugging and generation. | | [@ Mentions](/features/mentions) | Reference any file, function, or symbol directly. Precision context. | | [Tools](/features/tools) | In built tools for Web Search. | | [Studio](/features/studio) | Visualize and manage your taste. See how Command Code is learning from your conversations. | ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/ import { generateMetadata } from '@/lib/generate-metadata'; # Commands This section contains a complete reference for all Command Code commands. --- ## CLI Commands Explore the CLI commands to start an interactive session or run a one-time task. - [`cmd`](/commands/cmd) - Start interactive session - [`cmd "task"`](/commands/cmd-task) - Run a one-time task - [`cmd auth login`](/commands/auth-login) - Authenticate - [`cmd auth logout`](/commands/auth-logout) - Log out --- ## Interactive Commands Available during chat sessions (type `/` followed by the command) - [`/init`](/commands/init) - Initialize AGENTS.md - [`/memory`](/commands/memory) - Manage project memory - [`/taste`](/commands/taste) - Manage taste learning - [`/resume`](/commands/resume) - Resume a past conversation - [`/clear`](/commands/clear) - Clear conversation history - [`/share`](/commands/share) - Share conversation - [`/unshare`](/commands/unshare) - Stop sharing - [`/agents`](/commands/agents) - Manage agents - [`/provider`](/commands/provider) - Select provider - [`/compact`](/commands/compact) - Compact conversation history - [`/help`](/commands/help) - Show commands - [`/exit`](/commands/exit) - Exit session --- ## Taste Commands Explore the taste commands to manage your taste learning. - [`npx taste push`](/commands/taste/push) - Push taste profile to Command Code registry - [`npx taste pull`](/commands/taste/pull) - Pull taste profile from Command Code registry - [`npx taste list`](/commands/taste/list) - List taste profiles - [`npx taste delete`](/commands/taste/delete) - Delete taste profile - [`npx taste lint`](/commands/taste/lint) - Lint taste profile - [`npx taste open`](/commands/taste/open) - Open taste profile in editor - [`npx taste help`](/commands/taste/help) - Show taste help `npx cmd taste` and `npx taste` are functionally the same, but we recommend using `npx taste`. --- ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/ import { generateMetadata } from '@/lib/generate-metadata'; import { Resources } from '@/components/Resources'; ![command-code](/docs/top.png) ### Commad Code is the first coding agent that continuously learns your *taste* of writing code. LLMs x Meta Neuro-Symbolic AI x Continuous Reinforcement Learning = Acquired Taste. --- ## Command Code: The Next Frontier in AI Coding

## Example ```bash > Build a CLI for generating UUIDs ``` ```ts > I always use commander, not yargs ``` From now on, Command Code will use commander to build the CLI. You'll see your taste profile growing in `.commandcode/taste/taste.md`. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/features/resume/ import { generateMetadata } from '@/lib/generate-metadata'; # Resume This feature is for conversations that you want to continue from where you left off. It's like a time machine for your conversations with full context intact. --- ## Why it matters That complex refactoring you started yesterday. It's still in your conversation history. Resume lets you pick up any past session with full context intact so that you don't have to rebuild context. ## Quick Start ```ts /resume ``` Select the past session to resume and Command Code will pick up where you left off. Resume

## Examples ```ts cmd > /resume ``` ```md Recent sessions: > 1. 2d ago - Building auth middleware 2. 3d ago - Refactoring CLI to use commander ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/features/mentions/ import { generateMetadata } from '@/lib/generate-metadata'; # Mentions This feature is for referencing any files directly. Reference any file with @. The agent understands exactly what you mean and doesn't hallucinate paths. --- ## Why it matters You don't have to say "the auth file in the server directory," just reference it with `@server/auth.ts`. Mention any file in your project with `@`. ```ts > @server/auth.ts ```

Mention any file in your project with `@`

Command Code understands exactly what you mean and doesn't hallucinate paths. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/features/image/ import { generateMetadata } from '@/lib/generate-metadata'; # Image This feature is for debugging and generation. Drop screenshots, diagrams, mockups. Command Code's vision model reads them and acts. ## Why it matters Debugging a UI bug with screenshot and ask "why is this misaligned?" instead of describing it. Drag image into terminal: ```bash > [#Image1] Why is this button overflowing? ```

Command Code analyzes the screenshot, sees your Tailwind classes, and fixes it. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/whoami/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd whoami This command displays current user information for Command Code. ## Usage ```bash cmd whoami ``` This command displays current user information for Command Code. ## How It Works ```bash 1. Run `cmd whoami` 2. Terminal displays current user information ``` ```bash User Information: ℹ Name: [Your Name] ℹ Email: [Your Email] ℹ Username: [Your Username] ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/update/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd update This command updates Command Code to the latest version. ## Usage ```bash cmd update ``` This command updates Command Code to the latest version. ## How It Works ```bash 1. Run `cmd update` 2. Terminal updates Command Code to the latest version ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/unshare/ import { generateMetadata } from '@/lib/generate-metadata'; # /unshare This command removes the public share link for the current conversation and makes it private again. --- ## Usage ```bash /unshare ``` This command removes the public share link for the current conversation and makes it private again. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/unshare` command and it will remove the public share link for the current conversation and make it private again 3. Command Code will show you a confirmation message ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/status/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd status This command displays authentication status for Command Code. ## Usage ```bash cmd status ``` This command displays authentication status for Command Code by checking if you are logged in. ## How It Works ```bash 1. Run `cmd status` 2. Terminal displays authentication status ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/taste/ import { generateMetadata } from '@/lib/generate-metadata'; # taste This command manages Taste learning and usage during interactive sessions. --- ## Usage ```bash /taste ``` This command toggles Taste learning and usage during interactive sessions. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/taste` command to toggle Taste learning 3. Command Code will show you your status of Taste learning enabled or disabled ``` Taste Command

## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/resume/ # /resume This command resumes a past conversation with full context. --- ## Usage ```bash /resume ``` This command resumes a past conversation with full context. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/resume` command to resume a past conversation 3. Command Code will show you a numbered list of recent conversations 4. Select the conversation you want to resume by entering the number ``` Resume Command

### Project Memory Project memory is a persistent memory for the current project. It is stored in the `.AGENTS.md` file. ### User Memory User memory is a persistent memory for the current user. It is stored in the `~/.commandcode/AGENTS.md` file. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/logout/ # cmd auth logout This command logs you out of Command Code and removes your stored API key from local storage. ## Usage ```bash cmd auth logout ``` This command logs you out of Command Code and removes your stored API key from local storage. This is useful when switching accounts or removing credentials from a shared machine. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/login/ # cmd auth login This command authenticates you with Command Code. ## Usage ```bash cmd auth login ``` This command authenticates you with Command Code. This is required before first use. The command will open your browser to the authentication page. ## How It Works ```bash 1. Run `cmd auth login` 2. Terminal asks: Would you like to sign in? (y/n) (y/n)` 3. Type `y` and hit Enter 4. Terminal asks: Open the authentication page? (y/n) 5. Select `Yes/No` in the terminal and press Enter 6. Your browser opens to the authentication page 7. Click Generate API Key and copy the API key 8. Paste the API key back in the terminal 9. Done! You'll see: `✓ Authenticated` ``` ## Troubleshooting If you get an error message, try running theses commands in the terminal: ```bash cmd auth logout ``` ```bash cmd auth login ``` If you still get an error message, please reach out to us on our [Discord community](https://langbase.com/discord). ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/init/ import { generateMetadata } from '@/lib/generate-metadata'; # /init This command initializes the `AGENTS.md` file for the current project inside your Command Code session. ## Usage ```bash /init ``` This command initializes the `AGENTS.md` file in your project directory when you are inside the Command Code session. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/init` command 3. Command Code initializes the `AGENTS.md` file in your project directory ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/info/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd info This command displays system information for Command Code. ## Usage ```bash cmd info ``` This command displays system information for Command Code. ## How It Works ```bash 1. Run `cmd info` 2. Terminal displays system information ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/help/ import { generateMetadata } from '@/lib/generate-metadata'; # /help This command shows all available interactive commands. --- ## Usage ```bash /help ``` This command shows all available interactive commands. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/help` command 3. Command Code will show you the list of available interactive commands ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/exit/ import { generateMetadata } from '@/lib/generate-metadata'; # /exit This command exits the Command Code session. --- ## Usage ```bash /exit ``` This command exits the Command Code session. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/exit` command 3. Command Code will exit the session ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/config/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd config This command manages CLI configuration for Command Code. ## Usage ```bash cmd config ``` The `config` command allows you to view, set, get, and reset configuration values for Command Code. ## Commands ### List all configuration values View all currently set configuration values: ```bash cmd config list ``` ### Get a configuration value Retrieve the value of a specific configuration key: ```bash cmd config get ``` ### Set a configuration value Set or update a configuration value: ```bash cmd config set ``` ### Reset all configuration Clear all configuration values and restore defaults: ```bash cmd config reset ``` This will remove all your custom configuration settings. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/compact/ import { generateMetadata } from '@/lib/generate-metadata'; # /compact This command summarizes conversation history to preserve context while saving tokens. ## Usage ```bash /compact ``` This command summarizes conversation history to preserve context while saving tokens. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/compact` command 3. Command Code will summarize the conversation history and preserve the context ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/cmd/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd This command starts an interactive Command Code session in your current directory. --- ## Usage ```bash cmd ``` This command starts an interactive Command Code session with your project's context already loaded. ## Available Flags To see all available flags for the `cmd` command, use: ```bash cmd --help ``` ## Flags - ### `--version` or `-V` This flag outputs the version number for Command Code. ```bash cmd --version # or cmd -V ``` - ### `--resume` or `-r` This flag resumes a list of recent conversations and lets you resume any session with full context. ```bash cmd --resume ``` - ### `--continue` or `-c` This flag continues the last conversation with full context preserved. ```bash cmd --continue ``` - ### `--trust` or `-T` This flag auto-trusts the project by skipping the initial permission prompt. ```bash cmd --trust ``` - ### `--taste-learn` This flag enables taste learning for this session. ```bash cmd --taste-learn ``` - ### `--crud` This flag enables all CRUD permissions for the session. ```bash cmd --crud ``` - ### `--cru` This flag enables Create, Read, and Update permissions (no Delete). ```bash cmd --cru ``` - ### `--create` This flag enables Create permission only. ```bash cmd --create ``` - ### `--read` This flag enables Read permission only. ```bash cmd --read ``` - ### `--update` This flag enables Update permission only. ```bash cmd --update ``` - ### `--delete` This flag enables Delete permission only. ```bash cmd --delete ``` - ### `--help` or `-h` This flag displays help for the command. ```bash cmd --help ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/clear/ import { generateMetadata } from '@/lib/generate-metadata'; # /clear This command clears the conversation history and starts a fresh session. --- ## Usage ```bash /clear ``` This command clears the conversation history and starts a fresh session. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/clear` command to clear the conversation history 3. Command Code will clear the conversation history and start a fresh session ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/agents/ import { generateMetadata } from '@/lib/generate-metadata'; # /agents This command creates, edits, and manages specialized agents for specific tasks. --- ## Usage ```bash /agents ``` This command creates, edits, and manages specialized agents for specific tasks. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/agents` command 3. Command Code will open the agent management menu 4. You can create, edit, list, and switch between specialized agents 5. Agents are customized versions of Command Code with specific system prompts and behaviors for different tasks ``` Agents Command

### **You will able to see the following options:** 1. **Project** - Create a new agent for the current project - Describe the agent you want, and Command Code will create it. - This agent will be saved in the current project 2. **Personal** - Create a new agent for your personal use - Saved in your personal account - You can use this agent in any project you want

## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/workflows/ import { generateMetadata } from '@/lib/generate-metadata'; # Common workflows Each task in this document includes clear instructions, example commands, and best practices to help you get the most from Command Code. --- ## Understand new codebases You can quickly get a high-level overview of a codebase by navigating to the project root directory and starting Command Code. ```bash cd /path/to/project ``` ```bash cmd ``` ``` > give me brief overview of this codebase ``` ``` > explain the architecture patterns used in this codebase ``` ``` > how is payment system implemented in this codebase? ``` --- ## Tell your taste preferences You can tell Command Code your taste preferences to start building your profile while you code. Here are some examples of taste preferences you can tell Command Code related to your projects: ```bash > I always use pnpm instead of npm > I use TypeScript for CLI projects > I use tsup as build tool > I use commandar for CLI commands ``` You can use your taste profiles from anywhere by pushing them to the [Command Code Studio](https://commandcode.ai). ```bash npx taste push ``` Use `npx taste` commands to manage taste remotely. --- ## Resume previous conversations Suppose you've been working on a task with Command Code and need to continue where you left off in a later session. Command Code provides two options for resuming previous conversations: - `--continue` to automatically continue the most recent conversation - `--resume` to display a conversation picker ```bash cmd --continue ``` This immediately resumes your most recent conversation without any prompts. ```bash cmd --resume ``` This displays an interactive conversation selector with a clean list view showing: - Session summary (or initial prompt) - Metadata: time elapsed, message count, and git branch Use arrow keys to navigate and press Enter to select a conversation. Press Esc to exit. ```bash Modified # Messages Git Branch Summary ❯ 1. 20 hours ago 172 main Follow this practice and up... 2. 21 hours ago 13 main Add the common worflows her... 3. 22 hours ago 2 main does this {src/components/u... 4. 22 hours ago 82 main pnpm dlx shadcn@latest add ... 5. 1 day ago 2 ankit/features all tools support you have 6. 2 days ago 20 ankit/commands Update the content in each ... 7. 3 days ago 28 main For each command make a fol... 8. 6 days ago 11 main Why Command Code similar to... ``` --- ## Find relevant code Suppose you need to locate code related to a specific feature or functionality. ``` > find the files that handle authentication logic ``` ``` > how do these files handle authentication logic? ``` ``` > explain the authentication flow from front-end to database ``` --- ## Fix bugs efficiently Suppose you've encountered an error message and need to find and fix its source. ``` > I'm seeing an build error when I run `npm run build`. ``` ``` > I prefer to run `pnpm run build` after the change to see the build error ``` ``` > suggest a few ways to fix the bugs in @user.ts ``` ``` > update @user.ts to fix the bugs ``` --- ## Refactor code Suppose you need to update old code to use modern patterns and practices. ``` > find deprecated API endpoints in this codebase ``` ``` > suggest how to refactor @auth.ts to use OAuth2 authentication ``` ``` > refactor @auth.ts to use OAuth2 authentication ``` ``` > run tests for the refactored code ``` --- ## Write tests for your code Suppose you need to add tests for uncovered code. ``` > find functions and files in which are not covered by tests ``` ``` > I prefer to use Vitest for testing > I use __test__ prefix for test files ``` ``` > add tests for those functions and files ``` ``` > add test cases for edge conditions in those functions and files ``` ``` > run the new tests and fix any failures ``` --- ## Create pull requests Suppose you need to create a well-documented pull request for your changes. ``` > summarize the changes I've made to the authentication logic ``` ``` > create a pr for those changes ``` ``` > add information about the changes I've made to the PR description ``` --- ## Handle documentation Suppose you need to add or update documentation for your code. ``` > find functions without proper documentation in this codebase ``` ``` > add documentation for those functions in this codebase ``` ``` > improve the documentation with your review and suggestions ``` ``` > check if the documentation follows our project standards ``` --- ## Work with images It supports images in the conversation. You can use images to debug UI bugs, describe UI elements, and check for issues in diagrams. You can copy paste an image into the CLI or reference an image file in the conversation. ``` > Copy an image and paste it into the CLI ``` ``` > Reference an image file in the conversation ``` ``` > What are the UI elements used in this image describe them [#Image#1] ``` ``` > Genreate the CSS to match the same design shown in the image [#Image#1] ``` ``` > Analyze this diagram and suggest improvements [#Image#1] ``` ``` > Debug this UI bug with the image [#Image#1] ``` ``` > Analyze this schema and suggest modifications for the new feature [#Image#1] ``` --- ## Reference files and directories Use @ to quickly include files or directories in the conversation. ``` > Explain the logic in this file @auth.ts ``` The will help Command Code to understand the context of the file and provide better suggestions. ``` > Look at this directory @src/app and explain the structure? ``` This provides a directory listing with file information and explains the structure of the directory. --- ## Run parallel Command Code sessions with Git worktrees You can use Git worktrees to work on multiple tasks simultaneously using your taste preferences without giving lot of context again and again to ship code faster. Git worktrees allow you to check out multiple branches from the same repository into separate directories. Each worktree has its own working directory with isolated files, while sharing the same Git history. You can learn more about Git worktrees in the [official Git worktree documentation](https://git-scm.com/docs/git-worktree). ```bash git worktree add ../project-feature-auth -b feature-auth ``` ```bash git worktree add ../project-auth auth-bugfix ``` This creates a new directory with a separate working copy of your repository. ```bash cd ../project-feature-auth ``` ```bash cmd ``` ```bash cd ../project-auth-bugfix ``` ```bash cmd ``` ```bash git worktree list ``` ```bash git worktree remove ../project-auth-bugfix ``` --- ## Ask Command Code about its capabilities Command Code has built-in access to its documentation and can answer questions about its own features and limitations. ### Example questions ``` > can you help me to create a pull requests? ``` ``` > What tools are available to you? ``` --- Codestin Search App https://commandcode.ai/docs/taste/ import { generateMetadata } from '@/lib/generate-metadata'; # Taste Taste is our meta neuro-symbolic AI model with continuous reinforcement learning (RL). We combine reasoning with neural intuition to create an invisible architecture of choices, we call taste. --- ## Taste: The Next Frontier in AI Coding

--- ## `taste-1` Introducing our meta neuro-symbolic AI model `taste-1` with continuous reinforcement learning (RL). We combine reasoning with neural intuition to create an invisible architecture of choices, we call taste. ![meta neuro-symbolic ai model taste-1](/docs/mns.png) - **Continuously learning** side learns the texture of your code (explicit & implicit feedback). - **Meta Neuro-Symbolic AI model `taste-1`** enforces your the invisible logic of your choices. - **Reflective Context Engineering** of a self-aware RL feedback loop to build skills. ✓ 10x faster coding, 2x faster code reviews, 5x fewer bugs. --- ## How to get started You can install Command Code by following these steps: **Step 1: Install Command Code** ```bash {{ title: 'npm' }} npm i -g command-code ``` ```bash {{ title: 'pnpm' }} pnpm i -g command-code ``` ```bash {{ title: 'yarn' }} yarn global add command-code ``` **Step 2: Login to Command Code** ```bash cmd login ``` **Step 3: Start coding with Command Code** ```bash cmd ``` Unlike traditional coding assistants that rely on generic best practices, Taste builds a personalized model of your team's code review patterns, style preferences, and architectural choices. It observes how you write, review, and merge code to develop an intuitive understanding of your quality standards and design philosophy. ## Taste Sharing and Portability The architecture of Taste is fundamentally built around the principle that taste should be transferable and composable. Your learned preferences should be trapped in a single project you can use them in other projects. ## Managing Taste with `npx taste` We've made sharing and managing taste profiles as simple as using Git. The `npx taste` CLI tool is your primary interface for pulling, pushing, and composing taste models which you can view in the [Command Code Studio](/studio/taste). ``` npx taste push --all ``` This pushes your entire project's taste to `commandcode.ai/username/taste`. ``` npx taste pull username/project-name ``` This pulls taste from remote to your local project. See the [taste commands reference](/taste/commands) for all available commands and options. --- ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/skills/ import { generateMetadata } from '@/lib/generate-metadata'; # Agent Skills Command Code supports Agent Skills - a lightweight, open standard for extending AI agents with specialized knowledge and workflows. --- ## What are Agent Skills? Agent Skills are modular, self-contained instruction sets that teach Command Code how to perform specific tasks. Each skill is a folder containing a `skill.md` file with metadata and step-by-step guidance. Think of skills as expert playbooks that Command Code can reference when needed. Instead of explaining the same process repeatedly, you define it once in a skill, and Command Code automatically applies it when appropriate. --- ## How Command Code implements skills? Command Code fully implements the [Agent Skills open standard](https://agentskills.io) with two storage locations: ### User-level skills (global) Stored in `~/.commandcode/skills/` and available across **all your projects**. Perfect for: - General development workflows - Exploratory workflows - Cross-project best practices ### Project-level skills (local) Stored in `.commandcode/skills/` within your project and **only available in that project**. Perfect for: - Project-specific patterns - Team conventions - Architecture guidelines - Domain-specific workflows --- ## Quickstart ### Create your first skill **User-level skill:** ```bash mkdir -p ~/.commandcode/skills/code-review cat > ~/.commandcode/skills/code-review/SKILL.md << 'EOF' --- name: code-review description: Perform thorough code reviews checking for bugs, security issues, and best practices --- # Code Review Checklist When reviewing code, check: ## Security - [ ] No hardcoded credentials or API keys - [ ] Input validation on all user data - [ ] Proper authentication and authorization ## Code Quality - [ ] Clear, descriptive variable names - [ ] Functions do one thing well - [ ] No code duplication - [ ] Edge cases handled ## Performance - [ ] No unnecessary loops or operations - [ ] Efficient data structures - [ ] Database queries optimized ## Testing - [ ] Unit tests cover main functionality - [ ] Edge cases tested - [ ] Error conditions tested EOF ``` **Project-level skill:** ```bash mkdir -p .commandcode/skills/api-guidelines cat > .commandcode/skills/api-guidelines/SKILL.md << 'EOF' --- name: api-guidelines description: API design patterns and conventions for this project --- # API Guidelines ## Endpoint naming - Use plural nouns: `/users`, `/posts` - Use kebab-case: `/user-profiles` - Version in URL: `/v1/users` ## Response format \```json { "data": { ... }, "meta": { "count": 10, "page": 1 } } \``` ## Error handling - 400: Bad request (validation errors) - 401: Unauthorized - 403: Forbidden - 404: Not found - 500: Server error EOF ``` ### Browse and use skills Use the `/skills` slash command to view all available skills: ```bash # In Command Code session /skills ``` This shows: - All user-level skills with `(user)` label - All project-level skills with `(project)` label - Use **arrow keys** to navigate - Press **Enter** to open any skill in your editor - Press Esc to close Command Code automatically sees all your skills and uses them when relevant to the task. --- ## Skill format Every skill is a directory containing a `SKILL.md` file: ```text theme={null} my-skill/ ├── SKILL.md # Required: instructions + metadata ├── scripts/ # Optional: executable code ├── references/ # Optional: documentation └── assets/ # Optional: templates, resources ``` ### `SKILL.md` structure ```markdown theme={null} --- name: skill-name description: What this skill does and when to use it license: MIT (optional) compatibility: ["Requires git"] (optional) metadata: (optional) author: "team-name" version: "1.0" allowed-tools: ["Read", "Grep"] (optional) --- # Skill Instructions Step-by-step guidance for Command Code... ## When to use this skill Use this skill when... ## How to perform the task 1. First step... 2. Second step... ``` **Required fields:** - `name`: Short identifier (lowercase, hyphens only) - `description`: What the skill does and when to use it (max 1024 characters) **Optional fields:** - `license`: License information - `compatibility`: Environment requirements - `metadata`: Author, version, etc. - `allowed-tools`: Pre-approved tools (experimental) --- ## How it works Skills use **progressive disclosure** to manage context efficiently: 1. **Discovery**: Command Code loads only name + description of each skill at startup (\~100 tokens per skill) 2. **Activation**: When a task matches a skill's description, Command Code reads the full `SKILL.md` instructions 3. **Execution**: Command Code follows the instructions, optionally loading referenced files as needed This keeps Command Code fast while giving access to more context on demand. --- ## Next steps - [Learn more about Agent Skills](/skills/what-are-skills) and the open standard - [Manage your skills](/skills/manage) with the `/skills` command - Join our [Discord community](https://commandcode.ai/discord) for support Codestin Search App https://commandcode.ai/docs/quickstart/ import { generateMetadata } from '@/lib/generate-metadata'; # Quickstart: Command Code Welcome to Command Code! --- In this quickstart guide, we'll walk you through the steps to get up and running with Command Code, the AI-powered coding agent that learns your taste of coding style and preferences using both LLMs and continuous learning with meta neuro-symbolic model taste-1 Use your preferred package manager: ```sh {{ title: 'npm' }} npm i -g command-code ``` ```sh {{ title: 'pnpm' }} pnpm i -g command-code ``` ```sh {{ title: 'yarn' }} yarn global add command-code ``` Login with CommandCode.ai: Command Code is available globally as `command-code` or shorter alias `cmd` CLI. ```bash cmd login ``` 1. Run `cmd login` 2. Open auth page in browser (sign up or log in) 3. Generate your API key 4. Paste key in terminal 5. Select Provider: `Command Code` ``` ┌ Command Code Authentication │ ◇ Open the authentication page? — copy your API key and paste it here. │ Yes │ ◇ Copy/Paste your API key in the terminal: │ ************************************* │ ◇ Select provider │ Command Code (recommended) │ └ You are logged in. API key is stored in ~/.commandcode/auth.json file. ``` Now you're logged in. Let's try it out! Navigate to any project directory and start Command Code `cmd`: ```sh cd your-project ``` ```sh cmd ``` You can start by providing a prompt like this: ```md Build a date.js CLI with that tells ISO format of date. Use commander.js and pnpm. ``` You'll see that in your projects `.commancode/taste/taste.md` files and folders where `cmd` has started learning your coding taste. In the taste.md file, Command Code will have learned something like this: ```md # CLI - Use pnpm as package manager. Confidence: 0.50 - Use commander.js for CLI argument parsing. Confidence: 0.50 ``` Command Code will continuously learn your taste, and auto manage the taste files and folders. As your taste grows, you'll see Command Code taking your taste out of the main taste.md file into separate files and folders for better organization and reflective context engineering. Meaning only relevant taste context will be used for your coding sessions. For example, if you are working on a React component, only React-related taste context will be used. - You can press `Shift + Tab` to switch auto `accept edits on`. - You can press `Ctrl + C` to exit anytime. Please join our [Discord community](https://langbase.fyi/discordcmd) to share your feedback and get help. We're still in early days and figuring out the best interface for taste. Taste.md files and folders in your projects allow you full git versioning control. We also have a lot more meta learning on roadmap, help us shape it! --- ## Essential commands Here are the commands you'll use most: | Command | What it does | |---------|-------------| | `cmd` | Start interactive mode | | `/taste` | Toggle taste learning on/off | | `/share` | Create a shareable link for the thread | | `/unshare` | Stop sharing the thread | | `/resume` | Resume a past thread | | `/memory` | Manage project memory (persistent context) | | `/provider` | Select AI provider (currently support Command Code only) | | `/clear` | Clear the thread history | | `/help` | Show all available commands | --- Codestin Search App https://commandcode.ai/docs/enterprise/ import { generateMetadata } from '@/lib/generate-metadata'; # Command Code Enterprise Command Code offers an Enterprise edition designed for organizations that require enhanced security, compliance, and control over their development environment. If you want to ensure that your code and data never leaves your infrastructure, Command Code Enterprise is the solution for you. To get started with Command Code Enterprise: Reach out to our sales team at support@langbase.com. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/taste/push/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste push This command pushes a taste profile to the Command Code registry. --- ## Usage ``` npx taste push [package] ``` This command pushes a taste profile to the Command Code registry. If no package is specified, it will push the current package. ## Options - `-g, --global` - Push to global storage - `--remote` - Push to remote registry - `--all` - Push all packages - `--overwrite` - Overwrite target without prompting (default: interactive merge) ## How It Works ```bash 1. Command Code will push the taste profile to the Command Code Studio 2. View your taste profile in the Command Code Studio ``` ## Example ```bash {title: Push current package} npx taste push cli -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/taste/pull/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste pull This command pulls a taste profile from the Command Code registry. --- ## Usage ``` npx taste pull [package] ``` This command pulls a taste profile from the Command Code registry. If no package is specified, it will pull the current package. ## Options - `-g, --global` - Pull from global storage - `--remote` - Pull from remote registry - `--all` - Pull all packages - `--overwrite` - Overwrite local without prompting (default: interactive merge) ## How It Works ```bash 1. Command Code will pull the taste profile from the Command Code Studio 2. Merge or overwrite local taste profile based on your selection ``` ## Example ```bash {title: Pull current package} npx taste pull cli -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/taste/open/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste open This command opens a taste package in your editor. --- ## Usage ``` npx taste open ``` This command opens a taste package in your default editor for viewing or editing. ## Options - `-g, --global` - Open from global storage ## How It Works ```bash 1. Command Code will locate the package in local or global storage 2. Open the package files in your default editor ``` ## Example ```bash {title: Open global package} npx taste open cli -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/taste/lint/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste lint This command validates taste file format and structure. --- ## Usage ``` npx taste lint [package] ``` This command validates the format and structure of taste files. If no package is specified, it will lint the current package. ## Options - `-g, --global` - Lint global packages - `--all` - Lint all packages ## How It Works ```bash 1. Command Code will check the taste file format and structure 2. Report any validation errors or warnings ``` ## Example ```bash {title: Lint all packages} npx taste lint --all -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/taste/list/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste list This command lists available taste packages. --- ## Usage ``` npx taste list ``` This command lists available taste packages from local, global, or remote storage. ## Options - `-g, --global` - List global packages - `--remote` - List remote packages ## How It Works ```bash 1. Command Code will fetch available packages from the specified source 2. Display packages with their details and preferences count ``` ## Example ```bash {title: List global packages} npx taste list -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/taste/help/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste help This command displays help information for taste commands. --- ## Usage ``` npx taste help ``` This command displays help information for the taste CLI and its commands. If a command is specified, it shows detailed help for that command. ## Options - `-h, --help` - Display help for command - `-v, --version` - Output the version number ## Available Commands - `push [options] [package]` - Push packages from project to remote or global storage - `pull [options] [package]` - Pull packages from storage to project - `list [options]` - List available packages - `delete [options] ` - Delete a package - `lint [options] [package]` - Validate taste file format and structure - `open [options] ` - Open a package in your editor - `update` - Update taste CLI to the latest version - `help [command]` - Display help for command ## How It Works ```bash 1. Command Code will display the main help menu with all available commands 2. If a command is specified, show detailed help for that specific command ``` ## Example ```bash {title: Help for specific command} npx taste help push ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/to-be-deleted/commands/taste/delete/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste delete This command deletes a taste package. --- ## Usage ``` npx taste delete [package] ``` This command deletes a taste package from local or global storage. ## Options - `-g, --global` - Delete from global storage ## How It Works ```bash 1. Command Code will locate the package in local or global storage 2. Remove the package and all its associated files ``` ## Example ```bash {title: Delete global package} npx taste delete cli -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/taste/what-is-taste/ import { generateMetadata } from '@/lib/generate-metadata'; # What is Taste? We have built our first meta neuro-symbolic AI model `taste-1` with continuous reinforcement learning (RL). We combine reasoning with neural intuition to create an invisible architecture of choices. --- `taste-1` Introducing our meta neuro-symbolic AI model `taste-1` with continuous reinforcement learning (RL). We combine reasoning with neural intuition to create an invisible architecture of choices, we call taste. ![meta neuro-symbolic ai model taste-1](/docs/mns.png) - **Continuously learning** side learns the texture of your code (explicit & implicit feedback). - **Meta Neuro-Symbolic AI model `taste-1`** enforces your the invisible logic of your choices. - **Reflective Context Engineering** of a self-aware RL feedback loop to build skills. Codestin Search App https://commandcode.ai/docs/taste/manage/ import { generateMetadata } from '@/lib/generate-metadata'; # Manage Taste Taste sharing and managing taste profiles is as simple as using Git via the `npx taste` CLI. --- ## How to get started You can install Command Code by following these steps: **Step 1: Install Command Code** ```bash {{ title: 'npm' }} npm i -g command-code ``` ```bash {{ title: 'pnpm' }} pnpm i -g command-code ``` ```bash {{ title: 'yarn' }} yarn global add command-code ``` **Step 2: Login to Command Code** ```bash cmd login ``` **Step 3: Start coding with Command Code** ```bash cmd ``` This unified interface lets you push your learned preferences to the [Command Code Studio](/studio/taste), pull taste from teammates or the community, and compose multiple taste profiles to match your workflow. You can push your taste to the Command Code Studio and share it with your team. ```bash npx taste push --all ``` You can pull a taste profile from the Command Code Studio to your different projects. ```bash npx taste pull ``` You can list all the taste profiles available in the Command Code Studio. ```bash npx taste list ``` You can open a specific taste profile in Command Code Studio. ```bash npx taste open ``` See the [taste commands reference](/taste/commands) for detailed command documentation. Codestin Search App https://commandcode.ai/docs/taste/commands/ import { generateMetadata } from '@/lib/generate-metadata'; # Taste Reference Complete reference for all `npx taste` commands. Manage your taste packages across project, global, and remote. --- ## Quick Reference | Command | Description | | ------- | ----------- | | [`taste push`](/taste/commands/push) | Push project or individual packages to remote or global | | [`taste pull`](/taste/commands/pull) | Pull packages from remote or global | | [`taste list`](/taste/commands/list) | List all available packages | | [`taste lint`](/taste/commands/lint) | Validate package format and structure | | [`taste open`](/taste/commands/open) | Open packages in your default editor | `npx taste` and `cmd taste` are equivalent. `cmd taste` requires global installation (`npm i -g command-code`). We recommend using `npx taste`. --- ## Taste Packages A taste package is a collection of learnings organized by category (e.g., `cli`, `typescript`, `architecture`). Each package contains a `taste.md` file with preferences and patterns Command Code has learned. Taste packages are of three types: ### Project Project specific taste packages are automatically learned and stored in your project. - **Path**: `.commandcode/taste/` - **Use case**: Learnings unique to this codebase ### Global Your personal taste packages accessible across all projects on your machine. Use the `-g` flag to push/pull global packages. - **Path**: `~/.commandcode/taste/` - **Use case**: Your personal taste that follows you across projects ### Remote Taste packages on cloud under your profile at [commandcode.ai](https://commandcode.ai). - **Path**: `commandcode.ai/username/taste` - **Use case**: Team sharing, backup, sync across machines, public packages By default `npx taste push` and `npx taste pull` interact with your remote packages. --- ## Project Taste vs Individual Packages You can either push/pull your entire project taste or individual packages. ### Project Taste (`push --all`) When you use `push --all`, Command Code pushes your **entire project's taste** as a single unit: ```bash npx taste push --all ``` - Bundles **all packages** from your project together - Project name is derived from your current directory - Pushed to remote under your namespace ### Individual Package (`push `) When you push a specific package, only that **single package** is uploaded: ```bash npx taste push cli npx taste push myorg/cli ``` - Pushes **one package** at a time - You choose the namespace (personal or organization) - Great for sharing specific learnings with others --- ## Common Workflows ### Share your project taste with the team Push all your project's learnings to remote. ```bash npx taste push --all ``` Others can pull the project taste to their local setup. ```bash npx taste pull username/project-name ``` ### Use your taste across projects (via global) Save a package to your global for use in any project. ```bash npx taste push cli -g ``` In a different project, pull from global. ```bash npx taste pull cli -g ``` ### Backup and sync via remote Back up your taste to commandcode.ai. ```bash npx taste push --all ``` Pull your taste on any machine. ```bash npx taste pull username/project-name ``` --- ## File Structure ``` your-project/ └── .commandcode/ └── taste/ ├── taste.md # Main taste file ├── cli/ │ └── taste.md # CLI-specific learnings ├── typescript/ │ └── taste.md # TypeScript preferences └── architecture/ └── taste.md # Architecture patterns ``` ``` ~/.commandcode/ └── taste/ ├── cli/ │ └── taste.md ├── react/ │ └── taste.md └── testing/ └── taste.md ``` --- ## Next steps - Learn about [`taste push`](/taste/commands/push) to upload your taste - View your packages in [Command Code Studio](/studio/taste) - Read about [what is taste](/taste/what-is-taste) Codestin Search App https://commandcode.ai/docs/studio/teams/ import { generateMetadata } from '@/lib/generate-metadata'; # Teams Teams are used to manage your team members and their permissions in Command Code. Codestin Search App https://commandcode.ai/docs/studio/usage/ import { generateMetadata } from '@/lib/generate-metadata'; # Usage Track your usage for every single request you make in Command Code. --- Navigate to the Usage tab in the Studio to see your usage. This shows you the total cost, and the total number of tokens used for each request. Usage

Click on a request to see the usage details. This shows you the each request's usage, the total cost, and the total number of tokens used.

Codestin Search App https://commandcode.ai/docs/studio/taste/ import { generateMetadata } from '@/lib/generate-metadata'; # Taste Studio Taste Studio is used to manage your taste preferences. You can manage them via `npx taste` commands. --- You can use Taste Studio to: - **View Taste Profile**: See your taste categories (cli, react, typescript) - **Push taste profiles**: Use `npx taste push` to push taste to studio - **Pull taste profiles**: Use `npx taste pull` to pull taste from studio - **Team management**: Invite org members to share @teammate-username/taste You can push a taste profile to the Command Code Studio to share it with your team.

```bash npx taste push ``` Navigate to the Taste tab in the Studio to see all your taste profiles. Taste Studio

You can pull a taste profile from the Command Code Studio to your different projects. Install the taste profile

```bash npx taste pull ``` Click on a taste profile to explore it. This shows you the taste profile's details, the `taste.md` file, and the confidence scores. Taste Studio

Codestin Search App https://commandcode.ai/docs/studio/api-keys/ import { generateMetadata } from '@/lib/generate-metadata'; # API Keys API Keys are used to authenticate you for using Command Code. --- ## How to get your API key You can get your API key by following these steps: Login to your account on [Command Code](https://commandcode.com/). Navigate to your [API keys page](https://studio.commandcode.com/api-keys). Command Code API keys

Click on the `Generate API key` button to generate a new API key. Command Code API keys

From here you can manage your existing API keys. Command Code API keys

Codestin Search App https://commandcode.ai/docs/skills/what-are-skills/ import { generateMetadata } from '@/lib/generate-metadata'; # What are Agent Skills? > Agent Skills are a lightweight, open format for extending AI agent capabilities with specialized knowledge and workflows. At its core, a skill is a folder containing a `SKILL.md` file. This file includes metadata (`name` and `description`, at minimum) and instructions that tell an agent how to perform a specific task. Skills can also bundle scripts, templates, and reference materials. ```text my-skill/ ├── SKILL.md # Required: instructions + metadata ├── scripts/ # Optional: executable code ├── references/ # Optional: documentation └── assets/ # Optional: templates, resources ``` --- ## How skills work? Skills use **progressive disclosure** to manage context efficiently: 1. **Discovery**: At startup, agents load only the name and description of each available skill, just enough to know when it might be relevant. 2. **Activation**: When a task matches a skill's description, the agent reads the full `SKILL.md` instructions into context. 3. **Execution**: The agent follows the instructions, optionally loading referenced files or executing bundled code as needed. This approach keeps agents fast while giving them access to more context on demand. --- ## The SKILL.md file Every skill starts with a `SKILL.md` file containing YAML frontmatter and markdown instructions: ```markdown --- name: pdf-processing description: Extract text and tables from PDF files, fill forms, merge documents. --- # PDF Processing ## When to use this skill Use this skill when the user needs to work with PDF files... ## How to extract text 1. Use pdfplumber for text extraction... ## How to fill forms ... ``` The following frontmatter is required at the top of `SKILL.md`: * `name`: A short identifier * `description`: When to use this skill The markdown body contains the actual instructions and has no specific restrictions on structure or content. This simple format has some key advantages: * **Self-documenting**: A skill author or user can read a `SKILL.md` and understand what it does, making skills easy to audit and improve. * **Extensible**: Skills can range in complexity from just text instructions to executable code, assets, and templates. * **Portable**: Skills are just files, so they're easy to edit, version, and share. --- ## Command Code implementation Command Code stores skills in two locations: ### User-level skills (global) **Location:** `~/.commandcode/skills/` Available across all your projects. Perfect for personal preferences and general workflows. ```bash mkdir -p ~/.commandcode/skills/code-review cat > ~/.commandcode/skills/code-review/SKILL.md << 'EOF' --- name: code-review description: Perform thorough code reviews checking for bugs, security, and best practices --- # Code Review Check for: - Security issues - Code quality - Performance - Testing EOF ``` ### Project-level skills (local) **Location:** `.commandcode/skills/` (in your project root) Available only within that specific project. Perfect for team conventions and project-specific patterns. ```bash mkdir -p .commandcode/skills/api-guidelines cat > .commandcode/skills/api-guidelines/SKILL.md << 'EOF' --- name: api-guidelines description: API design patterns and conventions for this project --- # API Guidelines Follow these patterns when creating APIs... EOF ``` --- ## Browsing skills Use the `/skills` slash command in Command Code to browse all available skills: ```bash # In Command Code session /skills ``` This opens an interactive menu showing: - All your user-level skills marked with `(user)` - All project-level skills marked with `(project)` - Skill names and descriptions Navigate with arrow keys, press Enter to open a skill in your editor, or Esc to close. --- ## Specification ### Frontmatter (required) ```md --- name: skill-name description: A description of what this skill does and when to use it. --- ``` With optional fields: ```md --- name: pdf-processing description: Extract text and tables from PDF files, fill forms, merge documents. license: Apache-2.0 compatibility: Requires pdfplumber and PyPDF2 packages metadata: author: example-org version: "1.0" allowed-tools: Read Bash(python:*) --- ``` | Field | Required | Constraints | | --------------- | -------- | ----------------------------------------------------------------------------------------------------------------- | | `name` | Yes | Max 64 characters. Lowercase letters, numbers, and hyphens-separated only. Must not start or end with a hyphen. | | `description` | Yes | Max 1024 characters. Non-empty. Describes what the skill does and when to use it. | | `license` | No | License name or reference to a bundled license file. | | `compatibility` | No | Max 500 characters. Indicates environment requirements (packages, system tools, network access, etc.). | | `metadata` | No | Arbitrary key-value mapping for additional metadata (author, version, etc.). | | `allowed-tools` | No | Space-delimited list of pre-approved tools the skill may use. (Experimental) | #### `name` field The required `name` field: * Must be 1 to 64 characters * May only contain lowercase alphanumeric characters and hyphens (`a-z` and `-`) * Must not start or end with `-` * Must not contain consecutive hyphens (`--`) * Must match the parent directory name **Valid examples:** ```md name: pdf-processing name: data-analysis name: code-review ``` **Invalid examples:** ```md name: PDF-Processing # uppercase not allowed name: -pdf # cannot start with hyphen name: pdf--processing # consecutive hyphens not allowed ``` #### `description` field The required `description` field: * Must be 1 to 1024 characters * Should describe both what the skill does and when to use it * Should include specific keywords that help Command Code identify relevant tasks **Good example:** ```md description: Extracts text and tables from PDF files, fills PDF forms, and merges multiple PDFs. Use when working with PDF documents or when the user mentions PDFs, forms, or document extraction. ``` **Poor example:** ```md description: Helps with PDFs. ``` #### `license` field The optional `license` field specifies the license applied to the skill: ```md license: MIT ``` ```md license: Proprietary. See LICENSE.txt for complete terms ``` #### `compatibility` field The optional `compatibility` field indicates environment requirements: ```md compatibility: Requires git, docker, and jq ``` ```md compatibility: Designed for Command Code. Requires internet access. ``` Most skills do not need the `compatibility` field. #### `metadata` field The optional `metadata` field stores additional properties: ```md metadata: author: example-org version: "1.0" maintainer: team@example.com ``` #### `allowed-tools` field The optional `allowed-tools` field lists pre-approved tools (experimental): ```md allowed-tools: Bash(git:*) Bash(jq:*) Read Grep ``` ### Body content The markdown body after the frontmatter contains the skill instructions. There are no format restrictions. Write whatever helps Command Code perform the task effectively. Recommended sections: * **When to use this skill**: Clear triggers for activation * **Step-by-step instructions**: Detailed guidance * **Examples**: Input/output examples * **Common edge cases**: Known pitfalls and solutions Keep your main `SKILL.md` under 500 lines. Move detailed reference material to separate files in `references/`. --- ## Optional directories ### `scripts/` Contains executable code that agents can run. Scripts should: * Be self-contained or clearly document dependencies * Include helpful error messages * Handle edge cases gracefully ```text my-skill/ ├── SKILL.md └── scripts/ ├── extract.py └── process.sh ``` ### references/ Contains additional documentation that agents can read when needed: ```text my-skill/ ├── SKILL.md └── references/ ├── API_REFERENCE.md ├── FORMS.md └── TROUBLESHOOTING.md ``` Keep individual reference files focused. Command Code loads these on demand, so smaller files mean less context usage. ### assets/ Contains static resources: ```text my-skill/ ├── SKILL.md └── assets/ ├── template.json ├── diagram.png └── schema.sql ``` --- ## Progressive disclosure in action Here's how Command Code uses a skill: **Startup (all skills):** ``` Skills loaded: code-review, api-guidelines, testing-patterns Total tokens: ~300 (just names + descriptions) ``` **User asks:** "Review this code for security issues" **Command Code thinks:** "This matches 'code-review' skill description" **Command Code loads:** ```markdown --- name: code-review description: Perform thorough code reviews... --- # Code Review Checklist ## Security - [ ] No hardcoded credentials - [ ] Input validation ... ``` **Result:** Command Code follows the security checklist from the skill, ensuring consistent, thorough reviews. --- ## Standard compliance Command Code fully implements the [Agent Skills open standard](https://agentskills.io). Skills you create are: * **Portable**: Work with any agent that supports the standard * **Versionable**: Track changes with Git * **Shareable**: Publish for your team or community * **Auditable**: Plain text files anyone can read --- ## Next steps * [Manage your skills](/skills/manage) in Command Code * Join our [Discord community](https://commandcode.ai/discord) for support Codestin Search App https://commandcode.ai/docs/skills/manage/ import { generateMetadata } from '@/lib/generate-metadata'; # Managing Agent Skills Learn how to create, browse, edit, and organize your Agent Skills in Command Code. --- ## Browsing skills Use the `/skills` slash command to view all your skills: ```bash # In Command Code interactive session /skills ``` This opens an interactive menu showing: * All user-level skills with `(user)` label * All project-level skills with `(project)` label * Skill names and descriptions **Navigation:** - ↑/↓ arrow keys to navigate - Enter to open skill in your editor - Esc to close and return to conversation --- ## Creating skills ### User-level skills User-level skills are available across **all your projects**. **Location:** `~/.commandcode/skills/` ```bash # Create the directory mkdir -p ~/.commandcode/skills/my-skill # Create the SKILL.md file cat > ~/.commandcode/skills/my-skill/SKILL.md << 'EOF' --- name: my-skill description: What this skill does and when to use it --- # My Skill Instructions for Claude... EOF ``` **Use cases:** - Personal coding preferences - General development workflows - Cross-project best practices - Your own code style guidelines **Example:** ```bash mkdir -p ~/.commandcode/skills/code-review cat > ~/.commandcode/skills/code-review/SKILL.md << 'EOF' --- name: code-review description: Perform thorough code reviews checking for bugs, security issues, and best practices --- # Code Review Checklist ## Security - [ ] No hardcoded credentials or API keys - [ ] Input validation on all user data - [ ] Proper authentication and authorization ## Code Quality - [ ] Clear, descriptive variable names - [ ] Functions do one thing well - [ ] No code duplication ## Performance - [ ] No unnecessary loops - [ ] Efficient data structures - [ ] Optimized queries ## Testing - [ ] Unit tests cover main functionality - [ ] Edge cases tested - [ ] Error conditions handled EOF ``` ### Project-level skills Project-level skills are available only in **that specific project**. **Location:** `.commandcode/skills/` (in your project root) ```bash # Create the directory mkdir -p .commandcode/skills/my-skill # Create the SKILL.md file cat > .commandcode/skills/my-skill/SKILL.md << 'EOF' --- name: my-skill description: What this skill does and when to use it --- # My Skill Instructions for Claude... EOF ``` **Use cases:** - Project-specific patterns - Team conventions - Architecture guidelines - Domain-specific workflows **Example:** ```bash mkdir -p .commandcode/skills/api-guidelines cat > .commandcode/skills/api-guidelines/SKILL.md << 'EOF' --- name: api-guidelines description: API design patterns and conventions for this project --- # API Guidelines ## Endpoint naming - Use plural nouns: `/users`, `/posts` - Use kebab-case: `/user-profiles` - Version in URL: `/v1/users` ## Response format Always return JSON with this structure: \```json { "data": { ... }, "meta": { "count": 10, "page": 1 }, "errors": [] } \``` ## Error codes - 400: Bad request (validation errors) - 401: Unauthorized (missing/invalid token) - 403: Forbidden (insufficient permissions) - 404: Not found - 500: Server error ## Authentication All endpoints require Bearer token in Authorization header except: - POST /v1/auth/login - POST /v1/auth/register EOF ``` --- ## Editing skills ### Using the `/skills` command 1. Type `/skills` in Command Code 2. Navigate to the skill you want to edit 3. Press Enter This opens the `SKILL.md` file in your default editor (configured via `$EDITOR` environment variable). ### Manual editing You can also edit skills directly: ```bash # Edit user-level skill code ~/.commandcode/skills/my-skill/SKILL.md # Edit project-level skill code .commandcode/skills/my-skill/SKILL.md ``` After editing, the changes are immediately available - no restart required. --- ## Setting up your editor The `/skills` command uses your `$EDITOR` environment variable to open files. ### Configure $EDITOR ```bash # Add to ~/.bashrc and reload echo 'export EDITOR="code"' >> ~/.bashrc source ~/.bashrc ``` ```bash # Add to ~/.zshrc and reload echo 'export EDITOR="code"' >> ~/.zshrc source ~/.zshrc ``` ```bash # Set permanently (restart terminal after) setx EDITOR "code" ``` **Common editors:** - `code` - Visual Studio Code - `vim` - Vim - `nano` - Nano - `emacs` - Emacs - `subl` - Sublime Text - `atom` - Atom --- ## Organizing skills ### Single skill per directory Each skill must be in its own directory: ```text theme={null} .commandcode/skills/ ├── code-review/ │ └── SKILL.md ├── api-guidelines/ │ └── SKILL.md └── testing-patterns/ └── SKILL.md ``` ### Adding supporting files Skills can include additional files: ```text theme={null} my-skill/ ├── SKILL.md # Required ├── scripts/ # Executable code │ ├── process.py │ └── validate.sh ├── references/ # Additional docs │ ├── API_REFERENCE.md │ └── EXAMPLES.md └── assets/ # Templates, resources ├── template.json └── schema.sql ``` Reference these files in your `SKILL.md`: ```markdown theme={null} See [API Reference](references/API_REFERENCE.md) for details. Run the validation script: \```bash scripts/validate.sh \``` ``` --- ## Naming conventions ### Skill names * Use lowercase letters, numbers, and hyphens only * Max 64 characters * Must not start or end with hyphen * No consecutive hyphens **Good names:** ``` code-review api-guidelines testing-patterns commit-messages ``` **Bad names:** ``` CodeReview # uppercase not allowed code_review # underscores not allowed -code-review # cannot start with hyphen code--review # consecutive hyphens ``` ### Directory names The directory name must match the skill `name` field: ```text theme={null} code-review/ # Directory name └── SKILL.md # Must have: name: code-review ``` --- ## Troubleshooting ### Skills not appearing in `/skills` menu **Problem:** Skills don't show up in the menu **Solutions:** 1. Check directory structure: ```bash ls ~/.commandcode/skills/ ls .commandcode/skills/ ``` 2. Verify SKILL.md exists: ```bash cat ~/.commandcode/skills/my-skill/SKILL.md ``` 3. Validate frontmatter format: ```md --- name: my-skill description: A description --- ``` 4. Check for YAML syntax errors (missing quotes, invalid characters) 5. Ensure description is ≤1024 characters ### Editor not opening **Problem:** Pressing Enter in `/skills` doesn't open the file **Solutions:** 1. Check `$EDITOR` is set: ```bash echo $EDITOR ``` 2. Set `$EDITOR` if missing (see [Setting up your editor](#setting-up-your-editor)) 3. Verify editor is in PATH: ```bash which code # or your editor ``` ### Skill not being used by Command Code **Problem:** Command Code doesn't use a skill even though it's relevant **Solutions:** 1. Make the description more specific with keywords: ```md # Better description: Unit testing with Vitest. Use when writing tests, test files, or when user mentions testing, test coverage, or Vitest. # Less effective description: Testing ``` 2. Ensure the skill instructions are clear and actionable 3. Ask Command Code explicitly: "Use the testing-patterns skill to write tests" --- ## Best practices ### Writing effective descriptions Good descriptions help Command Code know when to use a skill: **Specific and keyword-rich:** ```md description: Extract text and tables from PDF files using pdfplumber. Use when user mentions PDFs, pdf files, document extraction, or needs to read PDF content. ``` **Too vague:** ```md description: PDF tools ``` ### Keep skills focused Each skill should do one thing well: **Focused:** - `code-review` - Code review checklist - `commit-messages` - Commit message format - `testing-patterns` - Testing conventions **Too broad:** - `development` - All development tasks ### Use progressive disclosure Keep `SKILL.md` concise. Move detailed content to `references/`: ```markdown theme={null} # API Guidelines Quick reference of our API patterns. For complete documentation, see: - [Authentication details](references/AUTH.md) - [Error handling guide](references/ERRORS.md) - [Versioning strategy](references/VERSIONING.md) ``` ### Version control Track your skills in Git: ```bash # Add skills to git git add .commandcode/skills/ # Commit git commit -m "Add API guidelines skill" # Share with team git push ``` Don't ignore `.commandcode/skills/` - these should be shared with your team. --- ## Next steps * [Learn more about Agent Skills](/skills/what-are-skills) * Join our [Discord community](https://commandcode.ai/discord) for support Codestin Search App https://commandcode.ai/docs/resources/pricing-limits/ import { generateMetadata } from '@/lib/generate-metadata'; # Pricing Limits Clear, honest pricing. No tricks. --- ## Individual Plans | Plan | Monthly Price | Monthly limits | |------|---------------|------------------| | Free | $10 (one-time) | Capacity based | | Pro | $15 | ~250 Premium Requests | | Max | $200 | ~3,500 Premium Requests | ## Team Plans | Plan | Monthly Price | Monthly limits | |------|---------------|------------------| | Team Pro | $40 | ~350 Premium Requests | | Team Max | $400 | ~3,500 Premium Requests | | Enterprise | $5,000+ | Unlimited // custom terms | **How it works:** - Monthly requests limits reset each month. - Auto top-up and buy extra credits at model cost. They roll over and never expire. - Enterprise plans? Email support@langbase.com for custom terms, SLAs, and dedicated support. Codestin Search App https://commandcode.ai/docs/resources/legal/ import { generateMetadata } from '@/lib/generate-metadata'; # Legal Command Code doesn't train on your code or store your code snippets. `TASTE` runs on your codebase and stores learning data in your project and on your local machine only. More details can be found in our [Privacy Policy](https://commandcode.ai/privacy) and [Terms of Service](https://commandcode.ai/terms). --- Codestin Search App https://commandcode.ai/docs/resources/faqs/ import { generateMetadata } from '@/lib/generate-metadata'; import { Faq } from '@/components/Faq'; import Link from 'next/link'; # FAQs Frequently asked questions about Command Code. --- Command Code offers both free and premium plans. Check our{' '} pricing page {' '} for more details.

) }, { question: 'How do I install Command Code?', answer: (

See our quickstart guide for installation instructions.

) }, { question: 'What is the difference between Command Code and Langbase?', answer: (

Command Code is built by Langbase and shares the same core mission.

) } ]} /> Codestin Search App https://commandcode.ai/docs/reference/slash-commands/ import { generateMetadata } from '@/lib/generate-metadata'; # Slash Commands Custom slash commands let you save frequently-used prompts as markdown files. Define a command once, then run it anytime with dynamic arguments. Commands can be project-level or user-level (shared across all projects). --- ## Syntax ```bash / [arguments] ``` | **Parameter** | **Description** | | ------------- | --------------- | | `` | Name derived from the markdown filename (without `.md` extension) | | `[arguments]` | Optional arguments passed to the command | --- ## Command Types There are two types of Commands: ### Project-Level Commands Commands saved directly in your project. When shown in /help, they appear with “(project)” after their description. **Location:** `.commandcode/commands/` ```bash # Create a project-level command mkdir -p .commandcode/commands echo "Generate unit tests for this code following our testing conventions" > .commandcode/commands/test.md ``` This makes `/test` command available only within this project. ### User-Level Commands Commands that are available across all your projects. In the command menu, they appear with “(user)” after their description. **Location:** `~/.commandcode/commands/` ```bash # Create a user-level command mkdir -p ~/.commandcode/commands echo "I am currently being onboarded on this project, help me understand it." > ~/.commandcode/commands/understand.md ``` This makes `/understand` command available in all your projects. --- ## Namespacing Organize commands in subdirectories. The subdirectories appear in the command description but do not affect the command name. | **File Location** | **Command** | **Description Shows** | | ----------------- | ----------- | --------------------- | | `.commandcode/commands/frontend/component.md` | `/component` | `(project: frontend)` | | `~/.commandcode/commands/git/commit.md` | `/commit` | `(user: git)` | | `.commandcode/commands/simple.md` | `/simple` | `(project)` | ### Unlimited Nesting Depth You can organize commands as deeply as needed: ``` .commandcode/commands/ ├── frontend/ │ ├── react/ │ │ ├── hooks/ │ │ │ └── use-auth.md → /use-auth (project: frontend/react/hooks) │ │ └── components/ │ │ └── button.md → /button (project: frontend/react/components) │ └── vue/ │ └── composable.md → /composable (project: frontend/vue) ├── backend/ │ └── api/ │ └── endpoint.md → /endpoint (project: backend/api) └── simple.md → /simple (project) ``` The command name comes from the filename only, not the folder path. So `frontend/button.md` and `backend/button.md` both create `/button`, they will conflict. Use unique filenames like `frontend-button.md` and `backend-button.md` instead. --- ## Arguments Pass dynamic values to commands using argument placeholders. ### All Arguments with `$ARGUMENTS` The `$ARGUMENTS` placeholder captures all arguments as a single string: **Command definition** (`.commandcode/commands/explain.md`): ```markdown Explain the following concept in simple terms: $ARGUMENTS ``` **Usage:** ```bash /explain how async await works in JavaScript ``` **Result:** `$ARGUMENTS` becomes `"how async await works in JavaScript"` ### Positional Arguments with `$1`, `$2`, etc. Access specific arguments using positional parameters. Arguments start at `$1` (there is no `$0`): **Command definition** (`.commandcode/commands/create-component.md`): ```markdown Create a $1 component named $2 with the following features: $3 ``` **Usage:** ```bash /create-component React Button "onClick and disabled props" ``` **Result:** - `$1` → `"React"` - `$2` → `"Button"` - `$3` → `"onClick and disabled props"` ### Quoted Strings Arguments containing spaces can be wrapped in quotes: ```bash /create-component React "Login Form" "email validation and submit handler" ``` **Result:** - `$1` → `"React"` - `$2` → `"Login Form"` - `$3` → `"email validation and submit handler"` --- ## Edge Cases | **Scenario** | **Behavior** | | ------------ | ------------ | | Missing argument (e.g., `$3` with only 2 args) | Replaced with empty string | | Extra arguments | Captured in `$ARGUMENTS`, ignored by unused `$N` | | No arguments provided | `$ARGUMENTS` = `""`, all `$N` = `""` | | Command without placeholders | Template passed through unchanged | --- ## Examples ### Test Generator Command **File:** `.commandcode/commands/test.md` ```markdown Write $1 tests for the following code using $2. Requirements: - Cover edge cases and error scenarios - Add descriptive test names - Follow testing best practices ``` **Usage:** ```bash /test unit Jest ``` ### Documentation Command **File:** `~/.commandcode/commands/docs.md` ```markdown Generate documentation for this $1. Include: - Description and purpose - Parameters/props with types - Usage examples - Return values if applicable ``` **Usage:** ```bash /docs function ``` --- ## How It Works 1. **Type `/`** to open the command menu 2. **Select a command** from the dropdown (e.g., `/test`) 3. **Command is inserted** into the input field with a trailing space 4. **Type your arguments** (e.g., `unit Jest`) 5. **Press Enter** to execute 6. **Placeholders are replaced** with your arguments 7. **Processed prompt** is sent to the AI --- Custom commands cannot override built-in commands. If you create a command with the same name as a built-in, the built-in takes precedence. --- ## Quick Reference ### Placeholders | **Placeholder** | **Description** | **Example Input** | **Result** | | --------------- | --------------- | ----------------- | ---------- | | `$ARGUMENTS` | All arguments as string | `unit Jest async` | `unit Jest async` | | `$1` | First argument | `unit Jest` | `unit` | | `$2` | Second argument | `unit Jest` | `Jest` | | `$N` | Nth argument | — | — | ### Command Locations | **Type** | **Location** | **Description Label** | | -------- | ------------ | --------------------- | | Project | `.commandcode/commands/` | `(project)` | | Project (nested) | `.commandcode/commands/subdir/` | `(project: subdir)` | | User | `~/.commandcode/commands/` | `(user)` | | User (nested) | `~/.commandcode/commands/subdir/` | `(user: subdir)` | --- ## Troubleshooting ### Command not appearing in menu 1. Ensure the file has `.md` extension 2. Check file is in correct directory (`.commandcode/commands/` or `~/.commandcode/commands/`) 3. Verify file permissions allow reading ### Arguments not being replaced 1. Use `$1`, `$2`, etc. for positional args (not `$0`) 2. Use `$ARGUMENTS` for all args as a string 3. Check for typos in placeholder names (case-sensitive) --- ## Next steps - Create your first custom command and try it out - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/reference/memory/ import { generateMetadata } from '@/lib/generate-metadata'; # Memory Set custom instructions for Command Code by creating an `AGENTS.md` file. It contains instructions that customize Command Code's behavior for your project. --- ## Initialize Create a new `AGENTS.md` in your project: ```bash /init ``` This creates an `AGENTS.md` file in your project root with a starter template. Commit your project's `AGENTS.md` to git. --- ## Example The `/init` command creates a template like this: ```markdown # Memory ## Project Overview See @README.md for project overview and @package.json for available npm/pnpm commands for this project. ## Code Style Guidelines - Use descriptive variable names - Follow existing patterns in the codebase - Extract complex conditions into meaningful boolean variables ## Architecture Notes Add important architectural decisions and patterns here. ## Common Workflows Document frequently used workflows and commands here. ``` Customize it for your project. --- ## File Locations Command Code reads `AGENTS.md` from two locations: ### Project-level **Location:** `./AGENTS.md` or `./.commandcode/AGENTS.md` Team-shared project instructions. Commit this to Git along with your code. ### User-level **Location:** `~/.commandcode/AGENTS.md` Personal preferences for all your projects. --- ## Managing Files Edit `AGENTS.md` files: ```bash /memory ``` Opens a selector to choose which file to edit (project or user). --- ## Commands | **Command** | **Description** | | ----------- | --------------- | | `/init` | Create `AGENTS.md` in project root | | `/memory` | Open file selector to edit `AGENTS.md` | --- ## Next steps * [Skills](/skills/what-are-skills) for specialized agent capabilities * [Slash commands](/reference/slash-commands) for custom prompts * Join our [Discord community](https://commandcode.ai/discord) for support Codestin Search App https://commandcode.ai/docs/reference/interactive/ import { generateMetadata } from '@/lib/generate-metadata'; # Interactive Mode This page provides a complete reference for the Command Code's interactive mode. --- ## Slash Commands List of the main interactive slash commands and their descriptions. | **Slash Commands** | **Description** | **Example** | | ------------------ | ---------------------------- | ----------- | | `/init` | Initialize `AGENTS.md` | `/init` | | `/memory` | Manage project memory | `/memory` | | `/resume` | Resume a past conversation | `/resume` | | `/share` | Share conversation | `/share` | | `/unshare` | Stop sharing | `/unshare` | | `/taste` | Manage taste learning | `/taste` | | `/model` | Switch between Command Code models | `/model` | | `/clear` | Clear conversation history | `/clear` | | `/agents` | Manage agents | `/agents` | | `/compact` | Compact conversation history | `/compact` | | `/help` | Show commands | `/help` | | `/exit` | Exit session | `/exit` | ## Quick Commands List of the shortcuts that are available during interactive sessions: | **Shortcut** | **Description** | **Notes** | | ------------ | ----------------- | ------------------------------------------------------------- | | `/` at start | Slash command | See [slash commands](/reference/interactive#slash-commands) | | `!` at start | Bash mode | Run commands directly and add execution output to the session | | `@` | File path mention | Trigger file path autocomplete | Codestin Search App https://commandcode.ai/docs/reference/errors/ import { generateMetadata } from '@/lib/generate-metadata'; # Error Codes When using Command Code CLI, you may encounter errors due to various reasons. These errors can originate from either Command Code itself or the LLM (Language Model) provider. Below is a list of potential error codes to help you understand the issue. Please refer to the individual pages corresponding to the error code you encounter for detailed information and resolution steps. - [Bad request](/reference/errors/bad_request) - [Unauthorized](/reference/errors/unauthorized) - [Forbidden](/reference/errors/forbidden) - [Insufficient permissions](/reference/errors/insufficient_permissions) - [Usage exceeded](/reference/errors/usage_exceeded) - [Not found](/reference/errors/not_found) - [Conflict](/reference/errors/conflict) - [Precondition failed](/reference/errors/precondition_failed) - [Internal Server Error](/reference/errors/internal_server_error) If you encounter an error not listed here, please reach out to our [support team](mailto:support@langbase.com) for assistance. --- Codestin Search App https://commandcode.ai/docs/reference/cli/ import { generateMetadata } from '@/lib/generate-metadata'; # CLI Reference This page provides a complete reference for all the CLI and taste commands. --- ## CLI Commands List of the main CLI commands and their description. | **Command** | **Description** | **Example** | | ----------- | ----------------------------------------- | ------------------------------ | | `cmd` | Start an interactive session | `cmd` | | `login` | Authenticate your account access | `cmd login` | | `taste` | Manage taste learning packages | `cmd taste push` | | `config` | Manage CLI configuration | `cmd config set ` | | `logout` | Log out from your account | `cmd logout` | | `whoami` | Display current user information | `cmd whoami` | | `update` | Update Command Code to the latest version | `cmd update` | ## Taste Commands List of the all taste commands and their description. | **Command** | **Description** | **Example** | | ------------------ | --------------------------------------------- | ------------------ | | `npx taste push` | Push taste profile to Command Code registry | `npx taste push` | | `npx taste pull` | Pull taste profile from Command Code registry | `npx taste pull` | | `npx taste list` | List taste profiles | `npx taste list` | | `npx taste lint` | Lint taste profile | `npx taste lint` | | `npx taste open` | Open taste profile in editor | `npx taste open` | | `npx taste help` | Show taste help | `npx taste help` | `npx taste` and `cmd taste` are equivalent. `cmd taste` requires global installation (`npm i -g command-code`). We recommend using `npx taste`. --- ## CLI Flags You can customise Command Code's CLI behaviour with the following flags. | **Flag** | **Description** | **Example** | | -------------------- | --------------------------------------------------- | ------------------- | | `-v, --version` | Output the version number | `cmd --version` | | `-r, --resume` | Resume a conversation | `cmd --resume` | | `-c, --continue` | Continue the last conversation | `cmd --continue` | | `-t, --trust` | Auto-trust project (skip initial permission prompt) | `cmd --trust` | | `-tL, --taste-learn` | Enable taste learning | `cmd --taste-learn` | | `-crud, --crud` | Enable all CRUD permissions | `cmd --crud` | | `-cru, --cru` | Enable Create, Read, Update (no Delete) | `cmd --cru` | | `-c, --create` | Enable Create permission | `cmd --create` | | `-r, --read` | Enable Read permission | `cmd --read` | | `-u, --update` | Enable Update permission | `cmd --update` | | `-d, --delete` | Enable Delete permission | `cmd --delete` | | `-h, --help` | Display help for Command Code | `cmd --help` | --- ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Codestin Search App https://commandcode.ai/docs/reference/checkpoints/ import { generateMetadata } from '@/lib/generate-metadata'; # Checkpoints Command Code automatically creates checkpoints before modifying files, allowing you to restore your project to any previous state. Think of it as undo on steroids - you can rewind both your files and conversation history. --- ## How It Works 1. **Automatic backups**: Every time Command Code edits a file, it backs up the original content first 2. **Checkpoint creation**: A checkpoint snapshot is created on each user message 3. **Instant restore**: Rewind to any checkpoint to restore files, conversation, or both --- ## Opening the Rewind UI ### Keyboard Shortcut Press **`Esc`** twice quickly (double-tap) to open the checkpoint selector. ### Slash Command ```bash /rewind ``` --- ## Restore Modes When you select a checkpoint, choose what to restore: | **Mode** | **What It Does** | | -------- | ---------------- | | **Conversation only** | Removes all messages after the checkpoint. Code remains unchanged. | | **Code only** | Restores all code to its state at the checkpoint. Conversation remains intact. | | **Both** | Restores both code and conversation to the checkpoint state. | --- ## What Gets Restored ### Code - Code files modified after the checkpoint are restored to their original content - Files created after the checkpoint are deleted - Files that existed at the checkpoint but were deleted are restored ### Conversation - All messages after the selected checkpoint are removed - The checkpoint itself is removed (you're rewinding to *before* that message) - Context token count is updated to reflect the shorter conversation --- ## Checkpoint Information Each checkpoint shows: - **Timestamp**: When the checkpoint was created - **Your message**: Preview of what you asked (truncated to 60 chars) - **Files changed**: Number of files that were modified in that checkpoint - **Code changes**: Indicates if code was modified (used to filter restore options) --- ## Limitations | **Limitation** | **Details** | | -------------- | ----------- | | **Max file size** | Files larger than 10MB are not backed up | | **Session scope** | Checkpoints are per-session only | | **Disk space** | If disk is full, checkpointing pauses (you'll see a notice) | --- ## Fail-Safe Restore Restores are designed to be safe: 1. **Verify first**: Before restoring, Command Code verifies all backup files exist and are readable 2. **All or nothing**: If any file can't be restored, the entire operation is aborted 3. **Clear errors**: You'll see exactly which files couldn't be restored and why --- ## Edge Cases ### New Files If Command Code created a new file after a checkpoint and you restore to before that point: - **Code only** or **Both**: The new file is deleted - **Conversation only**: The file remains ### Disk Full If your disk runs out of space: - Checkpointing pauses automatically - You'll see a notice in the UI - Existing checkpoints remain usable - Once space is freed, checkpointing resumes ### Binary Files Binary files (images, compiled files, etc.) are backed up the same as text files. No special handling needed. --- ## Troubleshooting ### Checkpoints not appearing 1. Ensure you've sent at least one message in the session 2. Check if checkpointing is paused (disk full notice) 3. Verify the session has file modifications ### Restore failed 1. Check the error message for which file failed 2. Ensure backup files haven't been manually deleted from `~/.commandcode/file-history/` 3. Verify you have write permissions to the target files ### Double-Esc not working 1. Press Esc twice within 500ms 2. Ensure focus is on the Command Code input 3. Try using `/rewind` command instead --- ## Next Steps - Try creating a checkpoint by asking Command Code to modify a file - Join our [Discord community](https://langbase.com/discord) for support Codestin Search App https://commandcode.ai/docs/configuration/providers/ import { generateMetadata } from '@/lib/generate-metadata'; # Providers Command Code providers. Codestin Search App https://commandcode.ai/docs/taste/commands/push/ import { generateMetadata } from '@/lib/generate-metadata'; # taste push Push taste packages from your local project to remote or global. --- ## Usage ```bash npx taste push [package] [options] ``` --- ## Options | Option | Short | Description | | ------ | ----- | ----------- | | `--all` | | Push entire project taste (all packages bundled together) | | `--global` | `-g` | Push to global (`~/.commandcode/taste`) | | `--overwrite` | | Replace target completely without merging | | `--public` | | Make package publicly discoverable (remote only) | --- ## Project taste vs Individual Package You can either push your entire project taste or individual packages. ### Push Project Taste (`--all`) When you use `push --all`, Command Code pushes your **entire project's taste** as a single unit: ```bash npx taste push --all ``` - Bundles **all packages** from your project together - Project name is derived from your current directory - Pushed to remote under your namespace ### Push Individual Package When you push a specific package, only that **single package** is uploaded: ```bash # Interactive namespace selection npx taste push cli # Explicit namespace npx taste push myorg/cli ``` ```bash npx taste push cli -g ``` - Pushes **one package** at a time - If you have push access to multiple accounts, you get prompted --- ## Taste Packages ### Remote (default) Pushes to cloud under your profile at [commandcode.ai](https://commandcode.ai). - **Path**: `commandcode.ai/username/taste` - **Use case**: Team sharing, backup, sync across machines, public packages ```bash # Push project taste npx taste push --all # Push individual package npx taste push cli npx taste push myorg/cli ``` ### Global (`-g`) Pushes to your global packages accessible across all projects on your machine. - **Path**: `~/.commandcode/taste/` - **Use case**: Your personal taste that follows you across projects ```bash npx taste push cli -g ``` --- ## Examples ### Push entire project to remote ```bash npx taste push --all ``` Bundles all your project's taste packages and uploads them to `commandcode.ai/username/taste`. Your team can then pull with `npx taste pull username/project-name`. ### Push individual package to remote ```bash npx taste push cli ``` Prompts you to select a namespace (personal or organization), then uploads only the `cli` package. ### Push with explicit namespace ```bash npx taste push myteam/cli ``` Uploads the `cli` package directly to the `myteam` namespace without prompting. ### Push to global ```bash npx taste push cli -g ``` Saves the `cli` package to `~/.commandcode/taste/cli/` for use in any project on your machine. ### Push and make public ```bash npx taste push cli --public ``` Uploads the package and makes it publicly discoverable by other Command Code users. ### Overwrite without merging ```bash npx taste push cli --overwrite ``` Completely replaces the remote package without merging. By default, push intelligently merges learnings. --- ## Merge Behavior By default, `taste push` intelligently merges your local learnings with existing remote/global content: - **New learnings** are added - **Updated learnings** (changed confidence) are updated - **Identical learnings** remain unchanged Use `--overwrite` to skip merging and completely replace the target. --- ## Output ```sh ✓ Pushed project taste to commandcode.ai/aa/taste (3 packages, 15 learnings) ``` ```sh ✓ Pushed 'cli' to commandcode.ai/aa/taste (2 learnings added, 1 updated, 3 unchanged) ``` --- ## Next steps - Use [`taste pull`](/taste/commands/pull) to download packages - Use [`taste list`](/taste/commands/list) to view available packages - View your packages in [Command Code Studio](/studio/taste) Codestin Search App https://commandcode.ai/docs/taste/commands/open/ import { generateMetadata } from '@/lib/generate-metadata'; # taste open Open a taste package in your default editor. This command provides quick access to edit your taste files directly. --- ## Usage ```bash npx taste open ``` --- ## Arguments | Argument | Description | | -------- | ----------- | | `` | **Required.** The name of the package to open. | --- ## Options | Option | Short | Description | | ------ | ----- | ----------- | | `--global` | `-g` | Open package from global (`~/.commandcode/taste`) | --- ## Examples ### Open a local package ```bash npx taste open cli ``` Opens the `cli` taste package from your local project in your default editor. ### Open from global ```bash npx taste open cli -g ``` Opens the `cli` package from your global at `~/.commandcode/taste`. --- ## Output ```sh ✓ Opened 'cli' taste package from project ``` --- ## Editor Configuration The command uses your system's default editor set via the `$EDITOR` environment variable. If not configured, you'll see setup instructions: ```bash # VS Code echo 'export EDITOR="code"' >> ~/.zshrc # Vim echo 'export EDITOR="vim"' >> ~/.zshrc # Nano echo 'export EDITOR="nano"' >> ~/.zshrc # Sublime Text echo 'export EDITOR="subl"' >> ~/.zshrc ``` After adding the export, restart your terminal or run `source ~/.zshrc`. --- ## Behavior - Opens the taste file in your default editor - For category-specific files: Opens at line 1 - For main `taste.md` files: Searches for the category heading and opens at that line - Automatically navigates to the correct location in the file After editing a taste file, use `npx taste lint` to validate your changes before pushing. --- ## Next steps - Use [`taste lint`](/taste/commands/lint) to validate your changes - Use [`taste push`](/taste/commands/push) to upload edited packages - Use [`taste list`](/taste/commands/list) to view all packages Codestin Search App https://commandcode.ai/docs/taste/commands/pull/ import { generateMetadata } from '@/lib/generate-metadata'; # taste pull Pull taste packages from remote or global to your project. --- ## Usage ```bash npx taste pull / [options] ``` --- ## Options | Option | Short | Description | | ------ | ----- | ----------- | | `--global` | `-g` | Pull from global (`~/.commandcode/taste`) | | `--all` | | Pull all packages (global only) | | `--overwrite` | | Replace local package without merging | --- ## Taste Packages ### Remote (default) Pull from cloud under your profile or others' profiles at [commandcode.ai](https://commandcode.ai). - **Path**: `commandcode.ai/username/taste` - **Use case**: Get taste from teammates, sync across machines, pull public packages ```bash # Pull project taste npx taste pull ahmadawais/my-project # Pull individual package npx taste pull ahmadawais/cli ``` ### Global (`-g`) Pull from your global packages accessible across all projects on your machine. - **Path**: `~/.commandcode/taste/` - **Use case**: Your personal taste that follows you across projects ```bash # Pull specific package npx taste pull cli -g # Pull all global packages npx taste pull --all -g ``` --- ## Examples ### Pull project taste from remote ```bash npx taste pull teammate/awesome-project ``` Downloads all taste packages from `teammate/awesome-project` to your local project. ### Pull individual package from remote ```bash npx taste pull ahmadawais/cli ``` Downloads only the `cli` package from `ahmadawais`'s profile. ### Pull from global ```bash npx taste pull cli -g ``` Copies the `cli` package from `~/.commandcode/taste/` to your current project. ### Pull all from global ```bash npx taste pull --all -g ``` Copies all packages from your global to the current project. ### Overwrite local without merging ```bash npx taste pull ahmadawais/cli --overwrite ``` Completely replaces your local `cli` package with the remote version. --- ## Merge Behavior By default, `taste pull` intelligently merges remote learnings with your local content: - **New learnings** from remote are added locally - **Updated learnings** (changed confidence) are updated - **Identical learnings** remain unchanged Use `--overwrite` to skip merging and completely replace local content. --- ## Output ```sh ✓ Pulled 'cli' from saqib (1 learning added, 2 unchanged) Saved to: .commandcode/taste/cli/taste.md ``` --- ## Next steps - Use [`taste push`](/taste/commands/push) to upload your taste - Use [`taste list`](/taste/commands/list) to view available packages - Use [`taste open`](/taste/commands/open) to edit pulled packages Codestin Search App https://commandcode.ai/docs/taste/commands/list/ import { generateMetadata } from '@/lib/generate-metadata'; # taste list List all available taste packages. --- ## Usage ```bash npx taste list [options] ``` --- ## Options | Option | Short | Description | | ------ | ----- | ----------- | | `--global` | `-g` | List packages from global (`~/.commandcode/taste`) | | `--remote` | | List packages from your remote profile at commandcode.ai | --- ## Taste Packages ### Project (default) List packages in your current project's `.commandcode/taste/` directory. - **Path**: `.commandcode/taste/` ```bash npx taste list ``` ### Global (`-g`) List packages from your global, accessible across all projects on your machine. - **Path**: `~/.commandcode/taste/` ```bash npx taste list -g ``` ### Remote (`--remote`) List packages stored on cloud under your profile at [commandcode.ai](https://commandcode.ai). - **Path**: `commandcode.ai/username/taste` ```bash npx taste list --remote ``` --- ## Output The command displays: - **Package name**: The taste package identifier - **Public badge**: `[public]` for publicly discoverable packages - **Stats**: Star count (★) and download count (↓) for public packages - **Learning count**: Number of learnings in the package - **Last updated**: When the package was last modified ```sh Taste Packages Stored locally in .commandcode/taste cli (8 learnings, updated 2 hours ago) typescript (5 learnings, updated 1 day ago) architecture (12 learnings, updated just now) Total: 3 packages, 25 learnings ``` ```sh Taste Packages Stored on commandcode.ai/aa/taste my-project (15 learnings, updated 1 hour ago) cli [public] ★5 ↓12 (8 learnings, updated 2 days ago) Total: 2 packages, 23 learnings ``` --- ## Examples ### List project packages ```bash npx taste list ``` Shows all taste packages in your current project. ### List global packages ```bash npx taste list -g ``` Shows all taste packages in your global at `~/.commandcode/taste/`. ### List remote packages ```bash npx taste list --remote ``` Shows all taste packages stored on your profile at `commandcode.ai/username/taste`. --- ## Next steps - Use [`taste push`](/taste/commands/push) to upload packages - Use [`taste pull`](/taste/commands/pull) to download packages - View your packages in [Command Code Studio](/studio/taste) Codestin Search App https://commandcode.ai/docs/taste/commands/lint/ import { generateMetadata } from '@/lib/generate-metadata'; # taste lint Validate taste file format and structure. This command checks your taste files for errors and warnings before pushing. --- ## Usage ```bash npx taste lint ``` --- ## Arguments | Argument | Description | | -------- | ----------- | | `[package]` | Package name to lint. Optional if using `--all`. | --- ## Options | Option | Short | Description | | ------ | ----- | ----------- | | `--global` | `-g` | Lint packages from global (`~/.commandcode/taste`) | | `--all` | | Lint all packages | --- ## Examples ### Lint a specific package ```bash npx taste lint cli ``` Validates the `cli` taste package in your local project. ### Lint all local packages ```bash npx taste lint --all ``` Validates all taste packages in your local project's `.commandcode/taste` directory. ### Lint from global ```bash npx taste lint cli -g ``` Validates the `cli` package from your global. ### Lint all from global ```bash npx taste lint --all -g ``` Validates all packages in your global at `~/.commandcode/taste`. --- ## Output The command provides detailed validation results: ```sh taste.md ✓ File is valid cli/taste.md ✓ File is valid Summary: 0 errors, 0 warnings across 2 files ✓ All 2 taste files are valid ``` ```sh cli/taste.md ✗ 2 errors found Line 5: Invalid confidence value (must be between 0 and 1) Line 12: Missing required header Summary: 2 errors, 0 warnings across 1 file ✗ Validation failed ``` --- ## What Gets Validated | Check | Description | | ----- | ----------- | | Markdown structure | Proper header hierarchy and formatting | | Required fields | Presence of required metadata and sections | | Confidence values | Values must be between 0 and 1 | | Header format | Correct header syntax and naming | | File encoding | Valid UTF-8 encoding | --- ## Behavior - Validates both main `taste.md` and category-specific taste files - Supports automatic header migration for legacy format files - **Errors** indicate problems that must be fixed before pushing - **Warnings** indicate potential issues but don't block operations --- ## Next steps - Fix any errors reported by the linter - Use [`taste push`](/taste/commands/push) to upload validated packages - Use [`taste open`](/taste/commands/open) to edit packages with errors Codestin Search App https://commandcode.ai/docs/reference/errors/usage_exceeded/ import { generateMetadata } from '@/lib/generate-metadata'; # Usage exceeded The Usage Exceeded error occurs when you exceed your plan's usage limits. This error indicates that you have consumed all allocated resources for your current billing period. --- ## Possible Causes Reaching the maximum usage allowed by your current plan. --- ## Troubleshooting Steps 1. **Check Your Usage**: Review your current usage and plan limits in [Command Code Studio](https://commandcode.ai/studio) billing page. 2. **Upgrade Your Plan**: Consider upgrading to a higher plan to accommodate your usage needs. 3. **Wait for Reset**: If you're on a usage-based plan, your limits may reset at the start of next billing period. Please refer to the [Command Code Pricing page](https://commandcode.ai/pricing) for more details on available plans and their respective limits. --- ## Recommendation If you consistently hit usage limits, consider upgrading your plan to accommodate your needs. Codestin Search App https://commandcode.ai/docs/reference/errors/unauthorized/ import { generateMetadata } from '@/lib/generate-metadata'; # Unauthorized The unauthorized error occurs when Command Code CLI is not properly authenticated or your credentials are invalid. This error signals that you need to authenticate before using Command Code. --- ## Possible Causes - Not logged in to Command Code CLI. - Invalid or expired authentication session. - Authentication token has been revoked. --- ## Troubleshooting Steps 1. **Login to Command Code**: Run `cmd login` command to authenticate with Command Code CLI. 2. **Verify Authentication Status**: Check if you're properly logged in and your session is active. 3. **Re-authenticate**: If your session has expired, log out and log back in to refresh your authentication. --- ## Recommendation Ensure you are logged in to Command Code CLI with valid credentials. If you continue to experience issues, try logging out and logging back in. Codestin Search App https://commandcode.ai/docs/reference/errors/precondition_failed/ import { generateMetadata } from '@/lib/generate-metadata'; # Precondition failed You can run into this error when certain preconditions are not satisfied by the current state of the resource. This typically happens when the resource has been modified since you last accessed it. --- ## Possible Causes - The resource has been modified by another user or process. - The resource state doesn't match the expected conditions for the operation. - Outdated or conflicting version information. --- ## Troubleshooting Steps 1. **Refresh Resource State**: Retrieve latest version of the resource before attempting the operation again. 2. **Check Resource State**: Verify that resource is in expected state for operation you're trying to perform. 3. **Retry Operation**: After confirming the current state, retry your command with updated information. --- ## Recommendation Ensure you're working with the most recent version of the resource and that it's in the appropriate state for your operation to avoid encountering this error. Codestin Search App https://commandcode.ai/docs/reference/errors/not_found/ import { generateMetadata } from '@/lib/generate-metadata'; # Not found The Not Found error occurs when the requested resource cannot be found. This error can occur due to an incorrect identifier or a resource that no longer exists. --- ## Possible Causes - The requested resource has been removed or moved. - You're using an incorrect resource identifier (ID, name, etc.). --- ## Troubleshooting Steps 1. **Verify Resource Identifier**: Double-check that you're using the correct ID or name for the resource. 2. **Check Resource Existence**: Confirm that the resource still exists and hasn't been deleted. 3. **Review Documentation**: Consult the documentation to ensure you're referencing resources correctly. --- ## Recommendation Verify the resource identifier you're using and check that the resource exists before retrying your command. Codestin Search App https://commandcode.ai/docs/reference/errors/internal_server_error/ import { generateMetadata } from '@/lib/generate-metadata'; # Internal Server Error The Internal Server Error indicates that something went wrong on Command Code's server while processing your command. This error represents unexpected or unhandled server-side issues. --- ## Possible Causes - Temporary server issues or outages. - Database connectivity problems. - Server overload or resource exhaustion. --- ## Troubleshooting Steps 1. **Retry Your Command**: Wait a moment and try running your command again. 2. **Check Status**: Visit Command Code's status page to see if there are any ongoing incidents. 3. **Contact Support**: If the error persists, contact [Command Code support](mailto:support@langbase.com) for assistance. --- ## Recommendation If you consistently encounter this error, please report the issue to [Command Code support](mailto:support@langbase.com) for investigation. Codestin Search App https://commandcode.ai/docs/reference/errors/insufficient_permissions/ import { generateMetadata } from '@/lib/generate-metadata'; # Insufficient permissions The Insufficient Permissions error occurs when you lack the necessary permissions to access a resource or perform an action. This error indicates that you are authenticated but do not have the required level of authorization. --- ## Possible Causes - Attempting to access a restricted resource without the necessary permissions. - Trying to perform an action that requires higher privileges than you currently have. - Your role in the organization doesn't have the required access level. --- ## Troubleshooting Steps 1. **Check Your Permissions**: Verify that your account has the appropriate permissions for the resource or action. 2. **Review Organization Role**: If you're part of an organization, ensure that your role has the correct permissions configured. 3. **Contact Administrator**: Request the necessary permissions from your organization administrator. --- ## Recommendation Ensure you have the necessary permissions granted in your organization to access the resource or perform the action. Codestin Search App https://commandcode.ai/docs/reference/errors/forbidden/ import { generateMetadata } from '@/lib/generate-metadata'; # Forbidden The Forbidden error occurs when you are authenticated but don't have permission to perform the requested action due to insufficient permissions, access restrictions, or account-related issues. --- ## Possible Causes - Lack of necessary permissions to access the resource. - Trying to perform an action that your account or role is not permitted to do. - Your account may be restricted or accessing from a blocked location. --- ## Troubleshooting Steps 1. **Check Permissions**: Verify that your account has required permissions for action you're trying to perform. 2. **Review Account Status**: Ensure your Command Code account is active and not disabled or restricted. 3. **Contact Administrator**: If you're part of an organization, contact your administrator to verify your access. --- ## Recommendation Review your account permissions and access level to ensure you have authorization for the action you're attempting to perform. Codestin Search App https://commandcode.ai/docs/reference/errors/bad_request/ import { generateMetadata } from '@/lib/generate-metadata'; # Bad request The Bad Request error occurs when Command Code cannot process your CLI command due to invalid input or parameters. This error indicates that there is an issue with how the command was executed. --- ## Possible Causes - Missing or incorrect command parameters. - Invalid data format or structure in the input provided. - Malformed configuration or settings. - Encoding issues, such as improperly encoded characters in your input. --- ## Troubleshooting Steps 1. **Check Command Parameters**: Verify that all required parameters are included and their values are valid according to the Command Code documentation. 2. **Validate Input Format**: If your command includes structured data (e.g., JSON), validate that it follows the expected format without any syntax errors. 3. **Review Configuration**: Check your Command Code configuration for correctness and completeness. 4. **Check Encoding**: If dealing with special characters, ensure they are properly encoded (UTF-8). --- ## Recommendation Review your command and inputs to ensure they match the expected format described in the documentation. Codestin Search App https://commandcode.ai/docs/reference/errors/conflict/ import { generateMetadata } from '@/lib/generate-metadata'; # Conflict The conflict error occurs when you attempt to create or update a resource with an identifier that already exists. This error typically arises when different resources cannot have the same name. For instance, creating a resource with a name that already exists will result in a conflict error. --- ## Possible Causes - Attempting to create a resource with an identifier (e.g., name, ID) that already exists. - Updating a resource with a value that violates a unique constraint. --- ## Troubleshooting Steps 1. **Check Existing Resources**: Verify that the identifier you're using (e.g., name) is not already in use. 2. **Use Different Identifier**: Choose a unique identifier that is not already in use. --- ## Recommendation Always use unique names for resources to avoid this error. If you encounter this error, check the existing resources and use a different identifier.