Skillget

MiniCode

agent
Guvenlik Denetimi
Basarisiz
Health Gecti
  • License — License: MIT
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Community trust — 30 GitHub stars
Code Basarisiz
  • network request — Outbound network request in src/anthropic-adapter.ts
  • os.homedir — User home directory access in src/config.ts
  • process.env — Environment variable access in src/config.ts
  • process.env — Environment variable access in src/index.ts
  • os.homedir — User home directory access in src/install.ts
  • process.env — Environment variable access in src/install.ts
Permissions Gecti
  • Permissions — No dangerous permissions requested

Bu listing icin henuz AI raporu yok.

SUMMARY

A lightweight terminal coding assistant with Claude Code-like workflow, tool loop, and TUI architecture, built for learning and experimentation.

README.md

MiniCode

简体中文 | Architecture | License

A lightweight terminal coding assistant for local development workflows.

MiniCode provides Claude Code-like workflow and architectural ideas in a much smaller implementation, making it especially useful for learning, experimentation, and custom tooling.

Overview

MiniCode is built around a practical terminal-first agent loop:

  • accept a user request
  • inspect the workspace
  • call tools when needed
  • review file changes before writing
  • return a final response in the same terminal session

The project is intentionally compact, so the control flow, tool model, and TUI behavior remain easy to understand and extend.

Table of Contents

Why MiniCode

MiniCode is a good fit if you want:

  • a lightweight coding assistant instead of a large platform
  • a terminal UI with tool calling, transcript, and command workflow
  • a small codebase that is suitable for study and modification
  • a reference implementation for Claude Code-like agent architecture

Features

Core workflow

  • multi-step tool execution in a single turn
  • model -> tool -> model loop
  • full-screen terminal interface
  • input history, transcript scrolling, and slash command menu
  • discoverable local skills via SKILL.md
  • dynamic MCP tool loading over stdio
  • MCP resources and prompts via generic MCP helper tools

Built-in tools

  • list_files
  • grep_files
  • read_file
  • write_file
  • edit_file
  • patch_file
  • modify_file
  • run_command
  • load_skill
  • list_mcp_resources
  • read_mcp_resource
  • list_mcp_prompts
  • get_mcp_prompt

Safety and usability

  • review-before-write flow for file modifications
  • path and command permission checks
  • local installer with independent config storage
  • support for Anthropic-style API endpoints

Recent interaction upgrades

  • approval prompts now use Up/Down selection with Enter confirm
  • supports "reject with guidance" to send corrective instructions back to the model
  • edit approvals support "allow this file for this turn" and "allow all edits for this turn"
  • file review now uses standard unified diff output (closer to git diff)
  • approval view supports Ctrl+O expand/collapse plus wheel/page scrolling
  • finished tool calls auto-collapse into concise summaries to reduce transcript noise

Installation

cd mini-code
npm install
npm run install-local

The installer will ask for:

  • model name
  • ANTHROPIC_BASE_URL
  • ANTHROPIC_AUTH_TOKEN

Configuration is stored in:

  • ~/.mini-code/settings.json
  • ~/.mini-code/mcp.json

The launcher is installed to:

  • ~/.local/bin/minicode

If ~/.local/bin is not already on your PATH, add:

export PATH="$HOME/.local/bin:$PATH"

Quick Start

Run the installed launcher:

minicode

Run in development mode:

npm run dev

Run in offline demo mode:

MINI_CODE_MODEL_MODE=mock npm run dev

Commands

Management commands

  • minicode mcp list
  • minicode mcp add <name> [--project] [--protocol <mode>] [--env KEY=VALUE ...] -- <command> [args...]
  • minicode mcp remove <name> [--project]
  • minicode skills list
  • minicode skills add <path> [--name <name>] [--project]
  • minicode skills remove <name> [--project]

Local slash commands

  • /help
  • /tools
  • /skills
  • /mcp
  • /status
  • /model
  • /model <name>
  • /config-paths

Terminal interaction

  • command suggestions and slash menu
  • transcript scrolling
  • prompt editing
  • input history navigation
  • approval selection and feedback input flow

Configuration

Example configuration:

{
  "model": "your-model-name",
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  },
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.anthropic.com",
    "ANTHROPIC_AUTH_TOKEN": "your-token",
    "ANTHROPIC_MODEL": "your-model-name"
  }
}

Project-scoped MCP config is also supported through Claude Code compatible .mcp.json:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  }
}

For vendor compatibility, MiniCode now auto-negotiates stdio framing:

  • standard MCP Content-Length framing is tried first
  • if that fails, MiniCode falls back to newline-delimited JSON
  • you can force a mode per server with "protocol": "content-length" or "protocol": "newline-json"

Skills are discovered from:

  • ./.mini-code/skills/<skill-name>/SKILL.md
  • ~/.mini-code/skills/<skill-name>/SKILL.md
  • ./.claude/skills/<skill-name>/SKILL.md
  • ~/.claude/skills/<skill-name>/SKILL.md

Configuration priority:

  1. ~/.mini-code/settings.json
  2. ~/.mini-code/mcp.json
  3. project .mcp.json
  4. compatible existing local settings
  5. process environment variables

Skills and MCP Usage

MiniCode supports two extension layers:

  • skills: local workflow instructions, usually described by a SKILL.md
  • MCP: external tool providers that expose tools, resources, and prompts into MiniCode

Skills: install, inspect, trigger

Install a local skill:

minicode skills add ~/minimax-skills/skills/frontend-dev --name frontend-dev

List installed or discovered skills:

minicode skills list

Inside the interactive UI, you can also run:

/skills

to inspect which skills are available in the current session.

If you explicitly mention a skill name, MiniCode will prefer loading it. For example:

Use the frontend-dev skill and directly rebuild the current landing page instead of stopping at a plan.

If you want to be even more explicit:

Load the fullstack-dev skill first, then follow its workflow to implement this task.

A common pattern is to clone an official or Claude Code-compatible skills repo locally and install from there:

git clone https://github.com/MiniMax-AI/skills.git ~/minimax-skills
minicode skills add ~/minimax-skills/skills/frontend-dev --name frontend-dev

MCP: install, inspect, trigger

Install a user-scoped MCP server:

minicode mcp add MiniMax --env MINIMAX_API_KEY=your-key --env MINIMAX_API_HOST=https://api.minimaxi.com -- uvx minimax-coding-plan-mcp -y

List configured MCP servers:

minicode mcp list

To configure an MCP server only for the current project, add --project:

minicode mcp add filesystem --project -- npx -y @modelcontextprotocol/server-filesystem .
minicode mcp list --project

Inside the interactive UI, run:

/mcp

to see which servers are connected, which protocol they negotiated, and how many tools / resources / prompts they expose.

MCP tools are automatically registered as:

mcp__<server_name>__<tool_name>

For example, after connecting the MiniMax MCP server you may see:

  • mcp__minimax__web_search
  • mcp__minimax__understand_image

These tool names are not hand-written in MiniCode. They appear automatically after a successful MCP connection.

How to use them in chat

The simplest approach is to just describe the task naturally and let the model decide when to use a skill or MCP tool:

Search for recent Chinese-language resources about MCP and give me 5 representative links.

If MiniMax MCP is connected, the model will typically choose mcp__minimax__web_search.

If you want a more controlled workflow, name the skill or target capability explicitly:

Use the frontend-dev skill and directly modify the current project files to turn this page into a more complete product landing page.

Or:

Use the connected MCP tools to search for the MiniMax MCP guide and summarize what capabilities it provides.

When to use skills vs MCP

  • skills are better for workflow, conventions, domain-specific instructions, and reusable execution patterns
  • MCP is better for search, image understanding, browsers, filesystems, databases, and other remote capabilities

A common combination is:

  • use a skill such as frontend-dev to shape how the work should be done
  • use MCP to provide external search, image understanding, or system integrations

Compatibility notes

MiniCode currently focuses on:

  • local SKILL.md discovery with load_skill
  • stdio MCP servers
  • MCP tools
  • generic helper tools for MCP resources and prompts

For vendor compatibility, MiniCode automatically tries:

  • standard Content-Length framing
  • then falls back to newline-json if needed

That means servers such as MiniMax MCP, which use newline-delimited JSON over stdio, can still be connected directly.

Project Structure

  • src/index.ts: CLI entry
  • src/agent-loop.ts: multi-step model/tool loop
  • src/tool.ts: tool registry and execution
  • src/skills.ts: local skill discovery and loading
  • src/mcp.ts: stdio MCP client and dynamic tool wrapping
  • src/manage-cli.ts: top-level minicode mcp / minicode skills management commands
  • src/tools/*: built-in tools
  • src/tui/*: terminal UI modules
  • src/config.ts: runtime configuration loading
  • src/install.ts: interactive installer

Architecture Docs

Development

npm run check

MiniCode is intentionally small and pragmatic. The goal is to keep the architecture understandable, hackable, and easy to extend.

Yorumlar (0)

Sonuc bulunamadi