@knightcodeai/cli-linux-arm64 0.9.1 → 0.9.3

package/bin/docs/shell-aliases.md

@@ -1,13 +1,93 @@
-# Shell Aliases
+# Configure shell commands
 
-KnightCode runs bash in non-interactive mode (`bash -c`), which doesn't expand aliases by default.
+KnightCode starts a separate non-interactive shell process for each Bash command. Non-interactive Bash does not expand aliases by default and usually does not load the same startup files as an interactive terminal.
 
-To enable your shell aliases, add to `~/.knightcode/agent/settings.json`:
+Use `shellPath` to choose the Bash executable and `shellCommandPrefix` to run setup before each command.
+
+## Understand which shell KnightCode uses
+
+| Command source | Shell |
+|---|---|
+| Model calls the built-in `bash` tool | KnightCode's resolved Bash executable |
+| You enter `!command` or `!!command` | The same resolved Bash executable |
+| Model calls the optional `powershell` tool | PowerShell 7 (`pwsh.exe`) or Windows PowerShell |
+| An extension provides or replaces a shell tool | The operations implemented by that extension |
+
+KnightCode normally invokes Bash with `bash -c`. On Unix systems, it uses `/bin/bash`, then `bash` on `PATH`, and finally `sh` when Bash is unavailable. Native Windows first checks the configured path, then Git Bash, then `bash.exe` on `PATH`.
+
+## Choose a Bash executable
+
+Set `shellPath` in `~/.knightcode/agent/settings.json` when KnightCode should use a specific executable:
+
+```json
+{
+  "shellPath": "~/.local/bin/bash"
+}
+```
+
+On Windows, use forward slashes or escape backslashes:
 
 ```json
 {
-  "shellCommandPrefix": "shopt -s expand_aliases\neval \"$(grep '^alias ' ~/.zshrc)\""
+  "shellPath": "C:\\cygwin64\\bin\\bash.exe"
 }
 ```
 
-Adjust the path (`~/.zshrc`, `~/.bashrc`, etc.) to match your shell config.
+Run `/reload` after changing the setting. See [Run KnightCode on Windows](windows.md) for the native Windows defaults.
+
+## Run setup before every Bash command
+
+Set `shellCommandPrefix` to prepend shell setup to both the built-in `bash` tool and user-entered `!` or `!!` commands:
+
+```json
+{
+  "shellCommandPrefix": "export CI=1"
+}
+```
+
+KnightCode joins the prefix and requested command with a newline. The prefix runs again for every command, so keep it fast and free of interactive prompts.
+
+## Enable Bash aliases
+
+Store aliases needed by KnightCode in a Bash-compatible file instead of parsing an entire interactive shell configuration.
+
+Create `~/.bash_aliases`:
+
+```bash
+alias ll='ls -la'
+alias gs='git status --short'
+```
+
+Then configure KnightCode to enable alias expansion and load the file:
+
+```json
+{
+  "shellCommandPrefix": "shopt -s expand_aliases\nsource ~/.bash_aliases"
+}
+```
+
+Run `/reload`, then verify the alias through KnightCode:
+
+```text
+!ll
+```
+
+The command should produce the same listing as `ls -la`.
+
+Aliases must use Bash-compatible syntax. Do not source an arbitrary `.zshrc` into Bash because zsh options, functions, and plugins may not parse or behave correctly there.
+
+## Troubleshooting
+
+### The prefix works for `!` but not for an extension tool
+
+`shellCommandPrefix` configures KnightCode's built-in Bash execution. An extension that replaces the `bash` tool or provides its own shell operations controls its own setup. Check that extension's documentation.
+
+### `shopt` is not found
+
+KnightCode has fallen back to `sh` or `shellPath` points to a non-Bash shell. Install Bash or set `shellPath` to a Bash executable before using Bash-specific setup such as `shopt`.
+
+### A setup command waits for input
+
+Remove interactive commands from `shellCommandPrefix`. The prefix runs in a non-interactive process before every Bash command.
+
+For the complete setting definitions, see [Shell settings](settings.md#shell).

package/bin/docs/skills.md

@@ -1,231 +1,93 @@
-> knightcode can create skills. Ask it to build one for your use case.
-
 # Skills
 
-Skills are self-contained capability packages that the agent loads on-demand. A skill provides specialized workflows, setup instructions, helper scripts, and reference documentation for specific tasks.
-
-KnightCode implements the [Agent Skills standard](https://agentskills.io/specification), warning about most violations but remaining lenient. KnightCode allows skill names to differ from their parent directory even though the standard disallows it; that rule is suboptimal for shared skill directories used across multiple agent harnesses.
-
-## Table of Contents
-
-- [Locations](#locations)
-- [How Skills Work](#how-skills-work)
-- [Skill Commands](#skill-commands)
-- [Skill Structure](#skill-structure)
-- [Frontmatter](#frontmatter)
-- [Validation](#validation)
-- [Example](#example)
-- [Skill Repositories](#skill-repositories)
-
-## Locations
-
-> **Security:** Skills can instruct the model to perform any action and may include executable code the model invokes. Review skill content before use.
-
-KnightCode loads skills from:
-
-- Global:
-  - `~/.knightcode/agent/skills/`
-  - `~/.agents/skills/`
-- Project (only after the project is trusted):
-  - `.knightcode/skills/`
-  - `.agents/skills/` in `cwd` and ancestor directories (up to git repo root, or filesystem root when not in a repo)
-- Packages: `skills/` directories or `knightcode.skills` entries in `package.json`
-- Settings: `skills` array with files or directories
-- CLI: `--skill <path>` (repeatable, additive even with `--no-skills`)
-
-Discovery rules:
-- In `~/.knightcode/agent/skills/` and `.knightcode/skills/`, direct root `.md` files are discovered as individual skills when they have valid skill frontmatter with a non-empty `description`
-- In all skill locations, directories containing `SKILL.md` are discovered recursively
-- In `~/.agents/skills/` and project `.agents/skills/`, root `.md` files are ignored, but nested `.md` files in grouping folders are discovered when they declare skill frontmatter
-- Root Markdown files other than `SKILL.md` that do not look like skills are ignored silently
-
-Disable discovery with `--no-skills` (explicit `--skill` paths still load).
-
-### Using Skills from Other Harnesses
-
-To use skills from Claude Code or OpenAI Codex, add their directories to settings:
-
-```json
-{
-  "skills": [
-    "~/.claude/skills",
-    "~/.codex/skills"
-  ]
-}
-```
-
-For project-level Claude Code skills, add to `.knightcode/settings.json`:
-
-```json
-{
-  "skills": ["../.claude/skills"]
-}
-```
-
-## How Skills Work
-
-1. At startup, knightcode scans skill locations and extracts names and descriptions
-2. The system prompt includes available skills in XML format per the [specification](https://agentskills.io/integrate-skills)
-3. When a task matches, the agent uses `read`, or `bash` when `read` is unavailable, to load the full SKILL.md (models don't always do this; use prompting or `/skill:name` to force it)
-4. The agent follows the instructions, using relative paths to reference scripts and assets
-
-This is progressive disclosure: only descriptions are always in context, full instructions load on-demand.
-
-## Skill Commands
-
-Skills register as `/skill:name` commands:
-
-```bash
-/skill:brave-search           # Load and execute the skill
-/skill:pdf-tools extract      # Load skill with arguments
-```
-
-Arguments after the command are appended to the skill content as `User: <args>`.
+Skills give KnightCode specialized instructions and supporting files for a particular kind of work. KnightCode advertises each available skill by name and description, then loads its full instructions only when the task calls for them.
 
-Toggle skill commands via `/settings` in interactive mode or in `settings.json`:
+Use a skill when a workflow needs more context than a prompt template but does not need a new executable integration point. Skills can bundle scripts, references, and assets alongside their instructions.
 
-```json
-{
-  "enableSkillCommands": true
-}
-```
+KnightCode implements the [Agent Skills specification](https://agentskills.io/specification). Most invalid fields produce warnings rather than stopping startup.
 
-## Skill Structure
+## Create a skill
 
-A skill is a directory with a `SKILL.md` file. Everything else is freeform.
+A skill is a directory containing `SKILL.md`:
 
-```
-my-skill/
-├── SKILL.md              # Required: frontmatter + instructions
-├── scripts/              # Helper scripts
-│   └── process.sh
-├── references/           # Detailed docs loaded on-demand
-│   └── api-reference.md
+```text
+pdf-tools/
+├── SKILL.md
+├── scripts/
+│   └── extract.sh
+├── references/
+│   └── formats.md
 └── assets/
     └── template.json
 ```
 
-### SKILL.md Format
+Start `SKILL.md` with frontmatter followed by direct instructions:
 
-````markdown
+```markdown
 ---
-name: my-skill
-description: What this skill does and when to use it. Be specific.
+name: pdf-tools
+description: Extract text and tables from PDF files. Use when reading, converting, or inspecting PDFs.
 ---
 
-# My Skill
+# PDF tools
 
-## Setup
-
-Run once before first use:
-```bash
-cd /path/to/skill && npm install
+Read `references/formats.md` before converting a document. Run scripts relative to this skill directory.
 ```
 
-## Usage
-
-```bash
-./scripts/process.sh <input>
-```
-````
-
-Use relative paths from the skill directory:
-
-```markdown
-See [the reference guide](references/REFERENCE.md) for details.
-```
-
-## Frontmatter
-
-Per the [Agent Skills specification](https://agentskills.io/specification#frontmatter-required):
+The description determines when the model considers loading the skill. State both what the skill does and when it applies. Avoid descriptions such as “Helps with PDFs,” which do not provide enough routing information.
 
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Max 64 chars. Lowercase a-z, 0-9, hyphens. Unlike the standard, KnightCode does not require this to match the parent directory because that standard requirement is suboptimal for shared skill directories. |
-| `description` | Yes | Max 1024 chars. What the skill does and when to use it. |
-| `license` | No | License name or reference to bundled file. |
-| `compatibility` | No | Max 500 chars. Environment requirements. |
-| `metadata` | No | Arbitrary key-value mapping. |
-| `allowed-tools` | No | Space-delimited list of pre-approved tools (experimental). |
-| `disable-model-invocation` | No | When `true`, skill is hidden from system prompt. Users must use `/skill:name`. |
+Use relative paths from the skill directory when referring to bundled files. KnightCode tells the model where the skill lives so it can resolve those paths.
 
-### Name Rules
+## Understand how skills load
 
-- 1-64 characters
-- Lowercase letters, numbers, hyphens only
-- No leading/trailing hyphens
-- No consecutive hyphens
-KnightCode does not require the name to match the parent directory. The Agent Skills standard does, but that requirement is suboptimal for shared skill directories used by multiple tools.
+At startup, KnightCode scans configured skill locations and adds each skill’s name, description, and path to the system prompt. It does not add the full instructions.
 
-Valid: `pdf-processing`, `data-analysis`, `code-review`
-Invalid: `PDF-Processing`, `-pdf`, `pdf--processing`
+When a task matches, the model reads `SKILL.md` and follows its instructions. This keeps detailed guidance out of context until it is needed. A model might fail to load a relevant skill, so use `/skill:name` when you need to force it.
 
-### Description Best Practices
+Arguments after `/skill:name` are appended to the loaded instructions as a user request:
 
-The description determines when the agent loads the skill. Be specific.
-
-Good:
-```yaml
-description: Extracts text and tables from PDF files, fills PDF forms, and merges multiple PDFs. Use when working with PDF documents.
-```
-
-Poor:
-```yaml
-description: Helps with PDFs.
+```text
+/skill:pdf-tools extract report.pdf
 ```
 
-## Validation
+Set `disable-model-invocation: true` in frontmatter when a skill should be available only through its explicit command. The `enableSkillCommands` [setting](settings.md) controls whether skill commands appear in interactive command discovery; manually entered `/skill:name` commands still work.
 
-KnightCode validates skills against the Agent Skills standard. Most issues produce warnings but still load the skill:
+<a id="choose-where-it-loads"></a>
 
-- Name exceeds 64 characters or contains invalid characters
-- Name starts/ends with hyphen or has consecutive hyphens
-- Description exceeds 1024 characters
+## Add it to KnightCode
 
-Unknown frontmatter fields are ignored.
+Place the skill in your user or project skills directory. Directories containing `SKILL.md` are discovered recursively.
 
-Declared skills with missing descriptions are not loaded. Malformed `SKILL.md` files and `SKILL.md` files without a description produce warnings and are not loaded. Other Markdown files without valid skill frontmatter are ignored.
+KnightCode also supports the Agent Skills locations `~/.agents/skills/` and `.agents/skills/`. Project `.agents/skills/` directories are discovered from the working directory through its ancestors, stopping at the repository root when one exists.
 
-Name collisions (same name from different locations) warn and keep the first skill found.
+KnightCode accepts some standalone Markdown skills, but a directory containing `SKILL.md` is the portable form and should be preferred. See [Settings](settings.md#resources) and [KnightCode Packages](packages.md) for additional locations.
 
-## Example
-
-```
-brave-search/
-├── SKILL.md
-├── search.js
-└── content.js
-```
+Project skills can instruct the model to run scripts or modify files. Review unfamiliar skills and their supporting files before granting project trust.
 
-**SKILL.md:**
-````markdown
----
-name: brave-search
-description: Web search and content extraction via Brave Search API. Use for searching documentation, facts, or any web content.
----
+## Write portable frontmatter
 
-# Brave Search
+The Agent Skills specification defines these fields:
 
-## Setup
+| Field | Purpose |
+|---|---|
+| `name` | Command and display name |
+| `description` | Routing description shown to the model |
+| `license` | License name or bundled license file |
+| `compatibility` | Environment requirements |
+| `metadata` | Additional key-value metadata |
+| `allowed-tools` | Experimental pre-approved tool list |
+| `disable-model-invocation` | Hide the skill from automatic model selection |
 
-```bash
-cd /path/to/brave-search && npm install
-```
+Names use lowercase letters, numbers, and hyphens, with no leading, trailing, or consecutive hyphens. They can contain at most 64 characters; descriptions can contain at most 1024.
 
-## Search
+KnightCode neither requires nor warns when the declared name differs from the parent directory. Other Agent Skills implementations may enforce that requirement, so matching names remain the portable choice.
 
-```bash
-./search.js "query"              # Basic search
-./search.js "query" --content    # Include page content
-```
+Malformed `SKILL.md` files and declared skills without descriptions are not loaded. Name collisions keep the first discovered skill and produce a warning.
 
-## Extract Page Content
+## Validate and share a skill
 
-```bash
-./content.js https://example.com
-```
-````
+Run KnightCode from a location where the skill is discoverable, then inspect the startup diagnostics and `/skill:name` command. Run `/reload` after editing a skill during an active session.
 
-## Skill Repositories
+Use a [KnightCode package](packages.md) to distribute one or more skills through npm or git. Keep environment setup inside the skill and declare any required runtime dependencies in the package.
 
-- [Anthropic Skills](https://github.com/anthropics/skills) - Document processing (docx, pdf, pptx, xlsx), web development
+For examples, see the [Anthropic skills collection](https://github.com/anthropics/skills).

package/bin/docs/slash-commands.md

@@ -0,0 +1,63 @@
+# Slash commands
+
+Type `/` in KnightCode's terminal editor to search the commands available in the current session. This page lists the built-in commands in the current KnightCode release.
+
+Extensions, prompt templates, and skills can add commands. The command menu in KnightCode is therefore the exact reference for the resources loaded in your session.
+
+## Models and settings
+
+| Command | Description |
+|---|---|
+| `/settings` | Open settings |
+| `/model [provider/model]` | Select a model |
+| `/thinking [level]` | Set the thinking level |
+| `/scoped-models` | Configure the models used by interactive cycling |
+| `/login [provider]` | Add provider authentication |
+| `/logout` | Remove provider authentication |
+| `/tools` | Turn `webfetch`, `websearch`, and the [scratchpad](usage.md#scratchpad) off, on for this session, or on by default; pick the search provider and store its key |
+| `/llama` | Manage models on the configured llama.cpp router |
+
+## Sessions and context
+
+| Command | Description |
+|---|---|
+| `/new` | Start a new session |
+| `/resume` | Switch to another saved session |
+| `/name [name]` | Set the session display name, or show the current name when omitted |
+| `/session` | Show current session information and statistics |
+| `/tree` | Navigate the session tree |
+| `/fork` | Create a new session from an earlier user message |
+| `/clone` | Duplicate the current session at its current position |
+| `/undo` | Go back to an earlier user message; optionally restore the files edited after it |
+| `/compact [instructions]` | Compact the current context, optionally with custom instructions |
+| `/import <path>` | Import and resume a JSONL session |
+
+## Export and share
+
+| Command | Description |
+|---|---|
+| `/copy` | Copy the last assistant message |
+| `/export [path]` | Export the session as HTML or JSONL |
+| `/share` | Upload the session and return a viewer link |
+| `/remote` | Publish this session to a live web link; see [Remote sessions](remote.md) |
+| `/bug [description]` | Prepare a private bug report for the KnightCode developers |
+
+Review a session before exporting or sharing it. Sessions can contain prompts, tool arguments, command output, file contents, and credentials exposed during the conversation.
+
+## Runtime and project
+
+| Command | Description |
+|---|---|
+| `/trust` | Save a project trust decision for future KnightCode processes |
+| `/reload` | Reload keybindings, extensions, skills, templates, themes, and context files |
+| `/hotkeys` | Show active keyboard shortcuts |
+| `/changelog` | Show changelog entries |
+| `/quit` | Quit KnightCode |
+
+## Commands added by resources
+
+- Extensions can register commands with their own arguments and completion behavior.
+- Each prompt template is available under its template name.
+- Skills are available as `/skill:name` when skill commands are enabled.
+
+Use `/reload` after adding or changing a discovered command resource. See [Extensions](extensions.md), [Prompt Templates](prompt-templates.md), and [Skills](skills.md) for their loading and naming rules.