Merge branch 'master' of https://github.com/kunalk16/zeroclaw into fix-honor-default-temperature-agent-command

This commit is contained in:
Kunal Karmakar 2026-03-10 07:19:03 +00:00
commit 76d54193f1
250 changed files with 21999 additions and 2810 deletions

View File

@ -0,0 +1,133 @@
# Skill: github-issue
File a structured GitHub issue (bug report or feature request) for ZeroClaw interactively from Claude Code.
## When to Use
Trigger when the user wants to file a GitHub issue, report a bug, or request a feature for ZeroClaw. Keywords: "file issue", "report bug", "feature request", "open issue", "create issue", "github issue".
## Instructions
You are filing a GitHub issue against the ZeroClaw repository using structured issue forms. Follow this workflow exactly.
### Step 1: Detect Issue Type and Read the Template
Determine from the user's message whether this is a **bug report** or **feature request**.
- If unclear, use AskUserQuestion to ask: "Is this a bug report or a feature request?"
Then read the corresponding issue template to understand the required fields:
- Bug report: `.github/ISSUE_TEMPLATE/bug_report.yml`
- Feature request: `.github/ISSUE_TEMPLATE/feature_request.yml`
Parse the YAML to extract:
- The `title` prefix (e.g. `[Bug]: `, `[Feature]: `)
- The `labels` array
- Each field in the `body` array: its `type` (dropdown, textarea, input, checkboxes, markdown), `id`, `attributes.label`, `attributes.options` (for dropdowns), `attributes.description`, `attributes.placeholder`, and `validations.required`
This is the source of truth for what fields exist, what they're called, what options are available, and which are required. Do not assume or hardcode any field names or options — always derive them from the template file.
### Step 2: Auto-Gather Context
Before asking the user anything, silently gather environment and repo context:
```bash
# Git context
git log --oneline -5
git status --short
git diff --stat HEAD~1 2>/dev/null
# For bug reports — environment detection
uname -s -r -m # OS info
sw_vers 2>/dev/null # macOS version
rustc --version 2>/dev/null # Rust version
cargo metadata --format-version=1 --no-deps 2>/dev/null | jq -r '.packages[] | select(.name=="zeroclaw") | .version' 2>/dev/null # ZeroClaw version
git rev-parse --short HEAD # commit SHA fallback
```
Also read recently changed files to infer the affected component and architecture impact.
### Step 3: Pre-Fill and Present the Form
Using the parsed template fields and gathered context, draft values for ALL fields from the template:
- **dropdown** fields: select the most likely option from `attributes.options` based on context. For dropdowns where you're uncertain, note your best guess and flag it for the user.
- **textarea** fields: draft content based on the user's description, git context, and the field's `attributes.description`/`attributes.placeholder` for guidance on what's expected.
- **input** fields: fill with auto-detected values (versions, OS) or draft from user context.
- **checkboxes** fields: auto-check all items (the skill itself ensures compliance with the stated checks).
- **markdown** fields: skip these — they're informational headers, not form inputs.
- **optional fields** (where `validations.required` is false): fill if there's enough context, otherwise note "(optional — not enough context to fill)".
Present the complete draft to the user in a clean readable format:
```
## Issue Draft: [Bug]: <title> / [Feature]: <title>
**Labels**: <from template>
### <Field Label>
<proposed value or selection>
### <Field Label>
<proposed value>
...
```
Use AskUserQuestion to ask the user to review:
- "Here's the pre-filled issue. Please review and let me know what to change, or say 'submit' to file it."
If the user requests changes, update the draft and re-present. Iterate until the user approves.
### Step 4: Scope Guard
Before final submission, analyze the collected content for scope creep:
- Does the bug report describe multiple independent defects?
- Does the feature request bundle unrelated changes?
If multi-concept issues are detected:
1. Inform the user: "This issue appears to cover multiple distinct topics. Focused, single-concept issues are strongly preferred and more likely to be accepted."
2. Break down the distinct groups found.
3. Offer to file separate issues for each group, reusing shared context (environment, etc.).
4. Let the user decide: proceed as-is or split.
### Step 5: Construct Issue Body
Build the issue body as markdown sections matching GitHub's form-field rendering format. GitHub renders form-submitted issues with `### <Field Label>` sections, so use that exact structure.
For each non-markdown field from the template, in order:
```markdown
### <attributes.label>
<value>
```
For optional fields with no content, use `_No response_` as the value (this matches GitHub's native rendering for empty optional fields).
For checkbox fields, render each option as:
```markdown
- [X] <option label text>
```
### Step 6: Final Preview and Submit
Show the final constructed issue (title + labels + full body) for one last confirmation.
Then submit using a HEREDOC for the body to preserve formatting:
```bash
gh issue create --title "<title prefix><user title>" --label "<label1>,<label2>" --body "$(cat <<'ISSUE_EOF'
<body content>
ISSUE_EOF
)"
```
Return the resulting issue URL to the user.
### Important Rules
- **Always read the template file** — never assume field names, options, or structure. The templates are the source of truth and may change over time.
- **Never include personal/sensitive data** in the issue. Redact secrets, tokens, emails, real names.
- **Use neutral project-scoped placeholders** per ZeroClaw's privacy contract.
- **One concept per issue** — enforce the scope guard.
- **Auto-detect, don't guess** — use real command output for environment fields.
- **Match GitHub's rendering** — use `### Field Label` sections so issues look consistent whether filed via web UI or this skill.

View File

@ -0,0 +1,209 @@
# Skill: github-pr
Open or update a GitHub Pull Request for ZeroClaw. Handles creating new PRs with a fully filled-out template body, and updating existing PRs (title, body sections, labels, comments). Use this skill whenever the user wants to open a PR, create a pull request, update a PR, edit PR description, add labels to a PR, or sync a PR after new commits — even if they don't say "PR" explicitly (e.g., "submit this for review", "push and open for merge").
## Instructions
This skill supports two modes: **Open** (create a new PR) and **Update** (edit an existing PR). Detect the mode from context — if there's already an open PR for the current branch and the user didn't say "open a new PR", default to update mode.
The PR template at `.github/pull_request_template.md` is the source of truth for the PR body structure. Read it every time — never assume or hardcode section names, fields, or their order. The template may change over time and the skill should always reflect its current state.
---
## Shared: Read the PR Template
Before opening or updating a PR body, read `.github/pull_request_template.md` and parse it to understand:
- The `## ` section headers (these are the top-level sections of the PR body)
- The bullet points, fields, and prompts within each section
- Which sections are marked `(required)` vs optional/recommended
- Any inline formatting conventions (backtick options, Yes/No fields, etc.)
This parsed structure drives how you fill, present, and edit the PR body.
---
## Mode: Open a New PR
### Step 1: Gather Context
Collect information to pre-fill the PR body. Run these in parallel:
```bash
# Branch and commit context
git branch --show-current
git log master..HEAD --oneline
git diff master...HEAD --stat
# Check if branch is pushed
git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null
# Environment (for validation evidence)
rustc --version 2>/dev/null
```
Also review the changed files and commit messages to understand the nature of the change (bug fix, feature, refactor, docs, chore, etc.) and which subsystems are affected.
### Step 2: Pre-Fill the Template
Using the parsed template structure and gathered context, draft a complete PR body:
- For each `## ` section from the template, fill in the bullet points and fields based on context from the commits, diff, and changed files.
- Use the field descriptions and placeholder text in the template as guidance for what each field expects.
- For Yes/No fields, infer from the diff (e.g., if no files in `src/security/` changed, security impact is likely all No).
- For required sections, always provide a substantive answer. For optional sections, fill if there's enough context, otherwise leave the template prompts in place.
- Draft a conventional commit-style PR title based on the changes (e.g., `feat(provider): add retry budget override`, `fix(channel): handle disconnect gracefully`, `chore(ci): update workflow targets`).
### Step 3: Present Draft for Review
Show the user the complete draft:
```
## PR Draft: <title>
**Branch**: <head> -> master
**Labels**: <suggested labels>
<full body with all sections filled>
```
Ask the user to review: "Here's the pre-filled PR. Review and let me know what to change, or say 'submit' to open it."
Iterate on changes until the user approves.
### Step 4: Push and Create
1. If the branch isn't pushed yet, push it:
```bash
git push -u origin <branch>
```
2. Create the PR using a HEREDOC for the body:
```bash
gh pr create --title "<title>" --base master --body "$(cat <<'PR_BODY_EOF'
<full body>
PR_BODY_EOF
)"
```
3. If labels were agreed on, add them:
```bash
gh pr edit <number> --add-label "<label1>,<label2>"
```
4. Return the PR URL to the user.
---
## Mode: Update an Existing PR
### Step 1: Identify the PR
1. **If a PR number or URL is given**: use that directly.
2. **If on a branch with an open PR**: auto-detect:
```bash
gh pr view --json number,title,body,labels,state,author,url,headRefName 2>/dev/null
```
3. **If neither**: ask the user for the PR number.
Verify the current user is the PR author:
```bash
CURRENT_USER=$(gh api user --jq '.login')
PR_AUTHOR=$(gh pr view <number> --json author --jq '.author.login')
```
If not the author, stop and inform the user.
### Step 2: Fetch Current State
```bash
gh pr view <number> --json number,title,body,labels,state,baseRefName,headRefName,url,author,reviewDecision,statusCheckRollup,commits
```
Display a summary:
```
## PR #<number>: <title>
**State**: <open/closed/merged>
**Branch**: <head> -> <base>
**Labels**: <label list>
**Checks**: <pass/fail/pending>
**URL**: <url>
```
### Step 3: Determine What to Update
Support these operations:
| Operation | How |
|---|---|
| **Edit title** | `gh pr edit <number> --title "<new title>"` |
| **Edit full body** | `gh pr edit <number> --body "<new body>"` |
| **Add labels** | `gh pr edit <number> --add-label "<label1>,<label2>"` |
| **Remove labels** | `gh pr edit <number> --remove-label "<label1>"` |
| **Edit specific section** | Parse body by `## ` headers, modify target section, re-submit full body |
| **Add a comment** | `gh pr comment <number> --body "<comment>"` |
| **Link an issue** | Edit the linked-issue section in the body |
| **Smart update after new commits** | Re-analyze and suggest section updates |
### Step 4: Handle Body Section Edits
When editing a specific section:
1. Parse the current PR body into sections by `## ` headers
2. Match the user's request to the corresponding section from the template
3. Show the current content of that section and the proposed replacement
4. On confirmation, modify only that section, reconstruct the full body, and submit
### Step 5: Smart Update After New Commits
When the user wants to sync the PR description after pushing new changes:
1. Identify new commits:
```bash
gh pr view <number> --json commits --jq '.commits[].messageHeadline'
git log <base>..<head> --oneline
git diff <base>...<head> --stat
```
2. Re-read the PR template. Analyze which sections are now stale based on the new changes — use the template's section names and field descriptions to identify what needs updating rather than relying on hardcoded assumptions.
3. Present proposed updates section-by-section and confirm before applying.
### Step 6: Apply Updates
For title/label changes, use direct `gh pr edit` flags.
For body edits, use a HEREDOC:
```bash
gh pr edit <number> --body "$(cat <<'PR_BODY_EOF'
<full updated body>
PR_BODY_EOF
)"
```
For comments:
```bash
gh pr comment <number> --body "$(cat <<'COMMENT_EOF'
<comment text>
COMMENT_EOF
)"
```
### Step 7: Confirm
Fetch and display the updated state:
```bash
gh pr view <number> --json number,title,labels,url
```
Return the PR URL.
---
## Important Rules
- **Always read `.github/pull_request_template.md`** before filling or editing a PR body. Never assume section names, fields, or structure — derive everything from the template. It's the source of truth and may change.
- **For updates, only modify requested sections.** Preserve everything else exactly as-is.
- **Always show diffs before applying body edits.** Present current vs proposed for each changed section.
- **Never include personal/sensitive data** in PR content per ZeroClaw's privacy contract.
- **For label changes**, only use labels that exist in the repository. Check with `gh label list` if unsure.
- **Fetch the latest body before editing** to avoid clobbering concurrent changes.
- **For new PRs**, push the branch before creating (with `-u` to set upstream tracking).

View File

@ -0,0 +1,202 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

View File

@ -0,0 +1,485 @@
---
name: skill-creator
description: Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
---
# Skill Creator
A skill for creating new skills and iteratively improving them.
At a high level, the process of creating a skill goes like this:
- Decide what you want the skill to do and roughly how it should do it
- Write a draft of the skill
- Create a few test prompts and run claude-with-access-to-the-skill on them
- Help the user evaluate the results both qualitatively and quantitatively
- While the runs happen in the background, draft some quantitative evals if there aren't any (if there are some, you can either use as is or modify if you feel something needs to change about them). Then explain them to the user (or if they already existed, explain the ones that already exist)
- Use the `eval-viewer/generate_review.py` script to show the user the results for them to look at, and also let them look at the quantitative metrics
- Rewrite the skill based on feedback from the user's evaluation of the results (and also if there are any glaring flaws that become apparent from the quantitative benchmarks)
- Repeat until you're satisfied
- Expand the test set and try again at larger scale
Your job when using this skill is to figure out where the user is in this process and then jump in and help them progress through these stages. So for instance, maybe they're like "I want to make a skill for X". You can help narrow down what they mean, write a draft, write the test cases, figure out how they want to evaluate, run all the prompts, and repeat.
On the other hand, maybe they already have a draft of the skill. In this case you can go straight to the eval/iterate part of the loop.
Of course, you should always be flexible and if the user is like "I don't need to run a bunch of evaluations, just vibe with me", you can do that instead.
Then after the skill is done (but again, the order is flexible), you can also run the skill description improver, which we have a whole separate script for, to optimize the triggering of the skill.
Cool? Cool.
## Communicating with the user
The skill creator is liable to be used by people across a wide range of familiarity with coding jargon. If you haven't heard (and how could you, it's only very recently that it started), there's a trend now where the power of Claude is inspiring plumbers to open up their terminals, parents and grandparents to google "how to install npm". On the other hand, the bulk of users are probably fairly computer-literate.
So please pay attention to context cues to understand how to phrase your communication! In the default case, just to give you some idea:
- "evaluation" and "benchmark" are borderline, but OK
- for "JSON" and "assertion" you want to see serious cues from the user that they know what those things are before using them without explaining them
It's OK to briefly explain terms if you're in doubt, and feel free to clarify terms with a short definition if you're unsure if the user will get it.
---
## Creating a skill
### Capture Intent
Start by understanding the user's intent. The current conversation might already contain a workflow the user wants to capture (e.g., they say "turn this into a skill"). If so, extract answers from the conversation history first — the tools used, the sequence of steps, corrections the user made, input/output formats observed. The user may need to fill the gaps, and should confirm before proceeding to the next step.
1. What should this skill enable Claude to do?
2. When should this skill trigger? (what user phrases/contexts)
3. What's the expected output format?
4. Should we set up test cases to verify the skill works? Skills with objectively verifiable outputs (file transforms, data extraction, code generation, fixed workflow steps) benefit from test cases. Skills with subjective outputs (writing style, art) often don't need them. Suggest the appropriate default based on the skill type, but let the user decide.
### Interview and Research
Proactively ask questions about edge cases, input/output formats, example files, success criteria, and dependencies. Wait to write test prompts until you've got this part ironed out.
Check available MCPs - if useful for research (searching docs, finding similar skills, looking up best practices), research in parallel via subagents if available, otherwise inline. Come prepared with context to reduce burden on the user.
### Write the SKILL.md
Based on the user interview, fill in these components:
- **name**: Skill identifier
- **description**: When to trigger, what it does. This is the primary triggering mechanism - include both what the skill does AND specific contexts for when to use it. All "when to use" info goes here, not in the body. Note: currently Claude has a tendency to "undertrigger" skills -- to not use them when they'd be useful. To combat this, please make the skill descriptions a little bit "pushy". So for instance, instead of "How to build a simple fast dashboard to display internal Anthropic data.", you might write "How to build a simple fast dashboard to display internal Anthropic data. Make sure to use this skill whenever the user mentions dashboards, data visualization, internal metrics, or wants to display any kind of company data, even if they don't explicitly ask for a 'dashboard.'"
- **compatibility**: Required tools, dependencies (optional, rarely needed)
- **the rest of the skill :)**
### Skill Writing Guide
#### Anatomy of a Skill
```
skill-name/
├── SKILL.md (required)
│ ├── YAML frontmatter (name, description required)
│ └── Markdown instructions
└── Bundled Resources (optional)
├── scripts/ - Executable code for deterministic/repetitive tasks
├── references/ - Docs loaded into context as needed
└── assets/ - Files used in output (templates, icons, fonts)
```
#### Progressive Disclosure
Skills use a three-level loading system:
1. **Metadata** (name + description) - Always in context (~100 words)
2. **SKILL.md body** - In context whenever skill triggers (<500 lines ideal)
3. **Bundled resources** - As needed (unlimited, scripts can execute without loading)
These word counts are approximate and you can feel free to go longer if needed.
**Key patterns:**
- Keep SKILL.md under 500 lines; if you're approaching this limit, add an additional layer of hierarchy along with clear pointers about where the model using the skill should go next to follow up.
- Reference files clearly from SKILL.md with guidance on when to read them
- For large reference files (>300 lines), include a table of contents
**Domain organization**: When a skill supports multiple domains/frameworks, organize by variant:
```
cloud-deploy/
├── SKILL.md (workflow + selection)
└── references/
├── aws.md
├── gcp.md
└── azure.md
```
Claude reads only the relevant reference file.
#### Principle of Lack of Surprise
This goes without saying, but skills must not contain malware, exploit code, or any content that could compromise system security. A skill's contents should not surprise the user in their intent if described. Don't go along with requests to create misleading skills or skills designed to facilitate unauthorized access, data exfiltration, or other malicious activities. Things like a "roleplay as an XYZ" are OK though.
#### Writing Patterns
Prefer using the imperative form in instructions.
**Defining output formats** - You can do it like this:
```markdown
## Report structure
ALWAYS use this exact template:
# [Title]
## Executive summary
## Key findings
## Recommendations
```
**Examples pattern** - It's useful to include examples. You can format them like this (but if "Input" and "Output" are in the examples you might want to deviate a little):
```markdown
## Commit message format
**Example 1:**
Input: Added user authentication with JWT tokens
Output: feat(auth): implement JWT-based authentication
```
### Writing Style
Try to explain to the model why things are important in lieu of heavy-handed musty MUSTs. Use theory of mind and try to make the skill general and not super-narrow to specific examples. Start by writing a draft and then look at it with fresh eyes and improve it.
### Test Cases
After writing the skill draft, come up with 2-3 realistic test prompts — the kind of thing a real user would actually say. Share them with the user: [you don't have to use this exact language] "Here are a few test cases I'd like to try. Do these look right, or do you want to add more?" Then run them.
Save test cases to `evals/evals.json`. Don't write assertions yet — just the prompts. You'll draft assertions in the next step while the runs are in progress.
```json
{
"skill_name": "example-skill",
"evals": [
{
"id": 1,
"prompt": "User's task prompt",
"expected_output": "Description of expected result",
"files": []
}
]
}
```
See `references/schemas.md` for the full schema (including the `assertions` field, which you'll add later).
## Running and evaluating test cases
This section is one continuous sequence — don't stop partway through. Do NOT use `/skill-test` or any other testing skill.
Put results in `<skill-name>-workspace/` as a sibling to the skill directory. Within the workspace, organize results by iteration (`iteration-1/`, `iteration-2/`, etc.) and within that, each test case gets a directory (`eval-0/`, `eval-1/`, etc.). Don't create all of this upfront — just create directories as you go.
### Step 1: Spawn all runs (with-skill AND baseline) in the same turn
For each test case, spawn two subagents in the same turn — one with the skill, one without. This is important: don't spawn the with-skill runs first and then come back for baselines later. Launch everything at once so it all finishes around the same time.
**With-skill run:**
```
Execute this task:
- Skill path: <path-to-skill>
- Task: <eval prompt>
- Input files: <eval files if any, or "none">
- Save outputs to: <workspace>/iteration-<N>/eval-<ID>/with_skill/outputs/
- Outputs to save: <what the user cares about e.g., "the .docx file", "the final CSV">
```
**Baseline run** (same prompt, but the baseline depends on context):
- **Creating a new skill**: no skill at all. Same prompt, no skill path, save to `without_skill/outputs/`.
- **Improving an existing skill**: the old version. Before editing, snapshot the skill (`cp -r <skill-path> <workspace>/skill-snapshot/`), then point the baseline subagent at the snapshot. Save to `old_skill/outputs/`.
Write an `eval_metadata.json` for each test case (assertions can be empty for now). Give each eval a descriptive name based on what it's testing — not just "eval-0". Use this name for the directory too. If this iteration uses new or modified eval prompts, create these files for each new eval directory — don't assume they carry over from previous iterations.
```json
{
"eval_id": 0,
"eval_name": "descriptive-name-here",
"prompt": "The user's task prompt",
"assertions": []
}
```
### Step 2: While runs are in progress, draft assertions
Don't just wait for the runs to finish — you can use this time productively. Draft quantitative assertions for each test case and explain them to the user. If assertions already exist in `evals/evals.json`, review them and explain what they check.
Good assertions are objectively verifiable and have descriptive names — they should read clearly in the benchmark viewer so someone glancing at the results immediately understands what each one checks. Subjective skills (writing style, design quality) are better evaluated qualitatively — don't force assertions onto things that need human judgment.
Update the `eval_metadata.json` files and `evals/evals.json` with the assertions once drafted. Also explain to the user what they'll see in the viewer — both the qualitative outputs and the quantitative benchmark.
### Step 3: As runs complete, capture timing data
When each subagent task completes, you receive a notification containing `total_tokens` and `duration_ms`. Save this data immediately to `timing.json` in the run directory:
```json
{
"total_tokens": 84852,
"duration_ms": 23332,
"total_duration_seconds": 23.3
}
```
This is the only opportunity to capture this data — it comes through the task notification and isn't persisted elsewhere. Process each notification as it arrives rather than trying to batch them.
### Step 4: Grade, aggregate, and launch the viewer
Once all runs are done:
1. **Grade each run** — spawn a grader subagent (or grade inline) that reads `agents/grader.md` and evaluates each assertion against the outputs. Save results to `grading.json` in each run directory. The grading.json expectations array must use the fields `text`, `passed`, and `evidence` (not `name`/`met`/`details` or other variants) — the viewer depends on these exact field names. For assertions that can be checked programmatically, write and run a script rather than eyeballing it — scripts are faster, more reliable, and can be reused across iterations.
2. **Aggregate into benchmark** — run the aggregation script from the skill-creator directory:
```bash
python -m scripts.aggregate_benchmark <workspace>/iteration-N --skill-name <name>
```
This produces `benchmark.json` and `benchmark.md` with pass_rate, time, and tokens for each configuration, with mean ± stddev and the delta. If generating benchmark.json manually, see `references/schemas.md` for the exact schema the viewer expects.
Put each with_skill version before its baseline counterpart.
3. **Do an analyst pass** — read the benchmark data and surface patterns the aggregate stats might hide. See `agents/analyzer.md` (the "Analyzing Benchmark Results" section) for what to look for — things like assertions that always pass regardless of skill (non-discriminating), high-variance evals (possibly flaky), and time/token tradeoffs.
4. **Launch the viewer** with both qualitative outputs and quantitative data:
```bash
nohup python <skill-creator-path>/eval-viewer/generate_review.py \
<workspace>/iteration-N \
--skill-name "my-skill" \
--benchmark <workspace>/iteration-N/benchmark.json \
> /dev/null 2>&1 &
VIEWER_PID=$!
```
For iteration 2+, also pass `--previous-workspace <workspace>/iteration-<N-1>`.
**Cowork / headless environments:** If `webbrowser.open()` is not available or the environment has no display, use `--static <output_path>` to write a standalone HTML file instead of starting a server. Feedback will be downloaded as a `feedback.json` file when the user clicks "Submit All Reviews". After download, copy `feedback.json` into the workspace directory for the next iteration to pick up.
Note: please use generate_review.py to create the viewer; there's no need to write custom HTML.
5. **Tell the user** something like: "I've opened the results in your browser. There are two tabs — 'Outputs' lets you click through each test case and leave feedback, 'Benchmark' shows the quantitative comparison. When you're done, come back here and let me know."
### What the user sees in the viewer
The "Outputs" tab shows one test case at a time:
- **Prompt**: the task that was given
- **Output**: the files the skill produced, rendered inline where possible
- **Previous Output** (iteration 2+): collapsed section showing last iteration's output
- **Formal Grades** (if grading was run): collapsed section showing assertion pass/fail
- **Feedback**: a textbox that auto-saves as they type
- **Previous Feedback** (iteration 2+): their comments from last time, shown below the textbox
The "Benchmark" tab shows the stats summary: pass rates, timing, and token usage for each configuration, with per-eval breakdowns and analyst observations.
Navigation is via prev/next buttons or arrow keys. When done, they click "Submit All Reviews" which saves all feedback to `feedback.json`.
### Step 5: Read the feedback
When the user tells you they're done, read `feedback.json`:
```json
{
"reviews": [
{"run_id": "eval-0-with_skill", "feedback": "the chart is missing axis labels", "timestamp": "..."},
{"run_id": "eval-1-with_skill", "feedback": "", "timestamp": "..."},
{"run_id": "eval-2-with_skill", "feedback": "perfect, love this", "timestamp": "..."}
],
"status": "complete"
}
```
Empty feedback means the user thought it was fine. Focus your improvements on the test cases where the user had specific complaints.
Kill the viewer server when you're done with it:
```bash
kill $VIEWER_PID 2>/dev/null
```
---
## Improving the skill
This is the heart of the loop. You've run the test cases, the user has reviewed the results, and now you need to make the skill better based on their feedback.
### How to think about improvements
1. **Generalize from the feedback.** The big picture thing that's happening here is that we're trying to create skills that can be used a million times (maybe literally, maybe even more who knows) across many different prompts. Here you and the user are iterating on only a few examples over and over again because it helps move faster. The user knows these examples in and out and it's quick for them to assess new outputs. But if the skill you and the user are codeveloping works only for those examples, it's useless. Rather than put in fiddly overfitty changes, or oppressively constrictive MUSTs, if there's some stubborn issue, you might try branching out and using different metaphors, or recommending different patterns of working. It's relatively cheap to try and maybe you'll land on something great.
2. **Keep the prompt lean.** Remove things that aren't pulling their weight. Make sure to read the transcripts, not just the final outputs — if it looks like the skill is making the model waste a bunch of time doing things that are unproductive, you can try getting rid of the parts of the skill that are making it do that and seeing what happens.
3. **Explain the why.** Try hard to explain the **why** behind everything you're asking the model to do. Today's LLMs are *smart*. They have good theory of mind and when given a good harness can go beyond rote instructions and really make things happen. Even if the feedback from the user is terse or frustrated, try to actually understand the task and why the user is writing what they wrote, and what they actually wrote, and then transmit this understanding into the instructions. If you find yourself writing ALWAYS or NEVER in all caps, or using super rigid structures, that's a yellow flag — if possible, reframe and explain the reasoning so that the model understands why the thing you're asking for is important. That's a more humane, powerful, and effective approach.
4. **Look for repeated work across test cases.** Read the transcripts from the test runs and notice if the subagents all independently wrote similar helper scripts or took the same multi-step approach to something. If all 3 test cases resulted in the subagent writing a `create_docx.py` or a `build_chart.py`, that's a strong signal the skill should bundle that script. Write it once, put it in `scripts/`, and tell the skill to use it. This saves every future invocation from reinventing the wheel.
This task is pretty important (we are trying to create billions a year in economic value here!) and your thinking time is not the blocker; take your time and really mull things over. I'd suggest writing a draft revision and then looking at it anew and making improvements. Really do your best to get into the head of the user and understand what they want and need.
### The iteration loop
After improving the skill:
1. Apply your improvements to the skill
2. Rerun all test cases into a new `iteration-<N+1>/` directory, including baseline runs. If you're creating a new skill, the baseline is always `without_skill` (no skill) — that stays the same across iterations. If you're improving an existing skill, use your judgment on what makes sense as the baseline: the original version the user came in with, or the previous iteration.
3. Launch the reviewer with `--previous-workspace` pointing at the previous iteration
4. Wait for the user to review and tell you they're done
5. Read the new feedback, improve again, repeat
Keep going until:
- The user says they're happy
- The feedback is all empty (everything looks good)
- You're not making meaningful progress
---
## Advanced: Blind comparison
For situations where you want a more rigorous comparison between two versions of a skill (e.g., the user asks "is the new version actually better?"), there's a blind comparison system. Read `agents/comparator.md` and `agents/analyzer.md` for the details. The basic idea is: give two outputs to an independent agent without telling it which is which, and let it judge quality. Then analyze why the winner won.
This is optional, requires subagents, and most users won't need it. The human review loop is usually sufficient.
---
## Description Optimization
The description field in SKILL.md frontmatter is the primary mechanism that determines whether Claude invokes a skill. After creating or improving a skill, offer to optimize the description for better triggering accuracy.
### Step 1: Generate trigger eval queries
Create 20 eval queries — a mix of should-trigger and should-not-trigger. Save as JSON:
```json
[
{"query": "the user prompt", "should_trigger": true},
{"query": "another prompt", "should_trigger": false}
]
```
The queries must be realistic and something a Claude Code or Claude.ai user would actually type. Not abstract requests, but requests that are concrete and specific and have a good amount of detail. For instance, file paths, personal context about the user's job or situation, column names and values, company names, URLs. A little bit of backstory. Some might be in lowercase or contain abbreviations or typos or casual speech. Use a mix of different lengths, and focus on edge cases rather than making them clear-cut (the user will get a chance to sign off on them).
Bad: `"Format this data"`, `"Extract text from PDF"`, `"Create a chart"`
Good: `"ok so my boss just sent me this xlsx file (its in my downloads, called something like 'Q4 sales final FINAL v2.xlsx') and she wants me to add a column that shows the profit margin as a percentage. The revenue is in column C and costs are in column D i think"`
For the **should-trigger** queries (8-10), think about coverage. You want different phrasings of the same intent — some formal, some casual. Include cases where the user doesn't explicitly name the skill or file type but clearly needs it. Throw in some uncommon use cases and cases where this skill competes with another but should win.
For the **should-not-trigger** queries (8-10), the most valuable ones are the near-misses — queries that share keywords or concepts with the skill but actually need something different. Think adjacent domains, ambiguous phrasing where a naive keyword match would trigger but shouldn't, and cases where the query touches on something the skill does but in a context where another tool is more appropriate.
The key thing to avoid: don't make should-not-trigger queries obviously irrelevant. "Write a fibonacci function" as a negative test for a PDF skill is too easy — it doesn't test anything. The negative cases should be genuinely tricky.
### Step 2: Review with user
Present the eval set to the user for review using the HTML template:
1. Read the template from `assets/eval_review.html`
2. Replace the placeholders:
- `__EVAL_DATA_PLACEHOLDER__` → the JSON array of eval items (no quotes around it — it's a JS variable assignment)
- `__SKILL_NAME_PLACEHOLDER__` → the skill's name
- `__SKILL_DESCRIPTION_PLACEHOLDER__` → the skill's current description
3. Write to a temp file (e.g., `/tmp/eval_review_<skill-name>.html`) and open it: `open /tmp/eval_review_<skill-name>.html`
4. The user can edit queries, toggle should-trigger, add/remove entries, then click "Export Eval Set"
5. The file downloads to `~/Downloads/eval_set.json` — check the Downloads folder for the most recent version in case there are multiple (e.g., `eval_set (1).json`)
This step matters — bad eval queries lead to bad descriptions.
### Step 3: Run the optimization loop
Tell the user: "This will take some time — I'll run the optimization loop in the background and check on it periodically."
Save the eval set to the workspace, then run in the background:
```bash
python -m scripts.run_loop \
--eval-set <path-to-trigger-eval.json> \
--skill-path <path-to-skill> \
--model <model-id-powering-this-session> \
--max-iterations 5 \
--verbose
```
Use the model ID from your system prompt (the one powering the current session) so the triggering test matches what the user actually experiences.
While it runs, periodically tail the output to give the user updates on which iteration it's on and what the scores look like.
This handles the full optimization loop automatically. It splits the eval set into 60% train and 40% held-out test, evaluates the current description (running each query 3 times to get a reliable trigger rate), then calls Claude to propose improvements based on what failed. It re-evaluates each new description on both train and test, iterating up to 5 times. When it's done, it opens an HTML report in the browser showing the results per iteration and returns JSON with `best_description` — selected by test score rather than train score to avoid overfitting.
### How skill triggering works
Understanding the triggering mechanism helps design better eval queries. Skills appear in Claude's `available_skills` list with their name + description, and Claude decides whether to consult a skill based on that description. The important thing to know is that Claude only consults skills for tasks it can't easily handle on its own — simple, one-step queries like "read this PDF" may not trigger a skill even if the description matches perfectly, because Claude can handle them directly with basic tools. Complex, multi-step, or specialized queries reliably trigger skills when the description matches.
This means your eval queries should be substantive enough that Claude would actually benefit from consulting a skill. Simple queries like "read file X" are poor test cases — they won't trigger skills regardless of description quality.
### Step 4: Apply the result
Take `best_description` from the JSON output and update the skill's SKILL.md frontmatter. Show the user before/after and report the scores.
---
### Package and Present (only if `present_files` tool is available)
Check whether you have access to the `present_files` tool. If you don't, skip this step. If you do, package the skill and present the .skill file to the user:
```bash
python -m scripts.package_skill <path/to/skill-folder>
```
After packaging, direct the user to the resulting `.skill` file path so they can install it.
---
## Claude.ai-specific instructions
In Claude.ai, the core workflow is the same (draft → test → review → improve → repeat), but because Claude.ai doesn't have subagents, some mechanics change. Here's what to adapt:
**Running test cases**: No subagents means no parallel execution. For each test case, read the skill's SKILL.md, then follow its instructions to accomplish the test prompt yourself. Do them one at a time. This is less rigorous than independent subagents (you wrote the skill and you're also running it, so you have full context), but it's a useful sanity check — and the human review step compensates. Skip the baseline runs — just use the skill to complete the task as requested.
**Reviewing results**: If you can't open a browser (e.g., Claude.ai's VM has no display, or you're on a remote server), skip the browser reviewer entirely. Instead, present results directly in the conversation. For each test case, show the prompt and the output. If the output is a file the user needs to see (like a .docx or .xlsx), save it to the filesystem and tell them where it is so they can download and inspect it. Ask for feedback inline: "How does this look? Anything you'd change?"
**Benchmarking**: Skip the quantitative benchmarking — it relies on baseline comparisons which aren't meaningful without subagents. Focus on qualitative feedback from the user.
**The iteration loop**: Same as before — improve the skill, rerun the test cases, ask for feedback — just without the browser reviewer in the middle. You can still organize results into iteration directories on the filesystem if you have one.
**Description optimization**: This section requires the `claude` CLI tool (specifically `claude -p`) which is only available in Claude Code. Skip it if you're on Claude.ai.
**Blind comparison**: Requires subagents. Skip it.
**Packaging**: The `package_skill.py` script works anywhere with Python and a filesystem. On Claude.ai, you can run it and the user can download the resulting `.skill` file.
**Updating an existing skill**: The user might be asking you to update an existing skill, not create a new one. In this case:
- **Preserve the original name.** Note the skill's directory name and `name` frontmatter field -- use them unchanged. E.g., if the installed skill is `research-helper`, output `research-helper.skill` (not `research-helper-v2`).
- **Copy to a writeable location before editing.** The installed skill path may be read-only. Copy to `/tmp/skill-name/`, edit there, and package from the copy.
- **If packaging manually, stage in `/tmp/` first**, then copy to the output directory -- direct writes may fail due to permissions.
---
## Cowork-Specific Instructions
If you're in Cowork, the main things to know are:
- You have subagents, so the main workflow (spawn test cases in parallel, run baselines, grade, etc.) all works. (However, if you run into severe problems with timeouts, it's OK to run the test prompts in series rather than parallel.)
- You don't have a browser or display, so when generating the eval viewer, use `--static <output_path>` to write a standalone HTML file instead of starting a server. Then proffer a link that the user can click to open the HTML in their browser.
- For whatever reason, the Cowork setup seems to disincline Claude from generating the eval viewer after running the tests, so just to reiterate: whether you're in Cowork or in Claude Code, after running tests, you should always generate the eval viewer for the human to look at examples before revising the skill yourself and trying to make corrections, using `generate_review.py` (not writing your own boutique html code). Sorry in advance but I'm gonna go all caps here: GENERATE THE EVAL VIEWER *BEFORE* evaluating inputs yourself. You want to get them in front of the human ASAP!
- Feedback works differently: since there's no running server, the viewer's "Submit All Reviews" button will download `feedback.json` as a file. You can then read it from there (you may have to request access first).
- Packaging works — `package_skill.py` just needs Python and a filesystem.
- Description optimization (`run_loop.py` / `run_eval.py`) should work in Cowork just fine since it uses `claude -p` via subprocess, not a browser, but please save it until you've fully finished making the skill and the user agrees it's in good shape.
- **Updating an existing skill**: The user might be asking you to update an existing skill, not create a new one. Follow the update guidance in the claude.ai section above.
---
## Reference files
The agents/ directory contains instructions for specialized subagents. Read them when you need to spawn the relevant subagent.
- `agents/grader.md` — How to evaluate assertions against outputs
- `agents/comparator.md` — How to do blind A/B comparison between two outputs
- `agents/analyzer.md` — How to analyze why one version beat another
The references/ directory has additional documentation:
- `references/schemas.md` — JSON structures for evals.json, grading.json, etc.
---
Repeating one more time the core loop here for emphasis:
- Figure out what the skill is about
- Draft or edit the skill
- Run claude-with-access-to-the-skill on test prompts
- With the user, evaluate the outputs:
- Create benchmark.json and run `eval-viewer/generate_review.py` to help the user review them
- Run quantitative evals
- Repeat until you and the user are satisfied
- Package the final skill and return it to the user.
Please add steps to your TodoList, if you have such a thing, to make sure you don't forget. If you're in Cowork, please specifically put "Create evals JSON and run `eval-viewer/generate_review.py` so human can review test cases" in your TodoList to make sure it happens.
Good luck!

View File

@ -0,0 +1,274 @@
# Post-hoc Analyzer Agent
Analyze blind comparison results to understand WHY the winner won and generate improvement suggestions.
## Role
After the blind comparator determines a winner, the Post-hoc Analyzer "unblids" the results by examining the skills and transcripts. The goal is to extract actionable insights: what made the winner better, and how can the loser be improved?
## Inputs
You receive these parameters in your prompt:
- **winner**: "A" or "B" (from blind comparison)
- **winner_skill_path**: Path to the skill that produced the winning output
- **winner_transcript_path**: Path to the execution transcript for the winner
- **loser_skill_path**: Path to the skill that produced the losing output
- **loser_transcript_path**: Path to the execution transcript for the loser
- **comparison_result_path**: Path to the blind comparator's output JSON
- **output_path**: Where to save the analysis results
## Process
### Step 1: Read Comparison Result
1. Read the blind comparator's output at comparison_result_path
2. Note the winning side (A or B), the reasoning, and any scores
3. Understand what the comparator valued in the winning output
### Step 2: Read Both Skills
1. Read the winner skill's SKILL.md and key referenced files
2. Read the loser skill's SKILL.md and key referenced files
3. Identify structural differences:
- Instructions clarity and specificity
- Script/tool usage patterns
- Example coverage
- Edge case handling
### Step 3: Read Both Transcripts
1. Read the winner's transcript
2. Read the loser's transcript
3. Compare execution patterns:
- How closely did each follow their skill's instructions?
- What tools were used differently?
- Where did the loser diverge from optimal behavior?
- Did either encounter errors or make recovery attempts?
### Step 4: Analyze Instruction Following
For each transcript, evaluate:
- Did the agent follow the skill's explicit instructions?
- Did the agent use the skill's provided tools/scripts?
- Were there missed opportunities to leverage skill content?
- Did the agent add unnecessary steps not in the skill?
Score instruction following 1-10 and note specific issues.
### Step 5: Identify Winner Strengths
Determine what made the winner better:
- Clearer instructions that led to better behavior?
- Better scripts/tools that produced better output?
- More comprehensive examples that guided edge cases?
- Better error handling guidance?
Be specific. Quote from skills/transcripts where relevant.
### Step 6: Identify Loser Weaknesses
Determine what held the loser back:
- Ambiguous instructions that led to suboptimal choices?
- Missing tools/scripts that forced workarounds?
- Gaps in edge case coverage?
- Poor error handling that caused failures?
### Step 7: Generate Improvement Suggestions
Based on the analysis, produce actionable suggestions for improving the loser skill:
- Specific instruction changes to make
- Tools/scripts to add or modify
- Examples to include
- Edge cases to address
Prioritize by impact. Focus on changes that would have changed the outcome.
### Step 8: Write Analysis Results
Save structured analysis to `{output_path}`.
## Output Format
Write a JSON file with this structure:
```json
{
"comparison_summary": {
"winner": "A",
"winner_skill": "path/to/winner/skill",
"loser_skill": "path/to/loser/skill",
"comparator_reasoning": "Brief summary of why comparator chose winner"
},
"winner_strengths": [
"Clear step-by-step instructions for handling multi-page documents",
"Included validation script that caught formatting errors",
"Explicit guidance on fallback behavior when OCR fails"
],
"loser_weaknesses": [
"Vague instruction 'process the document appropriately' led to inconsistent behavior",
"No script for validation, agent had to improvise and made errors",
"No guidance on OCR failure, agent gave up instead of trying alternatives"
],
"instruction_following": {
"winner": {
"score": 9,
"issues": [
"Minor: skipped optional logging step"
]
},
"loser": {
"score": 6,
"issues": [
"Did not use the skill's formatting template",
"Invented own approach instead of following step 3",
"Missed the 'always validate output' instruction"
]
}
},
"improvement_suggestions": [
{
"priority": "high",
"category": "instructions",
"suggestion": "Replace 'process the document appropriately' with explicit steps: 1) Extract text, 2) Identify sections, 3) Format per template",
"expected_impact": "Would eliminate ambiguity that caused inconsistent behavior"
},
{
"priority": "high",
"category": "tools",
"suggestion": "Add validate_output.py script similar to winner skill's validation approach",
"expected_impact": "Would catch formatting errors before final output"
},
{
"priority": "medium",
"category": "error_handling",
"suggestion": "Add fallback instructions: 'If OCR fails, try: 1) different resolution, 2) image preprocessing, 3) manual extraction'",
"expected_impact": "Would prevent early failure on difficult documents"
}
],
"transcript_insights": {
"winner_execution_pattern": "Read skill -> Followed 5-step process -> Used validation script -> Fixed 2 issues -> Produced output",
"loser_execution_pattern": "Read skill -> Unclear on approach -> Tried 3 different methods -> No validation -> Output had errors"
}
}
```
## Guidelines
- **Be specific**: Quote from skills and transcripts, don't just say "instructions were unclear"
- **Be actionable**: Suggestions should be concrete changes, not vague advice
- **Focus on skill improvements**: The goal is to improve the losing skill, not critique the agent
- **Prioritize by impact**: Which changes would most likely have changed the outcome?
- **Consider causation**: Did the skill weakness actually cause the worse output, or is it incidental?
- **Stay objective**: Analyze what happened, don't editorialize
- **Think about generalization**: Would this improvement help on other evals too?
## Categories for Suggestions
Use these categories to organize improvement suggestions:
| Category | Description |
|----------|-------------|
| `instructions` | Changes to the skill's prose instructions |
| `tools` | Scripts, templates, or utilities to add/modify |
| `examples` | Example inputs/outputs to include |
| `error_handling` | Guidance for handling failures |
| `structure` | Reorganization of skill content |
| `references` | External docs or resources to add |
## Priority Levels
- **high**: Would likely change the outcome of this comparison
- **medium**: Would improve quality but may not change win/loss
- **low**: Nice to have, marginal improvement
---
# Analyzing Benchmark Results
When analyzing benchmark results, the analyzer's purpose is to **surface patterns and anomalies** across multiple runs, not suggest skill improvements.
## Role
Review all benchmark run results and generate freeform notes that help the user understand skill performance. Focus on patterns that wouldn't be visible from aggregate metrics alone.
## Inputs
You receive these parameters in your prompt:
- **benchmark_data_path**: Path to the in-progress benchmark.json with all run results
- **skill_path**: Path to the skill being benchmarked
- **output_path**: Where to save the notes (as JSON array of strings)
## Process
### Step 1: Read Benchmark Data
1. Read the benchmark.json containing all run results
2. Note the configurations tested (with_skill, without_skill)
3. Understand the run_summary aggregates already calculated
### Step 2: Analyze Per-Assertion Patterns
For each expectation across all runs:
- Does it **always pass** in both configurations? (may not differentiate skill value)
- Does it **always fail** in both configurations? (may be broken or beyond capability)
- Does it **always pass with skill but fail without**? (skill clearly adds value here)
- Does it **always fail with skill but pass without**? (skill may be hurting)
- Is it **highly variable**? (flaky expectation or non-deterministic behavior)
### Step 3: Analyze Cross-Eval Patterns
Look for patterns across evals:
- Are certain eval types consistently harder/easier?
- Do some evals show high variance while others are stable?
- Are there surprising results that contradict expectations?
### Step 4: Analyze Metrics Patterns
Look at time_seconds, tokens, tool_calls:
- Does the skill significantly increase execution time?
- Is there high variance in resource usage?
- Are there outlier runs that skew the aggregates?
### Step 5: Generate Notes
Write freeform observations as a list of strings. Each note should:
- State a specific observation
- Be grounded in the data (not speculation)
- Help the user understand something the aggregate metrics don't show
Examples:
- "Assertion 'Output is a PDF file' passes 100% in both configurations - may not differentiate skill value"
- "Eval 3 shows high variance (50% ± 40%) - run 2 had an unusual failure that may be flaky"
- "Without-skill runs consistently fail on table extraction expectations (0% pass rate)"
- "Skill adds 13s average execution time but improves pass rate by 50%"
- "Token usage is 80% higher with skill, primarily due to script output parsing"
- "All 3 without-skill runs for eval 1 produced empty output"
### Step 6: Write Notes
Save notes to `{output_path}` as a JSON array of strings:
```json
[
"Assertion 'Output is a PDF file' passes 100% in both configurations - may not differentiate skill value",
"Eval 3 shows high variance (50% ± 40%) - run 2 had an unusual failure",
"Without-skill runs consistently fail on table extraction expectations",
"Skill adds 13s average execution time but improves pass rate by 50%"
]
```
## Guidelines
**DO:**
- Report what you observe in the data
- Be specific about which evals, expectations, or runs you're referring to
- Note patterns that aggregate metrics would hide
- Provide context that helps interpret the numbers
**DO NOT:**
- Suggest improvements to the skill (that's for the improvement step, not benchmarking)
- Make subjective quality judgments ("the output was good/bad")
- Speculate about causes without evidence
- Repeat information already in the run_summary aggregates

View File

@ -0,0 +1,202 @@
# Blind Comparator Agent
Compare two outputs WITHOUT knowing which skill produced them.
## Role
The Blind Comparator judges which output better accomplishes the eval task. You receive two outputs labeled A and B, but you do NOT know which skill produced which. This prevents bias toward a particular skill or approach.
Your judgment is based purely on output quality and task completion.
## Inputs
You receive these parameters in your prompt:
- **output_a_path**: Path to the first output file or directory
- **output_b_path**: Path to the second output file or directory
- **eval_prompt**: The original task/prompt that was executed
- **expectations**: List of expectations to check (optional - may be empty)
## Process
### Step 1: Read Both Outputs
1. Examine output A (file or directory)
2. Examine output B (file or directory)
3. Note the type, structure, and content of each
4. If outputs are directories, examine all relevant files inside
### Step 2: Understand the Task
1. Read the eval_prompt carefully
2. Identify what the task requires:
- What should be produced?
- What qualities matter (accuracy, completeness, format)?
- What would distinguish a good output from a poor one?
### Step 3: Generate Evaluation Rubric
Based on the task, generate a rubric with two dimensions:
**Content Rubric** (what the output contains):
| Criterion | 1 (Poor) | 3 (Acceptable) | 5 (Excellent) |
|-----------|----------|----------------|---------------|
| Correctness | Major errors | Minor errors | Fully correct |
| Completeness | Missing key elements | Mostly complete | All elements present |
| Accuracy | Significant inaccuracies | Minor inaccuracies | Accurate throughout |
**Structure Rubric** (how the output is organized):
| Criterion | 1 (Poor) | 3 (Acceptable) | 5 (Excellent) |
|-----------|----------|----------------|---------------|
| Organization | Disorganized | Reasonably organized | Clear, logical structure |
| Formatting | Inconsistent/broken | Mostly consistent | Professional, polished |
| Usability | Difficult to use | Usable with effort | Easy to use |
Adapt criteria to the specific task. For example:
- PDF form → "Field alignment", "Text readability", "Data placement"
- Document → "Section structure", "Heading hierarchy", "Paragraph flow"
- Data output → "Schema correctness", "Data types", "Completeness"
### Step 4: Evaluate Each Output Against the Rubric
For each output (A and B):
1. **Score each criterion** on the rubric (1-5 scale)
2. **Calculate dimension totals**: Content score, Structure score
3. **Calculate overall score**: Average of dimension scores, scaled to 1-10
### Step 5: Check Assertions (if provided)
If expectations are provided:
1. Check each expectation against output A
2. Check each expectation against output B
3. Count pass rates for each output
4. Use expectation scores as secondary evidence (not the primary decision factor)
### Step 6: Determine the Winner
Compare A and B based on (in priority order):
1. **Primary**: Overall rubric score (content + structure)
2. **Secondary**: Assertion pass rates (if applicable)
3. **Tiebreaker**: If truly equal, declare a TIE
Be decisive - ties should be rare. One output is usually better, even if marginally.
### Step 7: Write Comparison Results
Save results to a JSON file at the path specified (or `comparison.json` if not specified).
## Output Format
Write a JSON file with this structure:
```json
{
"winner": "A",
"reasoning": "Output A provides a complete solution with proper formatting and all required fields. Output B is missing the date field and has formatting inconsistencies.",
"rubric": {
"A": {
"content": {
"correctness": 5,
"completeness": 5,
"accuracy": 4
},
"structure": {
"organization": 4,
"formatting": 5,
"usability": 4
},
"content_score": 4.7,
"structure_score": 4.3,
"overall_score": 9.0
},
"B": {
"content": {
"correctness": 3,
"completeness": 2,
"accuracy": 3
},
"structure": {
"organization": 3,
"formatting": 2,
"usability": 3
},
"content_score": 2.7,
"structure_score": 2.7,
"overall_score": 5.4
}
},
"output_quality": {
"A": {
"score": 9,
"strengths": ["Complete solution", "Well-formatted", "All fields present"],
"weaknesses": ["Minor style inconsistency in header"]
},
"B": {
"score": 5,
"strengths": ["Readable output", "Correct basic structure"],
"weaknesses": ["Missing date field", "Formatting inconsistencies", "Partial data extraction"]
}
},
"expectation_results": {
"A": {
"passed": 4,
"total": 5,
"pass_rate": 0.80,
"details": [
{"text": "Output includes name", "passed": true},
{"text": "Output includes date", "passed": true},
{"text": "Format is PDF", "passed": true},
{"text": "Contains signature", "passed": false},
{"text": "Readable text", "passed": true}
]
},
"B": {
"passed": 3,
"total": 5,
"pass_rate": 0.60,
"details": [
{"text": "Output includes name", "passed": true},
{"text": "Output includes date", "passed": false},
{"text": "Format is PDF", "passed": true},
{"text": "Contains signature", "passed": false},
{"text": "Readable text", "passed": true}
]
}
}
}
```
If no expectations were provided, omit the `expectation_results` field entirely.
## Field Descriptions
- **winner**: "A", "B", or "TIE"
- **reasoning**: Clear explanation of why the winner was chosen (or why it's a tie)
- **rubric**: Structured rubric evaluation for each output
- **content**: Scores for content criteria (correctness, completeness, accuracy)
- **structure**: Scores for structure criteria (organization, formatting, usability)
- **content_score**: Average of content criteria (1-5)
- **structure_score**: Average of structure criteria (1-5)
- **overall_score**: Combined score scaled to 1-10
- **output_quality**: Summary quality assessment
- **score**: 1-10 rating (should match rubric overall_score)
- **strengths**: List of positive aspects
- **weaknesses**: List of issues or shortcomings
- **expectation_results**: (Only if expectations provided)
- **passed**: Number of expectations that passed
- **total**: Total number of expectations
- **pass_rate**: Fraction passed (0.0 to 1.0)
- **details**: Individual expectation results
## Guidelines
- **Stay blind**: DO NOT try to infer which skill produced which output. Judge purely on output quality.
- **Be specific**: Cite specific examples when explaining strengths and weaknesses.
- **Be decisive**: Choose a winner unless outputs are genuinely equivalent.
- **Output quality first**: Assertion scores are secondary to overall task completion.
- **Be objective**: Don't favor outputs based on style preferences; focus on correctness and completeness.
- **Explain your reasoning**: The reasoning field should make it clear why you chose the winner.
- **Handle edge cases**: If both outputs fail, pick the one that fails less badly. If both are excellent, pick the one that's marginally better.

View File

@ -0,0 +1,223 @@
# Grader Agent
Evaluate expectations against an execution transcript and outputs.
## Role
The Grader reviews a transcript and output files, then determines whether each expectation passes or fails. Provide clear evidence for each judgment.
You have two jobs: grade the outputs, and critique the evals themselves. A passing grade on a weak assertion is worse than useless — it creates false confidence. When you notice an assertion that's trivially satisfied, or an important outcome that no assertion checks, say so.
## Inputs
You receive these parameters in your prompt:
- **expectations**: List of expectations to evaluate (strings)
- **transcript_path**: Path to the execution transcript (markdown file)
- **outputs_dir**: Directory containing output files from execution
## Process
### Step 1: Read the Transcript
1. Read the transcript file completely
2. Note the eval prompt, execution steps, and final result
3. Identify any issues or errors documented
### Step 2: Examine Output Files
1. List files in outputs_dir
2. Read/examine each file relevant to the expectations. If outputs aren't plain text, use the inspection tools provided in your prompt — don't rely solely on what the transcript says the executor produced.
3. Note contents, structure, and quality
### Step 3: Evaluate Each Assertion
For each expectation:
1. **Search for evidence** in the transcript and outputs
2. **Determine verdict**:
- **PASS**: Clear evidence the expectation is true AND the evidence reflects genuine task completion, not just surface-level compliance
- **FAIL**: No evidence, or evidence contradicts the expectation, or the evidence is superficial (e.g., correct filename but empty/wrong content)
3. **Cite the evidence**: Quote the specific text or describe what you found
### Step 4: Extract and Verify Claims
Beyond the predefined expectations, extract implicit claims from the outputs and verify them:
1. **Extract claims** from the transcript and outputs:
- Factual statements ("The form has 12 fields")
- Process claims ("Used pypdf to fill the form")
- Quality claims ("All fields were filled correctly")
2. **Verify each claim**:
- **Factual claims**: Can be checked against the outputs or external sources
- **Process claims**: Can be verified from the transcript
- **Quality claims**: Evaluate whether the claim is justified
3. **Flag unverifiable claims**: Note claims that cannot be verified with available information
This catches issues that predefined expectations might miss.
### Step 5: Read User Notes
If `{outputs_dir}/user_notes.md` exists:
1. Read it and note any uncertainties or issues flagged by the executor
2. Include relevant concerns in the grading output
3. These may reveal problems even when expectations pass
### Step 6: Critique the Evals
After grading, consider whether the evals themselves could be improved. Only surface suggestions when there's a clear gap.
Good suggestions test meaningful outcomes — assertions that are hard to satisfy without actually doing the work correctly. Think about what makes an assertion *discriminating*: it passes when the skill genuinely succeeds and fails when it doesn't.
Suggestions worth raising:
- An assertion that passed but would also pass for a clearly wrong output (e.g., checking filename existence but not file content)
- An important outcome you observed — good or bad — that no assertion covers at all
- An assertion that can't actually be verified from the available outputs
Keep the bar high. The goal is to flag things the eval author would say "good catch" about, not to nitpick every assertion.
### Step 7: Write Grading Results
Save results to `{outputs_dir}/../grading.json` (sibling to outputs_dir).
## Grading Criteria
**PASS when**:
- The transcript or outputs clearly demonstrate the expectation is true
- Specific evidence can be cited
- The evidence reflects genuine substance, not just surface compliance (e.g., a file exists AND contains correct content, not just the right filename)
**FAIL when**:
- No evidence found for the expectation
- Evidence contradicts the expectation
- The expectation cannot be verified from available information
- The evidence is superficial — the assertion is technically satisfied but the underlying task outcome is wrong or incomplete
- The output appears to meet the assertion by coincidence rather than by actually doing the work
**When uncertain**: The burden of proof to pass is on the expectation.
### Step 8: Read Executor Metrics and Timing
1. If `{outputs_dir}/metrics.json` exists, read it and include in grading output
2. If `{outputs_dir}/../timing.json` exists, read it and include timing data
## Output Format
Write a JSON file with this structure:
```json
{
"expectations": [
{
"text": "The output includes the name 'John Smith'",
"passed": true,
"evidence": "Found in transcript Step 3: 'Extracted names: John Smith, Sarah Johnson'"
},
{
"text": "The spreadsheet has a SUM formula in cell B10",
"passed": false,
"evidence": "No spreadsheet was created. The output was a text file."
},
{
"text": "The assistant used the skill's OCR script",
"passed": true,
"evidence": "Transcript Step 2 shows: 'Tool: Bash - python ocr_script.py image.png'"
}
],
"summary": {
"passed": 2,
"failed": 1,
"total": 3,
"pass_rate": 0.67
},
"execution_metrics": {
"tool_calls": {
"Read": 5,
"Write": 2,
"Bash": 8
},
"total_tool_calls": 15,
"total_steps": 6,
"errors_encountered": 0,
"output_chars": 12450,
"transcript_chars": 3200
},
"timing": {
"executor_duration_seconds": 165.0,
"grader_duration_seconds": 26.0,
"total_duration_seconds": 191.0
},
"claims": [
{
"claim": "The form has 12 fillable fields",
"type": "factual",
"verified": true,
"evidence": "Counted 12 fields in field_info.json"
},
{
"claim": "All required fields were populated",
"type": "quality",
"verified": false,
"evidence": "Reference section was left blank despite data being available"
}
],
"user_notes_summary": {
"uncertainties": ["Used 2023 data, may be stale"],
"needs_review": [],
"workarounds": ["Fell back to text overlay for non-fillable fields"]
},
"eval_feedback": {
"suggestions": [
{
"assertion": "The output includes the name 'John Smith'",
"reason": "A hallucinated document that mentions the name would also pass — consider checking it appears as the primary contact with matching phone and email from the input"
},
{
"reason": "No assertion checks whether the extracted phone numbers match the input — I observed incorrect numbers in the output that went uncaught"
}
],
"overall": "Assertions check presence but not correctness. Consider adding content verification."
}
}
```
## Field Descriptions
- **expectations**: Array of graded expectations
- **text**: The original expectation text
- **passed**: Boolean - true if expectation passes
- **evidence**: Specific quote or description supporting the verdict
- **summary**: Aggregate statistics
- **passed**: Count of passed expectations
- **failed**: Count of failed expectations
- **total**: Total expectations evaluated
- **pass_rate**: Fraction passed (0.0 to 1.0)
- **execution_metrics**: Copied from executor's metrics.json (if available)
- **output_chars**: Total character count of output files (proxy for tokens)
- **transcript_chars**: Character count of transcript
- **timing**: Wall clock timing from timing.json (if available)
- **executor_duration_seconds**: Time spent in executor subagent
- **total_duration_seconds**: Total elapsed time for the run
- **claims**: Extracted and verified claims from the output
- **claim**: The statement being verified
- **type**: "factual", "process", or "quality"
- **verified**: Boolean - whether the claim holds
- **evidence**: Supporting or contradicting evidence
- **user_notes_summary**: Issues flagged by the executor
- **uncertainties**: Things the executor wasn't sure about
- **needs_review**: Items requiring human attention
- **workarounds**: Places where the skill didn't work as expected
- **eval_feedback**: Improvement suggestions for the evals (only when warranted)
- **suggestions**: List of concrete suggestions, each with a `reason` and optionally an `assertion` it relates to
- **overall**: Brief assessment — can be "No suggestions, evals look solid" if nothing to flag
## Guidelines
- **Be objective**: Base verdicts on evidence, not assumptions
- **Be specific**: Quote the exact text that supports your verdict
- **Be thorough**: Check both transcript and output files
- **Be consistent**: Apply the same standard to each expectation
- **Explain failures**: Make it clear why evidence was insufficient
- **No partial credit**: Each expectation is pass or fail, not partial

View File

@ -0,0 +1,146 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Eval Set Review - __SKILL_NAME_PLACEHOLDER__</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Poppins:wght@500;600&family=Lora:wght@400;500&display=swap" rel="stylesheet">
<style>
* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: 'Lora', Georgia, serif; background: #faf9f5; padding: 2rem; color: #141413; }
h1 { font-family: 'Poppins', sans-serif; margin-bottom: 0.5rem; font-size: 1.5rem; }
.description { color: #b0aea5; margin-bottom: 1.5rem; font-style: italic; max-width: 900px; }
.controls { margin-bottom: 1rem; display: flex; gap: 0.5rem; }
.btn { font-family: 'Poppins', sans-serif; padding: 0.5rem 1rem; border: none; border-radius: 6px; cursor: pointer; font-size: 0.875rem; font-weight: 500; }
.btn-add { background: #6a9bcc; color: white; }
.btn-add:hover { background: #5889b8; }
.btn-export { background: #d97757; color: white; }
.btn-export:hover { background: #c4613f; }
table { width: 100%; max-width: 1100px; border-collapse: collapse; background: white; border-radius: 6px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,0.08); }
th { font-family: 'Poppins', sans-serif; background: #141413; color: #faf9f5; padding: 0.75rem 1rem; text-align: left; font-size: 0.875rem; }
td { padding: 0.75rem 1rem; border-bottom: 1px solid #e8e6dc; vertical-align: top; }
tr:nth-child(even) td { background: #faf9f5; }
tr:hover td { background: #f3f1ea; }
.section-header td { background: #e8e6dc; font-family: 'Poppins', sans-serif; font-weight: 500; font-size: 0.8rem; color: #141413; text-transform: uppercase; letter-spacing: 0.05em; }
.query-input { width: 100%; padding: 0.4rem; border: 1px solid #e8e6dc; border-radius: 4px; font-size: 0.875rem; font-family: 'Lora', Georgia, serif; resize: vertical; min-height: 60px; }
.query-input:focus { outline: none; border-color: #d97757; box-shadow: 0 0 0 2px rgba(217,119,87,0.15); }
.toggle { position: relative; display: inline-block; width: 44px; height: 24px; }
.toggle input { opacity: 0; width: 0; height: 0; }
.toggle .slider { position: absolute; inset: 0; background: #b0aea5; border-radius: 24px; cursor: pointer; transition: 0.2s; }
.toggle .slider::before { content: ""; position: absolute; width: 18px; height: 18px; left: 3px; bottom: 3px; background: white; border-radius: 50%; transition: 0.2s; }
.toggle input:checked + .slider { background: #d97757; }
.toggle input:checked + .slider::before { transform: translateX(20px); }
.btn-delete { background: #c44; color: white; padding: 0.3rem 0.6rem; border: none; border-radius: 4px; cursor: pointer; font-size: 0.75rem; font-family: 'Poppins', sans-serif; }
.btn-delete:hover { background: #a33; }
.summary { margin-top: 1rem; color: #b0aea5; font-size: 0.875rem; }
</style>
</head>
<body>
<h1>Eval Set Review: <span id="skill-name">__SKILL_NAME_PLACEHOLDER__</span></h1>
<p class="description">Current description: <span id="skill-desc">__SKILL_DESCRIPTION_PLACEHOLDER__</span></p>
<div class="controls">
<button class="btn btn-add" onclick="addRow()">+ Add Query</button>
<button class="btn btn-export" onclick="exportEvalSet()">Export Eval Set</button>
</div>
<table>
<thead>
<tr>
<th style="width:65%">Query</th>
<th style="width:18%">Should Trigger</th>
<th style="width:10%">Actions</th>
</tr>
</thead>
<tbody id="eval-body"></tbody>
</table>
<p class="summary" id="summary"></p>
<script>
const EVAL_DATA = __EVAL_DATA_PLACEHOLDER__;
let evalItems = [...EVAL_DATA];
function render() {
const tbody = document.getElementById('eval-body');
tbody.innerHTML = '';
// Sort: should-trigger first, then should-not-trigger
const sorted = evalItems
.map((item, origIdx) => ({ ...item, origIdx }))
.sort((a, b) => (b.should_trigger ? 1 : 0) - (a.should_trigger ? 1 : 0));
let lastGroup = null;
sorted.forEach(item => {
const group = item.should_trigger ? 'trigger' : 'no-trigger';
if (group !== lastGroup) {
const headerRow = document.createElement('tr');
headerRow.className = 'section-header';
headerRow.innerHTML = `<td colspan="3">${item.should_trigger ? 'Should Trigger' : 'Should NOT Trigger'}</td>`;
tbody.appendChild(headerRow);
lastGroup = group;
}
const idx = item.origIdx;
const tr = document.createElement('tr');
tr.innerHTML = `
<td><textarea class="query-input" onchange="updateQuery(${idx}, this.value)">${escapeHtml(item.query)}</textarea></td>
<td>
<label class="toggle">
<input type="checkbox" ${item.should_trigger ? 'checked' : ''} onchange="updateTrigger(${idx}, this.checked)">
<span class="slider"></span>
</label>
<span style="margin-left:8px;font-size:0.8rem;color:#b0aea5">${item.should_trigger ? 'Yes' : 'No'}</span>
</td>
<td><button class="btn-delete" onclick="deleteRow(${idx})">Delete</button></td>
`;
tbody.appendChild(tr);
});
updateSummary();
}
function escapeHtml(text) {
const div = document.createElement('div');
div.textContent = text;
return div.innerHTML;
}
function updateQuery(idx, value) { evalItems[idx].query = value; updateSummary(); }
function updateTrigger(idx, value) { evalItems[idx].should_trigger = value; render(); }
function deleteRow(idx) { evalItems.splice(idx, 1); render(); }
function addRow() {
evalItems.push({ query: '', should_trigger: true });
render();
const inputs = document.querySelectorAll('.query-input');
inputs[inputs.length - 1].focus();
}
function updateSummary() {
const trigger = evalItems.filter(i => i.should_trigger).length;
const noTrigger = evalItems.filter(i => !i.should_trigger).length;
document.getElementById('summary').textContent =
`${evalItems.length} queries total: ${trigger} should trigger, ${noTrigger} should not trigger`;
}
function exportEvalSet() {
const valid = evalItems.filter(i => i.query.trim() !== '');
const data = valid.map(i => ({ query: i.query.trim(), should_trigger: i.should_trigger }));
const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'eval_set.json';
document.body.appendChild(a);
a.click();
document.body.removeChild(a);
URL.revokeObjectURL(url);
}
render();
</script>
</body>
</html>

View File

@ -0,0 +1,471 @@
#!/usr/bin/env python3
"""Generate and serve a review page for eval results.
Reads the workspace directory, discovers runs (directories with outputs/),
embeds all output data into a self-contained HTML page, and serves it via
a tiny HTTP server. Feedback auto-saves to feedback.json in the workspace.
Usage:
python generate_review.py <workspace-path> [--port PORT] [--skill-name NAME]
python generate_review.py <workspace-path> --previous-feedback /path/to/old/feedback.json
No dependencies beyond the Python stdlib are required.
"""
import argparse
import base64
import json
import mimetypes
import os
import re
import signal
import subprocess
import sys
import time
import webbrowser
from functools import partial
from http.server import HTTPServer, BaseHTTPRequestHandler
from pathlib import Path
# Files to exclude from output listings
METADATA_FILES = {"transcript.md", "user_notes.md", "metrics.json"}
# Extensions we render as inline text
TEXT_EXTENSIONS = {
".txt", ".md", ".json", ".csv", ".py", ".js", ".ts", ".tsx", ".jsx",
".yaml", ".yml", ".xml", ".html", ".css", ".sh", ".rb", ".go", ".rs",
".java", ".c", ".cpp", ".h", ".hpp", ".sql", ".r", ".toml",
}
# Extensions we render as inline images
IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"}
# MIME type overrides for common types
MIME_OVERRIDES = {
".svg": "image/svg+xml",
".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
}
def get_mime_type(path: Path) -> str:
ext = path.suffix.lower()
if ext in MIME_OVERRIDES:
return MIME_OVERRIDES[ext]
mime, _ = mimetypes.guess_type(str(path))
return mime or "application/octet-stream"
def find_runs(workspace: Path) -> list[dict]:
"""Recursively find directories that contain an outputs/ subdirectory."""
runs: list[dict] = []
_find_runs_recursive(workspace, workspace, runs)
runs.sort(key=lambda r: (r.get("eval_id", float("inf")), r["id"]))
return runs
def _find_runs_recursive(root: Path, current: Path, runs: list[dict]) -> None:
if not current.is_dir():
return
outputs_dir = current / "outputs"
if outputs_dir.is_dir():
run = build_run(root, current)
if run:
runs.append(run)
return
skip = {"node_modules", ".git", "__pycache__", "skill", "inputs"}
for child in sorted(current.iterdir()):
if child.is_dir() and child.name not in skip:
_find_runs_recursive(root, child, runs)
def build_run(root: Path, run_dir: Path) -> dict | None:
"""Build a run dict with prompt, outputs, and grading data."""
prompt = ""
eval_id = None
# Try eval_metadata.json
for candidate in [run_dir / "eval_metadata.json", run_dir.parent / "eval_metadata.json"]:
if candidate.exists():
try:
metadata = json.loads(candidate.read_text())
prompt = metadata.get("prompt", "")
eval_id = metadata.get("eval_id")
except (json.JSONDecodeError, OSError):
pass
if prompt:
break
# Fall back to transcript.md
if not prompt:
for candidate in [run_dir / "transcript.md", run_dir / "outputs" / "transcript.md"]:
if candidate.exists():
try:
text = candidate.read_text()
match = re.search(r"## Eval Prompt\n\n([\s\S]*?)(?=\n##|$)", text)
if match:
prompt = match.group(1).strip()
except OSError:
pass
if prompt:
break
if not prompt:
prompt = "(No prompt found)"
run_id = str(run_dir.relative_to(root)).replace("/", "-").replace("\\", "-")
# Collect output files
outputs_dir = run_dir / "outputs"
output_files: list[dict] = []
if outputs_dir.is_dir():
for f in sorted(outputs_dir.iterdir()):
if f.is_file() and f.name not in METADATA_FILES:
output_files.append(embed_file(f))
# Load grading if present
grading = None
for candidate in [run_dir / "grading.json", run_dir.parent / "grading.json"]:
if candidate.exists():
try:
grading = json.loads(candidate.read_text())
except (json.JSONDecodeError, OSError):
pass
if grading:
break
return {
"id": run_id,
"prompt": prompt,
"eval_id": eval_id,
"outputs": output_files,
"grading": grading,
}
def embed_file(path: Path) -> dict:
"""Read a file and return an embedded representation."""
ext = path.suffix.lower()
mime = get_mime_type(path)
if ext in TEXT_EXTENSIONS:
try:
content = path.read_text(errors="replace")
except OSError:
content = "(Error reading file)"
return {
"name": path.name,
"type": "text",
"content": content,
}
elif ext in IMAGE_EXTENSIONS:
try:
raw = path.read_bytes()
b64 = base64.b64encode(raw).decode("ascii")
except OSError:
return {"name": path.name, "type": "error", "content": "(Error reading file)"}
return {
"name": path.name,
"type": "image",
"mime": mime,
"data_uri": f"data:{mime};base64,{b64}",
}
elif ext == ".pdf":
try:
raw = path.read_bytes()
b64 = base64.b64encode(raw).decode("ascii")
except OSError:
return {"name": path.name, "type": "error", "content": "(Error reading file)"}
return {
"name": path.name,
"type": "pdf",
"data_uri": f"data:{mime};base64,{b64}",
}
elif ext == ".xlsx":
try:
raw = path.read_bytes()
b64 = base64.b64encode(raw).decode("ascii")
except OSError:
return {"name": path.name, "type": "error", "content": "(Error reading file)"}
return {
"name": path.name,
"type": "xlsx",
"data_b64": b64,
}
else:
# Binary / unknown — base64 download link
try:
raw = path.read_bytes()
b64 = base64.b64encode(raw).decode("ascii")
except OSError:
return {"name": path.name, "type": "error", "content": "(Error reading file)"}
return {
"name": path.name,
"type": "binary",
"mime": mime,
"data_uri": f"data:{mime};base64,{b64}",
}
def load_previous_iteration(workspace: Path) -> dict[str, dict]:
"""Load previous iteration's feedback and outputs.
Returns a map of run_id -> {"feedback": str, "outputs": list[dict]}.
"""
result: dict[str, dict] = {}
# Load feedback
feedback_map: dict[str, str] = {}
feedback_path = workspace / "feedback.json"
if feedback_path.exists():
try:
data = json.loads(feedback_path.read_text())
feedback_map = {
r["run_id"]: r["feedback"]
for r in data.get("reviews", [])
if r.get("feedback", "").strip()
}
except (json.JSONDecodeError, OSError, KeyError):
pass
# Load runs (to get outputs)
prev_runs = find_runs(workspace)
for run in prev_runs:
result[run["id"]] = {
"feedback": feedback_map.get(run["id"], ""),
"outputs": run.get("outputs", []),
}
# Also add feedback for run_ids that had feedback but no matching run
for run_id, fb in feedback_map.items():
if run_id not in result:
result[run_id] = {"feedback": fb, "outputs": []}
return result
def generate_html(
runs: list[dict],
skill_name: str,
previous: dict[str, dict] | None = None,
benchmark: dict | None = None,
) -> str:
"""Generate the complete standalone HTML page with embedded data."""
template_path = Path(__file__).parent / "viewer.html"
template = template_path.read_text()
# Build previous_feedback and previous_outputs maps for the template
previous_feedback: dict[str, str] = {}
previous_outputs: dict[str, list[dict]] = {}
if previous:
for run_id, data in previous.items():
if data.get("feedback"):
previous_feedback[run_id] = data["feedback"]
if data.get("outputs"):
previous_outputs[run_id] = data["outputs"]
embedded = {
"skill_name": skill_name,
"runs": runs,
"previous_feedback": previous_feedback,
"previous_outputs": previous_outputs,
}
if benchmark:
embedded["benchmark"] = benchmark
data_json = json.dumps(embedded)
return template.replace("/*__EMBEDDED_DATA__*/", f"const EMBEDDED_DATA = {data_json};")
# ---------------------------------------------------------------------------
# HTTP server (stdlib only, zero dependencies)
# ---------------------------------------------------------------------------
def _kill_port(port: int) -> None:
"""Kill any process listening on the given port."""
try:
result = subprocess.run(
["lsof", "-ti", f":{port}"],
capture_output=True, text=True, timeout=5,
)
for pid_str in result.stdout.strip().split("\n"):
if pid_str.strip():
try:
os.kill(int(pid_str.strip()), signal.SIGTERM)
except (ProcessLookupError, ValueError):
pass
if result.stdout.strip():
time.sleep(0.5)
except subprocess.TimeoutExpired:
pass
except FileNotFoundError:
print("Note: lsof not found, cannot check if port is in use", file=sys.stderr)
class ReviewHandler(BaseHTTPRequestHandler):
"""Serves the review HTML and handles feedback saves.
Regenerates the HTML on each page load so that refreshing the browser
picks up new eval outputs without restarting the server.
"""
def __init__(
self,
workspace: Path,
skill_name: str,
feedback_path: Path,
previous: dict[str, dict],
benchmark_path: Path | None,
*args,
**kwargs,
):
self.workspace = workspace
self.skill_name = skill_name
self.feedback_path = feedback_path
self.previous = previous
self.benchmark_path = benchmark_path
super().__init__(*args, **kwargs)
def do_GET(self) -> None:
if self.path == "/" or self.path == "/index.html":
# Regenerate HTML on each request (re-scans workspace for new outputs)
runs = find_runs(self.workspace)
benchmark = None
if self.benchmark_path and self.benchmark_path.exists():
try:
benchmark = json.loads(self.benchmark_path.read_text())
except (json.JSONDecodeError, OSError):
pass
html = generate_html(runs, self.skill_name, self.previous, benchmark)
content = html.encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(content)))
self.end_headers()
self.wfile.write(content)
elif self.path == "/api/feedback":
data = b"{}"
if self.feedback_path.exists():
data = self.feedback_path.read_bytes()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(data)))
self.end_headers()
self.wfile.write(data)
else:
self.send_error(404)
def do_POST(self) -> None:
if self.path == "/api/feedback":
length = int(self.headers.get("Content-Length", 0))
body = self.rfile.read(length)
try:
data = json.loads(body)
if not isinstance(data, dict) or "reviews" not in data:
raise ValueError("Expected JSON object with 'reviews' key")
self.feedback_path.write_text(json.dumps(data, indent=2) + "\n")
resp = b'{"ok":true}'
self.send_response(200)
except (json.JSONDecodeError, OSError, ValueError) as e:
resp = json.dumps({"error": str(e)}).encode()
self.send_response(500)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(resp)))
self.end_headers()
self.wfile.write(resp)
else:
self.send_error(404)
def log_message(self, format: str, *args: object) -> None:
# Suppress request logging to keep terminal clean
pass
def main() -> None:
parser = argparse.ArgumentParser(description="Generate and serve eval review")
parser.add_argument("workspace", type=Path, help="Path to workspace directory")
parser.add_argument("--port", "-p", type=int, default=3117, help="Server port (default: 3117)")
parser.add_argument("--skill-name", "-n", type=str, default=None, help="Skill name for header")
parser.add_argument(
"--previous-workspace", type=Path, default=None,
help="Path to previous iteration's workspace (shows old outputs and feedback as context)",
)
parser.add_argument(
"--benchmark", type=Path, default=None,
help="Path to benchmark.json to show in the Benchmark tab",
)
parser.add_argument(
"--static", "-s", type=Path, default=None,
help="Write standalone HTML to this path instead of starting a server",
)
args = parser.parse_args()
workspace = args.workspace.resolve()
if not workspace.is_dir():
print(f"Error: {workspace} is not a directory", file=sys.stderr)
sys.exit(1)
runs = find_runs(workspace)
if not runs:
print(f"No runs found in {workspace}", file=sys.stderr)
sys.exit(1)
skill_name = args.skill_name or workspace.name.replace("-workspace", "")
feedback_path = workspace / "feedback.json"
previous: dict[str, dict] = {}
if args.previous_workspace:
previous = load_previous_iteration(args.previous_workspace.resolve())
benchmark_path = args.benchmark.resolve() if args.benchmark else None
benchmark = None
if benchmark_path and benchmark_path.exists():
try:
benchmark = json.loads(benchmark_path.read_text())
except (json.JSONDecodeError, OSError):
pass
if args.static:
html = generate_html(runs, skill_name, previous, benchmark)
args.static.parent.mkdir(parents=True, exist_ok=True)
args.static.write_text(html)
print(f"\n Static viewer written to: {args.static}\n")
sys.exit(0)
# Kill any existing process on the target port
port = args.port
_kill_port(port)
handler = partial(ReviewHandler, workspace, skill_name, feedback_path, previous, benchmark_path)
try:
server = HTTPServer(("127.0.0.1", port), handler)
except OSError:
# Port still in use after kill attempt — find a free one
server = HTTPServer(("127.0.0.1", 0), handler)
port = server.server_address[1]
url = f"http://localhost:{port}"
print(f"\n Eval Viewer")
print(f" ─────────────────────────────────")
print(f" URL: {url}")
print(f" Workspace: {workspace}")
print(f" Feedback: {feedback_path}")
if previous:
print(f" Previous: {args.previous_workspace} ({len(previous)} runs)")
if benchmark_path:
print(f" Benchmark: {benchmark_path}")
print(f"\n Press Ctrl+C to stop.\n")
webbrowser.open(url)
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nStopped.")
server.server_close()
if __name__ == "__main__":
main()

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,430 @@
# JSON Schemas
This document defines the JSON schemas used by skill-creator.
---
## evals.json
Defines the evals for a skill. Located at `evals/evals.json` within the skill directory.
```json
{
"skill_name": "example-skill",
"evals": [
{
"id": 1,
"prompt": "User's example prompt",
"expected_output": "Description of expected result",
"files": ["evals/files/sample1.pdf"],
"expectations": [
"The output includes X",
"The skill used script Y"
]
}
]
}
```
**Fields:**
- `skill_name`: Name matching the skill's frontmatter
- `evals[].id`: Unique integer identifier
- `evals[].prompt`: The task to execute
- `evals[].expected_output`: Human-readable description of success
- `evals[].files`: Optional list of input file paths (relative to skill root)
- `evals[].expectations`: List of verifiable statements
---
## history.json
Tracks version progression in Improve mode. Located at workspace root.
```json
{
"started_at": "2026-01-15T10:30:00Z",
"skill_name": "pdf",
"current_best": "v2",
"iterations": [
{
"version": "v0",
"parent": null,
"expectation_pass_rate": 0.65,
"grading_result": "baseline",
"is_current_best": false
},
{
"version": "v1",
"parent": "v0",
"expectation_pass_rate": 0.75,
"grading_result": "won",
"is_current_best": false
},
{
"version": "v2",
"parent": "v1",
"expectation_pass_rate": 0.85,
"grading_result": "won",
"is_current_best": true
}
]
}
```
**Fields:**
- `started_at`: ISO timestamp of when improvement started
- `skill_name`: Name of the skill being improved
- `current_best`: Version identifier of the best performer
- `iterations[].version`: Version identifier (v0, v1, ...)
- `iterations[].parent`: Parent version this was derived from
- `iterations[].expectation_pass_rate`: Pass rate from grading
- `iterations[].grading_result`: "baseline", "won", "lost", or "tie"
- `iterations[].is_current_best`: Whether this is the current best version
---
## grading.json
Output from the grader agent. Located at `<run-dir>/grading.json`.
```json
{
"expectations": [
{
"text": "The output includes the name 'John Smith'",
"passed": true,
"evidence": "Found in transcript Step 3: 'Extracted names: John Smith, Sarah Johnson'"
},
{
"text": "The spreadsheet has a SUM formula in cell B10",
"passed": false,
"evidence": "No spreadsheet was created. The output was a text file."
}
],
"summary": {
"passed": 2,
"failed": 1,
"total": 3,
"pass_rate": 0.67
},
"execution_metrics": {
"tool_calls": {
"Read": 5,
"Write": 2,
"Bash": 8
},
"total_tool_calls": 15,
"total_steps": 6,
"errors_encountered": 0,
"output_chars": 12450,
"transcript_chars": 3200
},
"timing": {
"executor_duration_seconds": 165.0,
"grader_duration_seconds": 26.0,
"total_duration_seconds": 191.0
},
"claims": [
{
"claim": "The form has 12 fillable fields",
"type": "factual",
"verified": true,
"evidence": "Counted 12 fields in field_info.json"
}
],
"user_notes_summary": {
"uncertainties": ["Used 2023 data, may be stale"],
"needs_review": [],
"workarounds": ["Fell back to text overlay for non-fillable fields"]
},
"eval_feedback": {
"suggestions": [
{
"assertion": "The output includes the name 'John Smith'",
"reason": "A hallucinated document that mentions the name would also pass"
}
],
"overall": "Assertions check presence but not correctness."
}
}
```
**Fields:**
- `expectations[]`: Graded expectations with evidence
- `summary`: Aggregate pass/fail counts
- `execution_metrics`: Tool usage and output size (from executor's metrics.json)
- `timing`: Wall clock timing (from timing.json)
- `claims`: Extracted and verified claims from the output
- `user_notes_summary`: Issues flagged by the executor
- `eval_feedback`: (optional) Improvement suggestions for the evals, only present when the grader identifies issues worth raising
---
## metrics.json
Output from the executor agent. Located at `<run-dir>/outputs/metrics.json`.
```json
{
"tool_calls": {
"Read": 5,
"Write": 2,
"Bash": 8,
"Edit": 1,
"Glob": 2,
"Grep": 0
},
"total_tool_calls": 18,
"total_steps": 6,
"files_created": ["filled_form.pdf", "field_values.json"],
"errors_encountered": 0,
"output_chars": 12450,
"transcript_chars": 3200
}
```
**Fields:**
- `tool_calls`: Count per tool type
- `total_tool_calls`: Sum of all tool calls
- `total_steps`: Number of major execution steps
- `files_created`: List of output files created
- `errors_encountered`: Number of errors during execution
- `output_chars`: Total character count of output files
- `transcript_chars`: Character count of transcript
---
## timing.json
Wall clock timing for a run. Located at `<run-dir>/timing.json`.
**How to capture:** When a subagent task completes, the task notification includes `total_tokens` and `duration_ms`. Save these immediately — they are not persisted anywhere else and cannot be recovered after the fact.
```json
{
"total_tokens": 84852,
"duration_ms": 23332,
"total_duration_seconds": 23.3,
"executor_start": "2026-01-15T10:30:00Z",
"executor_end": "2026-01-15T10:32:45Z",
"executor_duration_seconds": 165.0,
"grader_start": "2026-01-15T10:32:46Z",
"grader_end": "2026-01-15T10:33:12Z",
"grader_duration_seconds": 26.0
}
```
---
## benchmark.json
Output from Benchmark mode. Located at `benchmarks/<timestamp>/benchmark.json`.
```json
{
"metadata": {
"skill_name": "pdf",
"skill_path": "/path/to/pdf",
"executor_model": "claude-sonnet-4-20250514",
"analyzer_model": "most-capable-model",
"timestamp": "2026-01-15T10:30:00Z",
"evals_run": [1, 2, 3],
"runs_per_configuration": 3
},
"runs": [
{
"eval_id": 1,
"eval_name": "Ocean",
"configuration": "with_skill",
"run_number": 1,
"result": {
"pass_rate": 0.85,
"passed": 6,
"failed": 1,
"total": 7,
"time_seconds": 42.5,
"tokens": 3800,
"tool_calls": 18,
"errors": 0
},
"expectations": [
{"text": "...", "passed": true, "evidence": "..."}
],
"notes": [
"Used 2023 data, may be stale",
"Fell back to text overlay for non-fillable fields"
]
}
],
"run_summary": {
"with_skill": {
"pass_rate": {"mean": 0.85, "stddev": 0.05, "min": 0.80, "max": 0.90},
"time_seconds": {"mean": 45.0, "stddev": 12.0, "min": 32.0, "max": 58.0},
"tokens": {"mean": 3800, "stddev": 400, "min": 3200, "max": 4100}
},
"without_skill": {
"pass_rate": {"mean": 0.35, "stddev": 0.08, "min": 0.28, "max": 0.45},
"time_seconds": {"mean": 32.0, "stddev": 8.0, "min": 24.0, "max": 42.0},
"tokens": {"mean": 2100, "stddev": 300, "min": 1800, "max": 2500}
},
"delta": {
"pass_rate": "+0.50",
"time_seconds": "+13.0",
"tokens": "+1700"
}
},
"notes": [
"Assertion 'Output is a PDF file' passes 100% in both configurations - may not differentiate skill value",
"Eval 3 shows high variance (50% ± 40%) - may be flaky or model-dependent",
"Without-skill runs consistently fail on table extraction expectations",
"Skill adds 13s average execution time but improves pass rate by 50%"
]
}
```
**Fields:**
- `metadata`: Information about the benchmark run
- `skill_name`: Name of the skill
- `timestamp`: When the benchmark was run
- `evals_run`: List of eval names or IDs
- `runs_per_configuration`: Number of runs per config (e.g. 3)
- `runs[]`: Individual run results
- `eval_id`: Numeric eval identifier
- `eval_name`: Human-readable eval name (used as section header in the viewer)
- `configuration`: Must be `"with_skill"` or `"without_skill"` (the viewer uses this exact string for grouping and color coding)
- `run_number`: Integer run number (1, 2, 3...)
- `result`: Nested object with `pass_rate`, `passed`, `total`, `time_seconds`, `tokens`, `errors`
- `run_summary`: Statistical aggregates per configuration
- `with_skill` / `without_skill`: Each contains `pass_rate`, `time_seconds`, `tokens` objects with `mean` and `stddev` fields
- `delta`: Difference strings like `"+0.50"`, `"+13.0"`, `"+1700"`
- `notes`: Freeform observations from the analyzer
**Important:** The viewer reads these field names exactly. Using `config` instead of `configuration`, or putting `pass_rate` at the top level of a run instead of nested under `result`, will cause the viewer to show empty/zero values. Always reference this schema when generating benchmark.json manually.
---
## comparison.json
Output from blind comparator. Located at `<grading-dir>/comparison-N.json`.
```json
{
"winner": "A",
"reasoning": "Output A provides a complete solution with proper formatting and all required fields. Output B is missing the date field and has formatting inconsistencies.",
"rubric": {
"A": {
"content": {
"correctness": 5,
"completeness": 5,
"accuracy": 4
},
"structure": {
"organization": 4,
"formatting": 5,
"usability": 4
},
"content_score": 4.7,
"structure_score": 4.3,
"overall_score": 9.0
},
"B": {
"content": {
"correctness": 3,
"completeness": 2,
"accuracy": 3
},
"structure": {
"organization": 3,
"formatting": 2,
"usability": 3
},
"content_score": 2.7,
"structure_score": 2.7,
"overall_score": 5.4
}
},
"output_quality": {
"A": {
"score": 9,
"strengths": ["Complete solution", "Well-formatted", "All fields present"],
"weaknesses": ["Minor style inconsistency in header"]
},
"B": {
"score": 5,
"strengths": ["Readable output", "Correct basic structure"],
"weaknesses": ["Missing date field", "Formatting inconsistencies", "Partial data extraction"]
}
},
"expectation_results": {
"A": {
"passed": 4,
"total": 5,
"pass_rate": 0.80,
"details": [
{"text": "Output includes name", "passed": true}
]
},
"B": {
"passed": 3,
"total": 5,
"pass_rate": 0.60,
"details": [
{"text": "Output includes name", "passed": true}
]
}
}
}
```
---
## analysis.json
Output from post-hoc analyzer. Located at `<grading-dir>/analysis.json`.
```json
{
"comparison_summary": {
"winner": "A",
"winner_skill": "path/to/winner/skill",
"loser_skill": "path/to/loser/skill",
"comparator_reasoning": "Brief summary of why comparator chose winner"
},
"winner_strengths": [
"Clear step-by-step instructions for handling multi-page documents",
"Included validation script that caught formatting errors"
],
"loser_weaknesses": [
"Vague instruction 'process the document appropriately' led to inconsistent behavior",
"No script for validation, agent had to improvise"
],
"instruction_following": {
"winner": {
"score": 9,
"issues": ["Minor: skipped optional logging step"]
},
"loser": {
"score": 6,
"issues": [
"Did not use the skill's formatting template",
"Invented own approach instead of following step 3"
]
}
},
"improvement_suggestions": [
{
"priority": "high",
"category": "instructions",
"suggestion": "Replace 'process the document appropriately' with explicit steps",
"expected_impact": "Would eliminate ambiguity that caused inconsistent behavior"
}
],
"transcript_insights": {
"winner_execution_pattern": "Read skill -> Followed 5-step process -> Used validation script",
"loser_execution_pattern": "Read skill -> Unclear on approach -> Tried 3 different methods"
}
}
```

View File

@ -0,0 +1,401 @@
#!/usr/bin/env python3
"""
Aggregate individual run results into benchmark summary statistics.
Reads grading.json files from run directories and produces:
- run_summary with mean, stddev, min, max for each metric
- delta between with_skill and without_skill configurations
Usage:
python aggregate_benchmark.py <benchmark_dir>
Example:
python aggregate_benchmark.py benchmarks/2026-01-15T10-30-00/
The script supports two directory layouts:
Workspace layout (from skill-creator iterations):
<benchmark_dir>/
eval-N/
with_skill/
run-1/grading.json
run-2/grading.json
without_skill/
run-1/grading.json
run-2/grading.json
Legacy layout (with runs/ subdirectory):
<benchmark_dir>/
runs/
eval-N/
with_skill/
run-1/grading.json
without_skill/
run-1/grading.json
"""
import argparse
import json
import math
import sys
from datetime import datetime, timezone
from pathlib import Path
def calculate_stats(values: list[float]) -> dict:
"""Calculate mean, stddev, min, max for a list of values."""
if not values:
return {"mean": 0.0, "stddev": 0.0, "min": 0.0, "max": 0.0}
n = len(values)
mean = sum(values) / n
if n > 1:
variance = sum((x - mean) ** 2 for x in values) / (n - 1)
stddev = math.sqrt(variance)
else:
stddev = 0.0
return {
"mean": round(mean, 4),
"stddev": round(stddev, 4),
"min": round(min(values), 4),
"max": round(max(values), 4)
}
def load_run_results(benchmark_dir: Path) -> dict:
"""
Load all run results from a benchmark directory.
Returns dict keyed by config name (e.g. "with_skill"/"without_skill",
or "new_skill"/"old_skill"), each containing a list of run results.
"""
# Support both layouts: eval dirs directly under benchmark_dir, or under runs/
runs_dir = benchmark_dir / "runs"
if runs_dir.exists():
search_dir = runs_dir
elif list(benchmark_dir.glob("eval-*")):
search_dir = benchmark_dir
else:
print(f"No eval directories found in {benchmark_dir} or {benchmark_dir / 'runs'}")
return {}
results: dict[str, list] = {}
for eval_idx, eval_dir in enumerate(sorted(search_dir.glob("eval-*"))):
metadata_path = eval_dir / "eval_metadata.json"
if metadata_path.exists():
try:
with open(metadata_path) as mf:
eval_id = json.load(mf).get("eval_id", eval_idx)
except (json.JSONDecodeError, OSError):
eval_id = eval_idx
else:
try:
eval_id = int(eval_dir.name.split("-")[1])
except ValueError:
eval_id = eval_idx
# Discover config directories dynamically rather than hardcoding names
for config_dir in sorted(eval_dir.iterdir()):
if not config_dir.is_dir():
continue
# Skip non-config directories (inputs, outputs, etc.)
if not list(config_dir.glob("run-*")):
continue
config = config_dir.name
if config not in results:
results[config] = []
for run_dir in sorted(config_dir.glob("run-*")):
run_number = int(run_dir.name.split("-")[1])
grading_file = run_dir / "grading.json"
if not grading_file.exists():
print(f"Warning: grading.json not found in {run_dir}")
continue
try:
with open(grading_file) as f:
grading = json.load(f)
except json.JSONDecodeError as e:
print(f"Warning: Invalid JSON in {grading_file}: {e}")
continue
# Extract metrics
result = {
"eval_id": eval_id,
"run_number": run_number,
"pass_rate": grading.get("summary", {}).get("pass_rate", 0.0),
"passed": grading.get("summary", {}).get("passed", 0),
"failed": grading.get("summary", {}).get("failed", 0),
"total": grading.get("summary", {}).get("total", 0),
}
# Extract timing — check grading.json first, then sibling timing.json
timing = grading.get("timing", {})
result["time_seconds"] = timing.get("total_duration_seconds", 0.0)
timing_file = run_dir / "timing.json"
if result["time_seconds"] == 0.0 and timing_file.exists():
try:
with open(timing_file) as tf:
timing_data = json.load(tf)
result["time_seconds"] = timing_data.get("total_duration_seconds", 0.0)
result["tokens"] = timing_data.get("total_tokens", 0)
except json.JSONDecodeError:
pass
# Extract metrics if available
metrics = grading.get("execution_metrics", {})
result["tool_calls"] = metrics.get("total_tool_calls", 0)
if not result.get("tokens"):
result["tokens"] = metrics.get("output_chars", 0)
result["errors"] = metrics.get("errors_encountered", 0)
# Extract expectations — viewer requires fields: text, passed, evidence
raw_expectations = grading.get("expectations", [])
for exp in raw_expectations:
if "text" not in exp or "passed" not in exp:
print(f"Warning: expectation in {grading_file} missing required fields (text, passed, evidence): {exp}")
result["expectations"] = raw_expectations
# Extract notes from user_notes_summary
notes_summary = grading.get("user_notes_summary", {})
notes = []
notes.extend(notes_summary.get("uncertainties", []))
notes.extend(notes_summary.get("needs_review", []))
notes.extend(notes_summary.get("workarounds", []))
result["notes"] = notes
results[config].append(result)
return results
def aggregate_results(results: dict) -> dict:
"""
Aggregate run results into summary statistics.
Returns run_summary with stats for each configuration and delta.
"""
run_summary = {}
configs = list(results.keys())
for config in configs:
runs = results.get(config, [])
if not runs:
run_summary[config] = {
"pass_rate": {"mean": 0.0, "stddev": 0.0, "min": 0.0, "max": 0.0},
"time_seconds": {"mean": 0.0, "stddev": 0.0, "min": 0.0, "max": 0.0},
"tokens": {"mean": 0, "stddev": 0, "min": 0, "max": 0}
}
continue
pass_rates = [r["pass_rate"] for r in runs]
times = [r["time_seconds"] for r in runs]
tokens = [r.get("tokens", 0) for r in runs]
run_summary[config] = {
"pass_rate": calculate_stats(pass_rates),
"time_seconds": calculate_stats(times),
"tokens": calculate_stats(tokens)
}
# Calculate delta between the first two configs (if two exist)
if len(configs) >= 2:
primary = run_summary.get(configs[0], {})
baseline = run_summary.get(configs[1], {})
else:
primary = run_summary.get(configs[0], {}) if configs else {}
baseline = {}
delta_pass_rate = primary.get("pass_rate", {}).get("mean", 0) - baseline.get("pass_rate", {}).get("mean", 0)
delta_time = primary.get("time_seconds", {}).get("mean", 0) - baseline.get("time_seconds", {}).get("mean", 0)
delta_tokens = primary.get("tokens", {}).get("mean", 0) - baseline.get("tokens", {}).get("mean", 0)
run_summary["delta"] = {
"pass_rate": f"{delta_pass_rate:+.2f}",
"time_seconds": f"{delta_time:+.1f}",
"tokens": f"{delta_tokens:+.0f}"
}
return run_summary
def generate_benchmark(benchmark_dir: Path, skill_name: str = "", skill_path: str = "") -> dict:
"""
Generate complete benchmark.json from run results.
"""
results = load_run_results(benchmark_dir)
run_summary = aggregate_results(results)
# Build runs array for benchmark.json
runs = []
for config in results:
for result in results[config]:
runs.append({
"eval_id": result["eval_id"],
"configuration": config,
"run_number": result["run_number"],
"result": {
"pass_rate": result["pass_rate"],
"passed": result["passed"],
"failed": result["failed"],
"total": result["total"],
"time_seconds": result["time_seconds"],
"tokens": result.get("tokens", 0),
"tool_calls": result.get("tool_calls", 0),
"errors": result.get("errors", 0)
},
"expectations": result["expectations"],
"notes": result["notes"]
})
# Determine eval IDs from results
eval_ids = sorted(set(
r["eval_id"]
for config in results.values()
for r in config
))
benchmark = {
"metadata": {
"skill_name": skill_name or "<skill-name>",
"skill_path": skill_path or "<path/to/skill>",
"executor_model": "<model-name>",
"analyzer_model": "<model-name>",
"timestamp": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
"evals_run": eval_ids,
"runs_per_configuration": 3
},
"runs": runs,
"run_summary": run_summary,
"notes": [] # To be filled by analyzer
}
return benchmark
def generate_markdown(benchmark: dict) -> str:
"""Generate human-readable benchmark.md from benchmark data."""
metadata = benchmark["metadata"]
run_summary = benchmark["run_summary"]
# Determine config names (excluding "delta")
configs = [k for k in run_summary if k != "delta"]
config_a = configs[0] if len(configs) >= 1 else "config_a"
config_b = configs[1] if len(configs) >= 2 else "config_b"
label_a = config_a.replace("_", " ").title()
label_b = config_b.replace("_", " ").title()
lines = [
f"# Skill Benchmark: {metadata['skill_name']}",
"",
f"**Model**: {metadata['executor_model']}",
f"**Date**: {metadata['timestamp']}",
f"**Evals**: {', '.join(map(str, metadata['evals_run']))} ({metadata['runs_per_configuration']} runs each per configuration)",
"",
"## Summary",
"",
f"| Metric | {label_a} | {label_b} | Delta |",
"|--------|------------|---------------|-------|",
]
a_summary = run_summary.get(config_a, {})
b_summary = run_summary.get(config_b, {})
delta = run_summary.get("delta", {})
# Format pass rate
a_pr = a_summary.get("pass_rate", {})
b_pr = b_summary.get("pass_rate", {})
lines.append(f"| Pass Rate | {a_pr.get('mean', 0)*100:.0f}% ± {a_pr.get('stddev', 0)*100:.0f}% | {b_pr.get('mean', 0)*100:.0f}% ± {b_pr.get('stddev', 0)*100:.0f}% | {delta.get('pass_rate', '')} |")
# Format time
a_time = a_summary.get("time_seconds", {})
b_time = b_summary.get("time_seconds", {})
lines.append(f"| Time | {a_time.get('mean', 0):.1f}s ± {a_time.get('stddev', 0):.1f}s | {b_time.get('mean', 0):.1f}s ± {b_time.get('stddev', 0):.1f}s | {delta.get('time_seconds', '')}s |")
# Format tokens
a_tokens = a_summary.get("tokens", {})
b_tokens = b_summary.get("tokens", {})
lines.append(f"| Tokens | {a_tokens.get('mean', 0):.0f} ± {a_tokens.get('stddev', 0):.0f} | {b_tokens.get('mean', 0):.0f} ± {b_tokens.get('stddev', 0):.0f} | {delta.get('tokens', '')} |")
# Notes section
if benchmark.get("notes"):
lines.extend([
"",
"## Notes",
""
])
for note in benchmark["notes"]:
lines.append(f"- {note}")
return "\n".join(lines)
def main():
parser = argparse.ArgumentParser(
description="Aggregate benchmark run results into summary statistics"
)
parser.add_argument(
"benchmark_dir",
type=Path,
help="Path to the benchmark directory"
)
parser.add_argument(
"--skill-name",
default="",
help="Name of the skill being benchmarked"
)
parser.add_argument(
"--skill-path",
default="",
help="Path to the skill being benchmarked"
)
parser.add_argument(
"--output", "-o",
type=Path,
help="Output path for benchmark.json (default: <benchmark_dir>/benchmark.json)"
)
args = parser.parse_args()
if not args.benchmark_dir.exists():
print(f"Directory not found: {args.benchmark_dir}")
sys.exit(1)
# Generate benchmark
benchmark = generate_benchmark(args.benchmark_dir, args.skill_name, args.skill_path)
# Determine output paths
output_json = args.output or (args.benchmark_dir / "benchmark.json")
output_md = output_json.with_suffix(".md")
# Write benchmark.json
with open(output_json, "w") as f:
json.dump(benchmark, f, indent=2)
print(f"Generated: {output_json}")
# Write benchmark.md
markdown = generate_markdown(benchmark)
with open(output_md, "w") as f:
f.write(markdown)
print(f"Generated: {output_md}")
# Print summary
run_summary = benchmark["run_summary"]
configs = [k for k in run_summary if k != "delta"]
delta = run_summary.get("delta", {})
print(f"\nSummary:")
for config in configs:
pr = run_summary[config]["pass_rate"]["mean"]
label = config.replace("_", " ").title()
print(f" {label}: {pr*100:.1f}% pass rate")
print(f" Delta: {delta.get('pass_rate', '')}")
if __name__ == "__main__":
main()

View File

@ -0,0 +1,326 @@
#!/usr/bin/env python3
"""Generate an HTML report from run_loop.py output.
Takes the JSON output from run_loop.py and generates a visual HTML report
showing each description attempt with check/x for each test case.
Distinguishes between train and test queries.
"""
import argparse
import html
import json
import sys
from pathlib import Path
def generate_html(data: dict, auto_refresh: bool = False, skill_name: str = "") -> str:
"""Generate HTML report from loop output data. If auto_refresh is True, adds a meta refresh tag."""
history = data.get("history", [])
holdout = data.get("holdout", 0)
title_prefix = html.escape(skill_name + " \u2014 ") if skill_name else ""
# Get all unique queries from train and test sets, with should_trigger info
train_queries: list[dict] = []
test_queries: list[dict] = []
if history:
for r in history[0].get("train_results", history[0].get("results", [])):
train_queries.append({"query": r["query"], "should_trigger": r.get("should_trigger", True)})
if history[0].get("test_results"):
for r in history[0].get("test_results", []):
test_queries.append({"query": r["query"], "should_trigger": r.get("should_trigger", True)})
refresh_tag = ' <meta http-equiv="refresh" content="5">\n' if auto_refresh else ""
html_parts = ["""<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
""" + refresh_tag + """ <title>""" + title_prefix + """Skill Description Optimization</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Poppins:wght@500;600&family=Lora:wght@400;500&display=swap" rel="stylesheet">
<style>
body {
font-family: 'Lora', Georgia, serif;
max-width: 100%;
margin: 0 auto;
padding: 20px;
background: #faf9f5;
color: #141413;
}
h1 { font-family: 'Poppins', sans-serif; color: #141413; }
.explainer {
background: white;
padding: 15px;
border-radius: 6px;
margin-bottom: 20px;
border: 1px solid #e8e6dc;
color: #b0aea5;
font-size: 0.875rem;
line-height: 1.6;
}
.summary {
background: white;
padding: 15px;
border-radius: 6px;
margin-bottom: 20px;
border: 1px solid #e8e6dc;
}
.summary p { margin: 5px 0; }
.best { color: #788c5d; font-weight: bold; }
.table-container {
overflow-x: auto;
width: 100%;
}
table {
border-collapse: collapse;
background: white;
border: 1px solid #e8e6dc;
border-radius: 6px;
font-size: 12px;
min-width: 100%;
}
th, td {
padding: 8px;
text-align: left;
border: 1px solid #e8e6dc;
white-space: normal;
word-wrap: break-word;
}
th {
font-family: 'Poppins', sans-serif;
background: #141413;
color: #faf9f5;
font-weight: 500;
}
th.test-col {
background: #6a9bcc;
}
th.query-col { min-width: 200px; }
td.description {
font-family: monospace;
font-size: 11px;
word-wrap: break-word;
max-width: 400px;
}
td.result {
text-align: center;
font-size: 16px;
min-width: 40px;
}
td.test-result {
background: #f0f6fc;
}
.pass { color: #788c5d; }
.fail { color: #c44; }
.rate {
font-size: 9px;
color: #b0aea5;
display: block;
}
tr:hover { background: #faf9f5; }
.score {
display: inline-block;
padding: 2px 6px;
border-radius: 4px;
font-weight: bold;
font-size: 11px;
}
.score-good { background: #eef2e8; color: #788c5d; }
.score-ok { background: #fef3c7; color: #d97706; }
.score-bad { background: #fceaea; color: #c44; }
.train-label { color: #b0aea5; font-size: 10px; }
.test-label { color: #6a9bcc; font-size: 10px; font-weight: bold; }
.best-row { background: #f5f8f2; }
th.positive-col { border-bottom: 3px solid #788c5d; }
th.negative-col { border-bottom: 3px solid #c44; }
th.test-col.positive-col { border-bottom: 3px solid #788c5d; }
th.test-col.negative-col { border-bottom: 3px solid #c44; }
.legend { font-family: 'Poppins', sans-serif; display: flex; gap: 20px; margin-bottom: 10px; font-size: 13px; align-items: center; }
.legend-item { display: flex; align-items: center; gap: 6px; }
.legend-swatch { width: 16px; height: 16px; border-radius: 3px; display: inline-block; }
.swatch-positive { background: #141413; border-bottom: 3px solid #788c5d; }
.swatch-negative { background: #141413; border-bottom: 3px solid #c44; }
.swatch-test { background: #6a9bcc; }
.swatch-train { background: #141413; }
</style>
</head>
<body>
<h1>""" + title_prefix + """Skill Description Optimization</h1>
<div class="explainer">
<strong>Optimizing your skill's description.</strong> This page updates automatically as Claude tests different versions of your skill's description. Each row is an iteration a new description attempt. The columns show test queries: green checkmarks mean the skill triggered correctly (or correctly didn't trigger), red crosses mean it got it wrong. The "Train" score shows performance on queries used to improve the description; the "Test" score shows performance on held-out queries the optimizer hasn't seen. When it's done, Claude will apply the best-performing description to your skill.
</div>
"""]
# Summary section
best_test_score = data.get('best_test_score')
best_train_score = data.get('best_train_score')
html_parts.append(f"""
<div class="summary">
<p><strong>Original:</strong> {html.escape(data.get('original_description', 'N/A'))}</p>
<p class="best"><strong>Best:</strong> {html.escape(data.get('best_description', 'N/A'))}</p>
<p><strong>Best Score:</strong> {data.get('best_score', 'N/A')} {'(test)' if best_test_score else '(train)'}</p>
<p><strong>Iterations:</strong> {data.get('iterations_run', 0)} | <strong>Train:</strong> {data.get('train_size', '?')} | <strong>Test:</strong> {data.get('test_size', '?')}</p>
</div>
""")
# Legend
html_parts.append("""
<div class="legend">
<span style="font-weight:600">Query columns:</span>
<span class="legend-item"><span class="legend-swatch swatch-positive"></span> Should trigger</span>
<span class="legend-item"><span class="legend-swatch swatch-negative"></span> Should NOT trigger</span>
<span class="legend-item"><span class="legend-swatch swatch-train"></span> Train</span>
<span class="legend-item"><span class="legend-swatch swatch-test"></span> Test</span>
</div>
""")
# Table header
html_parts.append("""
<div class="table-container">
<table>
<thead>
<tr>
<th>Iter</th>
<th>Train</th>
<th>Test</th>
<th class="query-col">Description</th>
""")
# Add column headers for train queries
for qinfo in train_queries:
polarity = "positive-col" if qinfo["should_trigger"] else "negative-col"
html_parts.append(f' <th class="{polarity}">{html.escape(qinfo["query"])}</th>\n')
# Add column headers for test queries (different color)
for qinfo in test_queries:
polarity = "positive-col" if qinfo["should_trigger"] else "negative-col"
html_parts.append(f' <th class="test-col {polarity}">{html.escape(qinfo["query"])}</th>\n')
html_parts.append(""" </tr>
</thead>
<tbody>
""")
# Find best iteration for highlighting
if test_queries:
best_iter = max(history, key=lambda h: h.get("test_passed") or 0).get("iteration")
else:
best_iter = max(history, key=lambda h: h.get("train_passed", h.get("passed", 0))).get("iteration")
# Add rows for each iteration
for h in history:
iteration = h.get("iteration", "?")
train_passed = h.get("train_passed", h.get("passed", 0))
train_total = h.get("train_total", h.get("total", 0))
test_passed = h.get("test_passed")
test_total = h.get("test_total")
description = h.get("description", "")
train_results = h.get("train_results", h.get("results", []))
test_results = h.get("test_results", [])
# Create lookups for results by query
train_by_query = {r["query"]: r for r in train_results}
test_by_query = {r["query"]: r for r in test_results} if test_results else {}
# Compute aggregate correct/total runs across all retries
def aggregate_runs(results: list[dict]) -> tuple[int, int]:
correct = 0
total = 0
for r in results:
runs = r.get("runs", 0)
triggers = r.get("triggers", 0)
total += runs
if r.get("should_trigger", True):
correct += triggers
else:
correct += runs - triggers
return correct, total
train_correct, train_runs = aggregate_runs(train_results)
test_correct, test_runs = aggregate_runs(test_results)
# Determine score classes
def score_class(correct: int, total: int) -> str:
if total > 0:
ratio = correct / total
if ratio >= 0.8:
return "score-good"
elif ratio >= 0.5:
return "score-ok"
return "score-bad"
train_class = score_class(train_correct, train_runs)
test_class = score_class(test_correct, test_runs)
row_class = "best-row" if iteration == best_iter else ""
html_parts.append(f""" <tr class="{row_class}">
<td>{iteration}</td>
<td><span class="score {train_class}">{train_correct}/{train_runs}</span></td>
<td><span class="score {test_class}">{test_correct}/{test_runs}</span></td>
<td class="description">{html.escape(description)}</td>
""")
# Add result for each train query
for qinfo in train_queries:
r = train_by_query.get(qinfo["query"], {})
did_pass = r.get("pass", False)
triggers = r.get("triggers", 0)
runs = r.get("runs", 0)
icon = "" if did_pass else ""
css_class = "pass" if did_pass else "fail"
html_parts.append(f' <td class="result {css_class}">{icon}<span class="rate">{triggers}/{runs}</span></td>\n')
# Add result for each test query (with different background)
for qinfo in test_queries:
r = test_by_query.get(qinfo["query"], {})
did_pass = r.get("pass", False)
triggers = r.get("triggers", 0)
runs = r.get("runs", 0)
icon = "" if did_pass else ""
css_class = "pass" if did_pass else "fail"
html_parts.append(f' <td class="result test-result {css_class}">{icon}<span class="rate">{triggers}/{runs}</span></td>\n')
html_parts.append(" </tr>\n")
html_parts.append(""" </tbody>
</table>
</div>
""")
html_parts.append("""
</body>
</html>
""")
return "".join(html_parts)
def main():
parser = argparse.ArgumentParser(description="Generate HTML report from run_loop output")
parser.add_argument("input", help="Path to JSON output from run_loop.py (or - for stdin)")
parser.add_argument("-o", "--output", default=None, help="Output HTML file (default: stdout)")
parser.add_argument("--skill-name", default="", help="Skill name to include in the report title")
args = parser.parse_args()
if args.input == "-":
data = json.load(sys.stdin)
else:
data = json.loads(Path(args.input).read_text())
html_output = generate_html(data, skill_name=args.skill_name)
if args.output:
Path(args.output).write_text(html_output)
print(f"Report written to {args.output}", file=sys.stderr)
else:
print(html_output)
if __name__ == "__main__":
main()

View File

@ -0,0 +1,247 @@
#!/usr/bin/env python3
"""Improve a skill description based on eval results.
Takes eval results (from run_eval.py) and generates an improved description
by calling `claude -p` as a subprocess (same auth pattern as run_eval.py
uses the session's Claude Code auth, no separate ANTHROPIC_API_KEY needed).
"""
import argparse
import json
import os
import re
import subprocess
import sys
from pathlib import Path
from scripts.utils import parse_skill_md
def _call_claude(prompt: str, model: str | None, timeout: int = 300) -> str:
"""Run `claude -p` with the prompt on stdin and return the text response.
Prompt goes over stdin (not argv) because it embeds the full SKILL.md
body and can easily exceed comfortable argv length.
"""
cmd = ["claude", "-p", "--output-format", "text"]
if model:
cmd.extend(["--model", model])
# Remove CLAUDECODE env var to allow nesting claude -p inside a
# Claude Code session. The guard is for interactive terminal conflicts;
# programmatic subprocess usage is safe. Same pattern as run_eval.py.
env = {k: v for k, v in os.environ.items() if k != "CLAUDECODE"}
result = subprocess.run(
cmd,
input=prompt,
capture_output=True,
text=True,
env=env,
timeout=timeout,
)
if result.returncode != 0:
raise RuntimeError(
f"claude -p exited {result.returncode}\nstderr: {result.stderr}"
)
return result.stdout
def improve_description(
skill_name: str,
skill_content: str,
current_description: str,
eval_results: dict,
history: list[dict],
model: str,
test_results: dict | None = None,
log_dir: Path | None = None,
iteration: int | None = None,
) -> str:
"""Call Claude to improve the description based on eval results."""
failed_triggers = [
r for r in eval_results["results"]
if r["should_trigger"] and not r["pass"]
]
false_triggers = [
r for r in eval_results["results"]
if not r["should_trigger"] and not r["pass"]
]
# Build scores summary
train_score = f"{eval_results['summary']['passed']}/{eval_results['summary']['total']}"
if test_results:
test_score = f"{test_results['summary']['passed']}/{test_results['summary']['total']}"
scores_summary = f"Train: {train_score}, Test: {test_score}"
else:
scores_summary = f"Train: {train_score}"
prompt = f"""You are optimizing a skill description for a Claude Code skill called "{skill_name}". A "skill" is sort of like a prompt, but with progressive disclosure -- there's a title and description that Claude sees when deciding whether to use the skill, and then if it does use the skill, it reads the .md file which has lots more details and potentially links to other resources in the skill folder like helper files and scripts and additional documentation or examples.
The description appears in Claude's "available_skills" list. When a user sends a query, Claude decides whether to invoke the skill based solely on the title and on this description. Your goal is to write a description that triggers for relevant queries, and doesn't trigger for irrelevant ones.
Here's the current description:
<current_description>
"{current_description}"
</current_description>
Current scores ({scores_summary}):
<scores_summary>
"""
if failed_triggers:
prompt += "FAILED TO TRIGGER (should have triggered but didn't):\n"
for r in failed_triggers:
prompt += f' - "{r["query"]}" (triggered {r["triggers"]}/{r["runs"]} times)\n'
prompt += "\n"
if false_triggers:
prompt += "FALSE TRIGGERS (triggered but shouldn't have):\n"
for r in false_triggers:
prompt += f' - "{r["query"]}" (triggered {r["triggers"]}/{r["runs"]} times)\n'
prompt += "\n"
if history:
prompt += "PREVIOUS ATTEMPTS (do NOT repeat these — try something structurally different):\n\n"
for h in history:
train_s = f"{h.get('train_passed', h.get('passed', 0))}/{h.get('train_total', h.get('total', 0))}"
test_s = f"{h.get('test_passed', '?')}/{h.get('test_total', '?')}" if h.get('test_passed') is not None else None
score_str = f"train={train_s}" + (f", test={test_s}" if test_s else "")
prompt += f'<attempt {score_str}>\n'
prompt += f'Description: "{h["description"]}"\n'
if "results" in h:
prompt += "Train results:\n"
for r in h["results"]:
status = "PASS" if r["pass"] else "FAIL"
prompt += f' [{status}] "{r["query"][:80]}" (triggered {r["triggers"]}/{r["runs"]})\n'
if h.get("note"):
prompt += f'Note: {h["note"]}\n'
prompt += "</attempt>\n\n"
prompt += f"""</scores_summary>
Skill content (for context on what the skill does):
<skill_content>
{skill_content}
</skill_content>
Based on the failures, write a new and improved description that is more likely to trigger correctly. When I say "based on the failures", it's a bit of a tricky line to walk because we don't want to overfit to the specific cases you're seeing. So what I DON'T want you to do is produce an ever-expanding list of specific queries that this skill should or shouldn't trigger for. Instead, try to generalize from the failures to broader categories of user intent and situations where this skill would be useful or not useful. The reason for this is twofold:
1. Avoid overfitting
2. The list might get loooong and it's injected into ALL queries and there might be a lot of skills, so we don't want to blow too much space on any given description.
Concretely, your description should not be more than about 100-200 words, even if that comes at the cost of accuracy. There is a hard limit of 1024 characters descriptions over that will be truncated, so stay comfortably under it.
Here are some tips that we've found to work well in writing these descriptions:
- The skill should be phrased in the imperative -- "Use this skill for" rather than "this skill does"
- The skill description should focus on the user's intent, what they are trying to achieve, vs. the implementation details of how the skill works.
- The description competes with other skills for Claude's attention — make it distinctive and immediately recognizable.
- If you're getting lots of failures after repeated attempts, change things up. Try different sentence structures or wordings.
I'd encourage you to be creative and mix up the style in different iterations since you'll have multiple opportunities to try different approaches and we'll just grab the highest-scoring one at the end.
Please respond with only the new description text in <new_description> tags, nothing else."""
text = _call_claude(prompt, model)
match = re.search(r"<new_description>(.*?)</new_description>", text, re.DOTALL)
description = match.group(1).strip().strip('"') if match else text.strip().strip('"')
transcript: dict = {
"iteration": iteration,
"prompt": prompt,
"response": text,
"parsed_description": description,
"char_count": len(description),
"over_limit": len(description) > 1024,
}
# Safety net: the prompt already states the 1024-char hard limit, but if
# the model blew past it anyway, make one fresh single-turn call that
# quotes the too-long version and asks for a shorter rewrite. (The old
# SDK path did this as a true multi-turn; `claude -p` is one-shot, so we
# inline the prior output into the new prompt instead.)
if len(description) > 1024:
shorten_prompt = (
f"{prompt}\n\n"
f"---\n\n"
f"A previous attempt produced this description, which at "
f"{len(description)} characters is over the 1024-character hard limit:\n\n"
f'"{description}"\n\n'
f"Rewrite it to be under 1024 characters while keeping the most "
f"important trigger words and intent coverage. Respond with only "
f"the new description in <new_description> tags."
)
shorten_text = _call_claude(shorten_prompt, model)
match = re.search(r"<new_description>(.*?)</new_description>", shorten_text, re.DOTALL)
shortened = match.group(1).strip().strip('"') if match else shorten_text.strip().strip('"')
transcript["rewrite_prompt"] = shorten_prompt
transcript["rewrite_response"] = shorten_text
transcript["rewrite_description"] = shortened
transcript["rewrite_char_count"] = len(shortened)
description = shortened
transcript["final_description"] = description
if log_dir:
log_dir.mkdir(parents=True, exist_ok=True)
log_file = log_dir / f"improve_iter_{iteration or 'unknown'}.json"
log_file.write_text(json.dumps(transcript, indent=2))
return description
def main():
parser = argparse.ArgumentParser(description="Improve a skill description based on eval results")
parser.add_argument("--eval-results", required=True, help="Path to eval results JSON (from run_eval.py)")
parser.add_argument("--skill-path", required=True, help="Path to skill directory")
parser.add_argument("--history", default=None, help="Path to history JSON (previous attempts)")
parser.add_argument("--model", required=True, help="Model for improvement")
parser.add_argument("--verbose", action="store_true", help="Print thinking to stderr")
args = parser.parse_args()
skill_path = Path(args.skill_path)
if not (skill_path / "SKILL.md").exists():
print(f"Error: No SKILL.md found at {skill_path}", file=sys.stderr)
sys.exit(1)
eval_results = json.loads(Path(args.eval_results).read_text())
history = []
if args.history:
history = json.loads(Path(args.history).read_text())
name, _, content = parse_skill_md(skill_path)
current_description = eval_results["description"]
if args.verbose:
print(f"Current: {current_description}", file=sys.stderr)
print(f"Score: {eval_results['summary']['passed']}/{eval_results['summary']['total']}", file=sys.stderr)
new_description = improve_description(
skill_name=name,
skill_content=content,
current_description=current_description,
eval_results=eval_results,
history=history,
model=args.model,
)
if args.verbose:
print(f"Improved: {new_description}", file=sys.stderr)
# Output as JSON with both the new description and updated history
output = {
"description": new_description,
"history": history + [{
"description": current_description,
"passed": eval_results["summary"]["passed"],
"failed": eval_results["summary"]["failed"],
"total": eval_results["summary"]["total"],
"results": eval_results["results"],
}],
}
print(json.dumps(output, indent=2))
if __name__ == "__main__":
main()

View File

@ -0,0 +1,136 @@
#!/usr/bin/env python3
"""
Skill Packager - Creates a distributable .skill file of a skill folder
Usage:
python utils/package_skill.py <path/to/skill-folder> [output-directory]
Example:
python utils/package_skill.py skills/public/my-skill
python utils/package_skill.py skills/public/my-skill ./dist
"""
import fnmatch
import sys
import zipfile
from pathlib import Path
from scripts.quick_validate import validate_skill
# Patterns to exclude when packaging skills.
EXCLUDE_DIRS = {"__pycache__", "node_modules"}
EXCLUDE_GLOBS = {"*.pyc"}
EXCLUDE_FILES = {".DS_Store"}
# Directories excluded only at the skill root (not when nested deeper).
ROOT_EXCLUDE_DIRS = {"evals"}
def should_exclude(rel_path: Path) -> bool:
"""Check if a path should be excluded from packaging."""
parts = rel_path.parts
if any(part in EXCLUDE_DIRS for part in parts):
return True
# rel_path is relative to skill_path.parent, so parts[0] is the skill
# folder name and parts[1] (if present) is the first subdir.
if len(parts) > 1 and parts[1] in ROOT_EXCLUDE_DIRS:
return True
name = rel_path.name
if name in EXCLUDE_FILES:
return True
return any(fnmatch.fnmatch(name, pat) for pat in EXCLUDE_GLOBS)
def package_skill(skill_path, output_dir=None):
"""
Package a skill folder into a .skill file.
Args:
skill_path: Path to the skill folder
output_dir: Optional output directory for the .skill file (defaults to current directory)
Returns:
Path to the created .skill file, or None if error
"""
skill_path = Path(skill_path).resolve()
# Validate skill folder exists
if not skill_path.exists():
print(f"❌ Error: Skill folder not found: {skill_path}")
return None
if not skill_path.is_dir():
print(f"❌ Error: Path is not a directory: {skill_path}")
return None
# Validate SKILL.md exists
skill_md = skill_path / "SKILL.md"
if not skill_md.exists():
print(f"❌ Error: SKILL.md not found in {skill_path}")
return None
# Run validation before packaging
print("🔍 Validating skill...")
valid, message = validate_skill(skill_path)
if not valid:
print(f"❌ Validation failed: {message}")
print(" Please fix the validation errors before packaging.")
return None
print(f"{message}\n")
# Determine output location
skill_name = skill_path.name
if output_dir:
output_path = Path(output_dir).resolve()
output_path.mkdir(parents=True, exist_ok=True)
else:
output_path = Path.cwd()
skill_filename = output_path / f"{skill_name}.skill"
# Create the .skill file (zip format)
try:
with zipfile.ZipFile(skill_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
# Walk through the skill directory, excluding build artifacts
for file_path in skill_path.rglob('*'):
if not file_path.is_file():
continue
arcname = file_path.relative_to(skill_path.parent)
if should_exclude(arcname):
print(f" Skipped: {arcname}")
continue
zipf.write(file_path, arcname)
print(f" Added: {arcname}")
print(f"\n✅ Successfully packaged skill to: {skill_filename}")
return skill_filename
except Exception as e:
print(f"❌ Error creating .skill file: {e}")
return None
def main():
if len(sys.argv) < 2:
print("Usage: python utils/package_skill.py <path/to/skill-folder> [output-directory]")
print("\nExample:")
print(" python utils/package_skill.py skills/public/my-skill")
print(" python utils/package_skill.py skills/public/my-skill ./dist")
sys.exit(1)
skill_path = sys.argv[1]
output_dir = sys.argv[2] if len(sys.argv) > 2 else None
print(f"📦 Packaging skill: {skill_path}")
if output_dir:
print(f" Output directory: {output_dir}")
print()
result = package_skill(skill_path, output_dir)
if result:
sys.exit(0)
else:
sys.exit(1)
if __name__ == "__main__":
main()

View File

@ -0,0 +1,103 @@
#!/usr/bin/env python3
"""
Quick validation script for skills - minimal version
"""
import sys
import os
import re
import yaml
from pathlib import Path
def validate_skill(skill_path):
"""Basic validation of a skill"""
skill_path = Path(skill_path)
# Check SKILL.md exists
skill_md = skill_path / 'SKILL.md'
if not skill_md.exists():
return False, "SKILL.md not found"
# Read and validate frontmatter
content = skill_md.read_text()
if not content.startswith('---'):
return False, "No YAML frontmatter found"
# Extract frontmatter
match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
if not match:
return False, "Invalid frontmatter format"
frontmatter_text = match.group(1)
# Parse YAML frontmatter
try:
frontmatter = yaml.safe_load(frontmatter_text)
if not isinstance(frontmatter, dict):
return False, "Frontmatter must be a YAML dictionary"
except yaml.YAMLError as e:
return False, f"Invalid YAML in frontmatter: {e}"
# Define allowed properties
ALLOWED_PROPERTIES = {'name', 'description', 'license', 'allowed-tools', 'metadata', 'compatibility'}
# Check for unexpected properties (excluding nested keys under metadata)
unexpected_keys = set(frontmatter.keys()) - ALLOWED_PROPERTIES
if unexpected_keys:
return False, (
f"Unexpected key(s) in SKILL.md frontmatter: {', '.join(sorted(unexpected_keys))}. "
f"Allowed properties are: {', '.join(sorted(ALLOWED_PROPERTIES))}"
)
# Check required fields
if 'name' not in frontmatter:
return False, "Missing 'name' in frontmatter"
if 'description' not in frontmatter:
return False, "Missing 'description' in frontmatter"
# Extract name for validation
name = frontmatter.get('name', '')
if not isinstance(name, str):
return False, f"Name must be a string, got {type(name).__name__}"
name = name.strip()
if name:
# Check naming convention (kebab-case: lowercase with hyphens)
if not re.match(r'^[a-z0-9-]+$', name):
return False, f"Name '{name}' should be kebab-case (lowercase letters, digits, and hyphens only)"
if name.startswith('-') or name.endswith('-') or '--' in name:
return False, f"Name '{name}' cannot start/end with hyphen or contain consecutive hyphens"
# Check name length (max 64 characters per spec)
if len(name) > 64:
return False, f"Name is too long ({len(name)} characters). Maximum is 64 characters."
# Extract and validate description
description = frontmatter.get('description', '')
if not isinstance(description, str):
return False, f"Description must be a string, got {type(description).__name__}"
description = description.strip()
if description:
# Check for angle brackets
if '<' in description or '>' in description:
return False, "Description cannot contain angle brackets (< or >)"
# Check description length (max 1024 characters per spec)
if len(description) > 1024:
return False, f"Description is too long ({len(description)} characters). Maximum is 1024 characters."
# Validate compatibility field if present (optional)
compatibility = frontmatter.get('compatibility', '')
if compatibility:
if not isinstance(compatibility, str):
return False, f"Compatibility must be a string, got {type(compatibility).__name__}"
if len(compatibility) > 500:
return False, f"Compatibility is too long ({len(compatibility)} characters). Maximum is 500 characters."
return True, "Skill is valid!"
if __name__ == "__main__":
if len(sys.argv) != 2:
print("Usage: python quick_validate.py <skill_directory>")
sys.exit(1)
valid, message = validate_skill(sys.argv[1])
print(message)
sys.exit(0 if valid else 1)

View File

@ -0,0 +1,310 @@
#!/usr/bin/env python3
"""Run trigger evaluation for a skill description.
Tests whether a skill's description causes Claude to trigger (read the skill)
for a set of queries. Outputs results as JSON.
"""
import argparse
import json
import os
import select
import subprocess
import sys
import time
import uuid
from concurrent.futures import ProcessPoolExecutor, as_completed
from pathlib import Path
from scripts.utils import parse_skill_md
def find_project_root() -> Path:
"""Find the project root by walking up from cwd looking for .claude/.
Mimics how Claude Code discovers its project root, so the command file
we create ends up where claude -p will look for it.
"""
current = Path.cwd()
for parent in [current, *current.parents]:
if (parent / ".claude").is_dir():
return parent
return current
def run_single_query(
query: str,
skill_name: str,
skill_description: str,
timeout: int,
project_root: str,
model: str | None = None,
) -> bool:
"""Run a single query and return whether the skill was triggered.
Creates a command file in .claude/commands/ so it appears in Claude's
available_skills list, then runs `claude -p` with the raw query.
Uses --include-partial-messages to detect triggering early from
stream events (content_block_start) rather than waiting for the
full assistant message, which only arrives after tool execution.
"""
unique_id = uuid.uuid4().hex[:8]
clean_name = f"{skill_name}-skill-{unique_id}"
project_commands_dir = Path(project_root) / ".claude" / "commands"
command_file = project_commands_dir / f"{clean_name}.md"
try:
project_commands_dir.mkdir(parents=True, exist_ok=True)
# Use YAML block scalar to avoid breaking on quotes in description
indented_desc = "\n ".join(skill_description.split("\n"))
command_content = (
f"---\n"
f"description: |\n"
f" {indented_desc}\n"
f"---\n\n"
f"# {skill_name}\n\n"
f"This skill handles: {skill_description}\n"
)
command_file.write_text(command_content)
cmd = [
"claude",
"-p", query,
"--output-format", "stream-json",
"--verbose",
"--include-partial-messages",
]
if model:
cmd.extend(["--model", model])
# Remove CLAUDECODE env var to allow nesting claude -p inside a
# Claude Code session. The guard is for interactive terminal conflicts;
# programmatic subprocess usage is safe.
env = {k: v for k, v in os.environ.items() if k != "CLAUDECODE"}
process = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
cwd=project_root,
env=env,
)
triggered = False
start_time = time.time()
buffer = ""
# Track state for stream event detection
pending_tool_name = None
accumulated_json = ""
try:
while time.time() - start_time < timeout:
if process.poll() is not None:
remaining = process.stdout.read()
if remaining:
buffer += remaining.decode("utf-8", errors="replace")
break
ready, _, _ = select.select([process.stdout], [], [], 1.0)
if not ready:
continue
chunk = os.read(process.stdout.fileno(), 8192)
if not chunk:
break
buffer += chunk.decode("utf-8", errors="replace")
while "\n" in buffer:
line, buffer = buffer.split("\n", 1)
line = line.strip()
if not line:
continue
try:
event = json.loads(line)
except json.JSONDecodeError:
continue
# Early detection via stream events
if event.get("type") == "stream_event":
se = event.get("event", {})
se_type = se.get("type", "")
if se_type == "content_block_start":
cb = se.get("content_block", {})
if cb.get("type") == "tool_use":
tool_name = cb.get("name", "")
if tool_name in ("Skill", "Read"):
pending_tool_name = tool_name
accumulated_json = ""
else:
return False
elif se_type == "content_block_delta" and pending_tool_name:
delta = se.get("delta", {})
if delta.get("type") == "input_json_delta":
accumulated_json += delta.get("partial_json", "")
if clean_name in accumulated_json:
return True
elif se_type in ("content_block_stop", "message_stop"):
if pending_tool_name:
return clean_name in accumulated_json
if se_type == "message_stop":
return False
# Fallback: full assistant message
elif event.get("type") == "assistant":
message = event.get("message", {})
for content_item in message.get("content", []):
if content_item.get("type") != "tool_use":
continue
tool_name = content_item.get("name", "")
tool_input = content_item.get("input", {})
if tool_name == "Skill" and clean_name in tool_input.get("skill", ""):
triggered = True
elif tool_name == "Read" and clean_name in tool_input.get("file_path", ""):
triggered = True
return triggered
elif event.get("type") == "result":
return triggered
finally:
# Clean up process on any exit path (return, exception, timeout)
if process.poll() is None:
process.kill()
process.wait()
return triggered
finally:
if command_file.exists():
command_file.unlink()
def run_eval(
eval_set: list[dict],
skill_name: str,
description: str,
num_workers: int,
timeout: int,
project_root: Path,
runs_per_query: int = 1,
trigger_threshold: float = 0.5,
model: str | None = None,
) -> dict:
"""Run the full eval set and return results."""
results = []
with ProcessPoolExecutor(max_workers=num_workers) as executor:
future_to_info = {}
for item in eval_set:
for run_idx in range(runs_per_query):
future = executor.submit(
run_single_query,
item["query"],
skill_name,
description,
timeout,
str(project_root),
model,
)
future_to_info[future] = (item, run_idx)
query_triggers: dict[str, list[bool]] = {}
query_items: dict[str, dict] = {}
for future in as_completed(future_to_info):
item, _ = future_to_info[future]
query = item["query"]
query_items[query] = item
if query not in query_triggers:
query_triggers[query] = []
try:
query_triggers[query].append(future.result())
except Exception as e:
print(f"Warning: query failed: {e}", file=sys.stderr)
query_triggers[query].append(False)
for query, triggers in query_triggers.items():
item = query_items[query]
trigger_rate = sum(triggers) / len(triggers)
should_trigger = item["should_trigger"]
if should_trigger:
did_pass = trigger_rate >= trigger_threshold
else:
did_pass = trigger_rate < trigger_threshold
results.append({
"query": query,
"should_trigger": should_trigger,
"trigger_rate": trigger_rate,
"triggers": sum(triggers),
"runs": len(triggers),
"pass": did_pass,
})
passed = sum(1 for r in results if r["pass"])
total = len(results)
return {
"skill_name": skill_name,
"description": description,
"results": results,
"summary": {
"total": total,
"passed": passed,
"failed": total - passed,
},
}
def main():
parser = argparse.ArgumentParser(description="Run trigger evaluation for a skill description")
parser.add_argument("--eval-set", required=True, help="Path to eval set JSON file")
parser.add_argument("--skill-path", required=True, help="Path to skill directory")
parser.add_argument("--description", default=None, help="Override description to test")
parser.add_argument("--num-workers", type=int, default=10, help="Number of parallel workers")
parser.add_argument("--timeout", type=int, default=30, help="Timeout per query in seconds")
parser.add_argument("--runs-per-query", type=int, default=3, help="Number of runs per query")
parser.add_argument("--trigger-threshold", type=float, default=0.5, help="Trigger rate threshold")
parser.add_argument("--model", default=None, help="Model to use for claude -p (default: user's configured model)")
parser.add_argument("--verbose", action="store_true", help="Print progress to stderr")
args = parser.parse_args()
eval_set = json.loads(Path(args.eval_set).read_text())
skill_path = Path(args.skill_path)
if not (skill_path / "SKILL.md").exists():
print(f"Error: No SKILL.md found at {skill_path}", file=sys.stderr)
sys.exit(1)
name, original_description, content = parse_skill_md(skill_path)
description = args.description or original_description
project_root = find_project_root()
if args.verbose:
print(f"Evaluating: {description}", file=sys.stderr)
output = run_eval(
eval_set=eval_set,
skill_name=name,
description=description,
num_workers=args.num_workers,
timeout=args.timeout,
project_root=project_root,
runs_per_query=args.runs_per_query,
trigger_threshold=args.trigger_threshold,
model=args.model,
)
if args.verbose:
summary = output["summary"]
print(f"Results: {summary['passed']}/{summary['total']} passed", file=sys.stderr)
for r in output["results"]:
status = "PASS" if r["pass"] else "FAIL"
rate_str = f"{r['triggers']}/{r['runs']}"
print(f" [{status}] rate={rate_str} expected={r['should_trigger']}: {r['query'][:70]}", file=sys.stderr)
print(json.dumps(output, indent=2))
if __name__ == "__main__":
main()

View File

@ -0,0 +1,328 @@
#!/usr/bin/env python3
"""Run the eval + improve loop until all pass or max iterations reached.
Combines run_eval.py and improve_description.py in a loop, tracking history
and returning the best description found. Supports train/test split to prevent
overfitting.
"""
import argparse
import json
import random
import sys
import tempfile
import time
import webbrowser
from pathlib import Path
from scripts.generate_report import generate_html
from scripts.improve_description import improve_description
from scripts.run_eval import find_project_root, run_eval
from scripts.utils import parse_skill_md
def split_eval_set(eval_set: list[dict], holdout: float, seed: int = 42) -> tuple[list[dict], list[dict]]:
"""Split eval set into train and test sets, stratified by should_trigger."""
random.seed(seed)
# Separate by should_trigger
trigger = [e for e in eval_set if e["should_trigger"]]
no_trigger = [e for e in eval_set if not e["should_trigger"]]
# Shuffle each group
random.shuffle(trigger)
random.shuffle(no_trigger)
# Calculate split points
n_trigger_test = max(1, int(len(trigger) * holdout))
n_no_trigger_test = max(1, int(len(no_trigger) * holdout))
# Split
test_set = trigger[:n_trigger_test] + no_trigger[:n_no_trigger_test]
train_set = trigger[n_trigger_test:] + no_trigger[n_no_trigger_test:]
return train_set, test_set
def run_loop(
eval_set: list[dict],
skill_path: Path,
description_override: str | None,
num_workers: int,
timeout: int,
max_iterations: int,
runs_per_query: int,
trigger_threshold: float,
holdout: float,
model: str,
verbose: bool,
live_report_path: Path | None = None,
log_dir: Path | None = None,
) -> dict:
"""Run the eval + improvement loop."""
project_root = find_project_root()
name, original_description, content = parse_skill_md(skill_path)
current_description = description_override or original_description
# Split into train/test if holdout > 0
if holdout > 0:
train_set, test_set = split_eval_set(eval_set, holdout)
if verbose:
print(f"Split: {len(train_set)} train, {len(test_set)} test (holdout={holdout})", file=sys.stderr)
else:
train_set = eval_set
test_set = []
history = []
exit_reason = "unknown"
for iteration in range(1, max_iterations + 1):
if verbose:
print(f"\n{'='*60}", file=sys.stderr)
print(f"Iteration {iteration}/{max_iterations}", file=sys.stderr)
print(f"Description: {current_description}", file=sys.stderr)
print(f"{'='*60}", file=sys.stderr)
# Evaluate train + test together in one batch for parallelism
all_queries = train_set + test_set
t0 = time.time()
all_results = run_eval(
eval_set=all_queries,
skill_name=name,
description=current_description,
num_workers=num_workers,
timeout=timeout,
project_root=project_root,
runs_per_query=runs_per_query,
trigger_threshold=trigger_threshold,
model=model,
)
eval_elapsed = time.time() - t0
# Split results back into train/test by matching queries
train_queries_set = {q["query"] for q in train_set}
train_result_list = [r for r in all_results["results"] if r["query"] in train_queries_set]
test_result_list = [r for r in all_results["results"] if r["query"] not in train_queries_set]
train_passed = sum(1 for r in train_result_list if r["pass"])
train_total = len(train_result_list)
train_summary = {"passed": train_passed, "failed": train_total - train_passed, "total": train_total}
train_results = {"results": train_result_list, "summary": train_summary}
if test_set:
test_passed = sum(1 for r in test_result_list if r["pass"])
test_total = len(test_result_list)
test_summary = {"passed": test_passed, "failed": test_total - test_passed, "total": test_total}
test_results = {"results": test_result_list, "summary": test_summary}
else:
test_results = None
test_summary = None
history.append({
"iteration": iteration,
"description": current_description,
"train_passed": train_summary["passed"],
"train_failed": train_summary["failed"],
"train_total": train_summary["total"],
"train_results": train_results["results"],
"test_passed": test_summary["passed"] if test_summary else None,
"test_failed": test_summary["failed"] if test_summary else None,
"test_total": test_summary["total"] if test_summary else None,
"test_results": test_results["results"] if test_results else None,
# For backward compat with report generator
"passed": train_summary["passed"],
"failed": train_summary["failed"],
"total": train_summary["total"],
"results": train_results["results"],
})
# Write live report if path provided
if live_report_path:
partial_output = {
"original_description": original_description,
"best_description": current_description,
"best_score": "in progress",
"iterations_run": len(history),
"holdout": holdout,
"train_size": len(train_set),
"test_size": len(test_set),
"history": history,
}
live_report_path.write_text(generate_html(partial_output, auto_refresh=True, skill_name=name))
if verbose:
def print_eval_stats(label, results, elapsed):
pos = [r for r in results if r["should_trigger"]]
neg = [r for r in results if not r["should_trigger"]]
tp = sum(r["triggers"] for r in pos)
pos_runs = sum(r["runs"] for r in pos)
fn = pos_runs - tp
fp = sum(r["triggers"] for r in neg)
neg_runs = sum(r["runs"] for r in neg)
tn = neg_runs - fp
total = tp + tn + fp + fn
precision = tp / (tp + fp) if (tp + fp) > 0 else 1.0
recall = tp / (tp + fn) if (tp + fn) > 0 else 1.0
accuracy = (tp + tn) / total if total > 0 else 0.0
print(f"{label}: {tp+tn}/{total} correct, precision={precision:.0%} recall={recall:.0%} accuracy={accuracy:.0%} ({elapsed:.1f}s)", file=sys.stderr)
for r in results:
status = "PASS" if r["pass"] else "FAIL"
rate_str = f"{r['triggers']}/{r['runs']}"
print(f" [{status}] rate={rate_str} expected={r['should_trigger']}: {r['query'][:60]}", file=sys.stderr)
print_eval_stats("Train", train_results["results"], eval_elapsed)
if test_summary:
print_eval_stats("Test ", test_results["results"], 0)
if train_summary["failed"] == 0:
exit_reason = f"all_passed (iteration {iteration})"
if verbose:
print(f"\nAll train queries passed on iteration {iteration}!", file=sys.stderr)
break
if iteration == max_iterations:
exit_reason = f"max_iterations ({max_iterations})"
if verbose:
print(f"\nMax iterations reached ({max_iterations}).", file=sys.stderr)
break
# Improve the description based on train results
if verbose:
print(f"\nImproving description...", file=sys.stderr)
t0 = time.time()
# Strip test scores from history so improvement model can't see them
blinded_history = [
{k: v for k, v in h.items() if not k.startswith("test_")}
for h in history
]
new_description = improve_description(
skill_name=name,
skill_content=content,
current_description=current_description,
eval_results=train_results,
history=blinded_history,
model=model,
log_dir=log_dir,
iteration=iteration,
)
improve_elapsed = time.time() - t0
if verbose:
print(f"Proposed ({improve_elapsed:.1f}s): {new_description}", file=sys.stderr)
current_description = new_description
# Find the best iteration by TEST score (or train if no test set)
if test_set:
best = max(history, key=lambda h: h["test_passed"] or 0)
best_score = f"{best['test_passed']}/{best['test_total']}"
else:
best = max(history, key=lambda h: h["train_passed"])
best_score = f"{best['train_passed']}/{best['train_total']}"
if verbose:
print(f"\nExit reason: {exit_reason}", file=sys.stderr)
print(f"Best score: {best_score} (iteration {best['iteration']})", file=sys.stderr)
return {
"exit_reason": exit_reason,
"original_description": original_description,
"best_description": best["description"],
"best_score": best_score,
"best_train_score": f"{best['train_passed']}/{best['train_total']}",
"best_test_score": f"{best['test_passed']}/{best['test_total']}" if test_set else None,
"final_description": current_description,
"iterations_run": len(history),
"holdout": holdout,
"train_size": len(train_set),
"test_size": len(test_set),
"history": history,
}
def main():
parser = argparse.ArgumentParser(description="Run eval + improve loop")
parser.add_argument("--eval-set", required=True, help="Path to eval set JSON file")
parser.add_argument("--skill-path", required=True, help="Path to skill directory")
parser.add_argument("--description", default=None, help="Override starting description")
parser.add_argument("--num-workers", type=int, default=10, help="Number of parallel workers")
parser.add_argument("--timeout", type=int, default=30, help="Timeout per query in seconds")
parser.add_argument("--max-iterations", type=int, default=5, help="Max improvement iterations")
parser.add_argument("--runs-per-query", type=int, default=3, help="Number of runs per query")
parser.add_argument("--trigger-threshold", type=float, default=0.5, help="Trigger rate threshold")
parser.add_argument("--holdout", type=float, default=0.4, help="Fraction of eval set to hold out for testing (0 to disable)")
parser.add_argument("--model", required=True, help="Model for improvement")
parser.add_argument("--verbose", action="store_true", help="Print progress to stderr")
parser.add_argument("--report", default="auto", help="Generate HTML report at this path (default: 'auto' for temp file, 'none' to disable)")
parser.add_argument("--results-dir", default=None, help="Save all outputs (results.json, report.html, log.txt) to a timestamped subdirectory here")
args = parser.parse_args()
eval_set = json.loads(Path(args.eval_set).read_text())
skill_path = Path(args.skill_path)
if not (skill_path / "SKILL.md").exists():
print(f"Error: No SKILL.md found at {skill_path}", file=sys.stderr)
sys.exit(1)
name, _, _ = parse_skill_md(skill_path)
# Set up live report path
if args.report != "none":
if args.report == "auto":
timestamp = time.strftime("%Y%m%d_%H%M%S")
live_report_path = Path(tempfile.gettempdir()) / f"skill_description_report_{skill_path.name}_{timestamp}.html"
else:
live_report_path = Path(args.report)
# Open the report immediately so the user can watch
live_report_path.write_text("<html><body><h1>Starting optimization loop...</h1><meta http-equiv='refresh' content='5'></body></html>")
webbrowser.open(str(live_report_path))
else:
live_report_path = None
# Determine output directory (create before run_loop so logs can be written)
if args.results_dir:
timestamp = time.strftime("%Y-%m-%d_%H%M%S")
results_dir = Path(args.results_dir) / timestamp
results_dir.mkdir(parents=True, exist_ok=True)
else:
results_dir = None
log_dir = results_dir / "logs" if results_dir else None
output = run_loop(
eval_set=eval_set,
skill_path=skill_path,
description_override=args.description,
num_workers=args.num_workers,
timeout=args.timeout,
max_iterations=args.max_iterations,
runs_per_query=args.runs_per_query,
trigger_threshold=args.trigger_threshold,
holdout=args.holdout,
model=args.model,
verbose=args.verbose,
live_report_path=live_report_path,
log_dir=log_dir,
)
# Save JSON output
json_output = json.dumps(output, indent=2)
print(json_output)
if results_dir:
(results_dir / "results.json").write_text(json_output)
# Write final HTML report (without auto-refresh)
if live_report_path:
live_report_path.write_text(generate_html(output, auto_refresh=False, skill_name=name))
print(f"\nReport: {live_report_path}", file=sys.stderr)
if results_dir and live_report_path:
(results_dir / "report.html").write_text(generate_html(output, auto_refresh=False, skill_name=name))
if results_dir:
print(f"Results saved to: {results_dir}", file=sys.stderr)
if __name__ == "__main__":
main()

View File

@ -0,0 +1,47 @@
"""Shared utilities for skill-creator scripts."""
from pathlib import Path
def parse_skill_md(skill_path: Path) -> tuple[str, str, str]:
"""Parse a SKILL.md file, returning (name, description, full_content)."""
content = (skill_path / "SKILL.md").read_text()
lines = content.split("\n")
if lines[0].strip() != "---":
raise ValueError("SKILL.md missing frontmatter (no opening ---)")
end_idx = None
for i, line in enumerate(lines[1:], start=1):
if line.strip() == "---":
end_idx = i
break
if end_idx is None:
raise ValueError("SKILL.md missing frontmatter (no closing ---)")
name = ""
description = ""
frontmatter_lines = lines[1:end_idx]
i = 0
while i < len(frontmatter_lines):
line = frontmatter_lines[i]
if line.startswith("name:"):
name = line[len("name:"):].strip().strip('"').strip("'")
elif line.startswith("description:"):
value = line[len("description:"):].strip()
# Handle YAML multiline indicators (>, |, >-, |-)
if value in (">", "|", ">-", "|-"):
continuation_lines: list[str] = []
i += 1
while i < len(frontmatter_lines) and (frontmatter_lines[i].startswith(" ") or frontmatter_lines[i].startswith("\t")):
continuation_lines.append(frontmatter_lines[i].strip())
i += 1
description = " ".join(continuation_lines)
continue
else:
description = value.strip('"').strip("'")
i += 1
return name, description, content

View File

@ -11,15 +11,6 @@ body:
Please provide a minimal reproducible case so maintainers can triage quickly.
Do not include personal/sensitive data; redact and anonymize all logs/payloads.
- type: input
id: summary
attributes:
label: Summary
description: One-line description of the problem.
placeholder: zeroclaw daemon exits immediately when ...
validations:
required: true
- type: dropdown
id: component
attributes:
@ -83,13 +74,13 @@ body:
id: impact
attributes:
label: Impact
description: Who is affected, how often, and practical consequences.
description: Who is affected, how often, and practical consequences (optional but helps triage).
placeholder: |
Affected users: ...
Frequency: always/intermittent
Consequence: ...
validations:
required: true
required: false
- type: textarea
id: logs
@ -112,9 +103,10 @@ body:
id: rust
attributes:
label: Rust version
description: Required for runtime/build bugs; optional for docs/config issues.
placeholder: rustc 1.xx.x
validations:
required: true
required: false
- type: input
id: os
@ -142,7 +134,5 @@ body:
options:
- label: I reproduced this on the latest master branch or latest release.
required: true
- label: I redacted secrets/tokens from logs.
required: true
- label: I removed personal identifiers and replaced identity-specific data with neutral placeholders.
- label: I redacted secrets, tokens, and personal data from all submitted content.
required: true

View File

@ -42,10 +42,10 @@ body:
id: non_goals
attributes:
label: Non-goals / out of scope
description: Clarify what should not be included in the first iteration.
description: Clarify what should not be included in the first iteration (optional but helps scope discussion).
placeholder: No UI changes, no cross-provider dynamic adaptation in v1.
validations:
required: true
required: false
- type: textarea
id: alternatives
@ -60,31 +60,31 @@ body:
id: acceptance
attributes:
label: Acceptance criteria
description: What outcomes would make this request complete?
description: What outcomes would make this request complete? (optional — can be defined during triage)
placeholder: |
- Config key is documented and validated
- Runtime path uses configured retry budget
- Regression tests cover fallback and invalid config
validations:
required: true
required: false
- type: textarea
id: architecture
attributes:
label: Architecture impact
description: Which subsystem(s) are affected?
description: Which subsystem(s) are affected? (optional — maintainers will assess during triage)
placeholder: providers/, channels/, memory/, runtime/, security/, docs/ ...
validations:
required: true
required: false
- type: textarea
id: risk
attributes:
label: Risk and rollback
description: Main risk + how to disable/revert quickly.
description: Main risk + how to disable/revert quickly (optional — can be defined during planning).
placeholder: Risk is ... rollback is ...
validations:
required: true
required: false
- type: dropdown
id: breaking

View File

@ -5,7 +5,7 @@ updates:
directory: "/"
schedule:
interval: daily
target-branch: dev
target-branch: master
open-pull-requests-limit: 3
labels:
- "dependencies"
@ -21,7 +21,7 @@ updates:
directory: "/"
schedule:
interval: daily
target-branch: dev
target-branch: master
open-pull-requests-limit: 1
labels:
- "ci"
@ -38,7 +38,7 @@ updates:
directory: "/"
schedule:
interval: daily
target-branch: dev
target-branch: master
open-pull-requests-limit: 1
labels:
- "ci"

View File

@ -10,21 +10,8 @@ Subdirectories are not valid locations for workflow entry files.
Repository convention:
1. Keep runnable workflow entry files at `.github/workflows/` root.
2. Keep workflow-only helper scripts under `.github/workflows/scripts/`.
3. Keep cross-tooling/local CI scripts under `scripts/ci/` when they are used outside Actions.
2. Keep cross-tooling/local CI scripts under `dev/` or `scripts/ci/` when used outside Actions.
Workflow behavior documentation in this directory:
- `.github/workflows/main-branch-flow.md`
Current workflow helper scripts:
- `.github/workflows/scripts/ci_workflow_owner_approval.js`
- `.github/workflows/scripts/ci_license_file_owner_guard.js`
- `.github/workflows/scripts/lint_feedback.js`
- `.github/workflows/scripts/pr_auto_response_contributor_tier.js`
- `.github/workflows/scripts/pr_auto_response_labeled_routes.js`
- `.github/workflows/scripts/pr_check_status_nudge.js`
- `.github/workflows/scripts/pr_intake_checks.js`
- `.github/workflows/scripts/pr_labeler.js`
- `.github/workflows/scripts/test_benchmarks_pr_comment.js`
- `.github/workflows/master-branch-flow.md`

140
.github/workflows/checks-on-pr.yml vendored Normal file
View File

@ -0,0 +1,140 @@
name: Quality Gate
on:
pull_request:
branches: [master]
concurrency:
group: checks-${{ github.event.pull_request.number }}
cancel-in-progress: true
permissions:
contents: read
env:
CARGO_TERM_COLOR: always
CARGO_INCREMENTAL: 0
jobs:
lint:
name: Lint
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: dtolnay/rust-toolchain@631a55b12751854ce901bb631d5902ceb48146f7 # stable
with:
toolchain: 1.92.0
components: rustfmt, clippy
- uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
- name: Ensure web/dist placeholder exists
run: mkdir -p web/dist && touch web/dist/.gitkeep
- name: Check formatting
run: cargo fmt --all -- --check
- name: Clippy
run: cargo clippy --all-targets -- -D warnings
test:
name: Test
runs-on: ubuntu-latest
timeout-minutes: 30
steps:
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: dtolnay/rust-toolchain@631a55b12751854ce901bb631d5902ceb48146f7 # stable
with:
toolchain: 1.92.0
- uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
- name: Ensure web/dist placeholder exists
run: mkdir -p web/dist && touch web/dist/.gitkeep
- name: Install mold linker
run: |
sudo apt-get update -qq
sudo apt-get install -y mold
- name: Install cargo-nextest
run: curl -LsSf https://get.nexte.st/latest/linux | tar zxf - -C ${CARGO_HOME:-~/.cargo}/bin
- name: Run tests
run: cargo nextest run --locked
env:
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER: clang
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS: "-C link-arg=-fuse-ld=mold"
build:
name: Build ${{ matrix.target }}
runs-on: ${{ matrix.os }}
timeout-minutes: 40
strategy:
fail-fast: false
matrix:
include:
- os: ubuntu-latest
target: x86_64-unknown-linux-gnu
- os: macos-14
target: aarch64-apple-darwin
steps:
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: dtolnay/rust-toolchain@631a55b12751854ce901bb631d5902ceb48146f7 # stable
with:
toolchain: 1.92.0
targets: ${{ matrix.target }}
- uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
- name: Install mold linker
if: runner.os == 'Linux'
run: |
sudo apt-get update -qq
sudo apt-get install -y mold
- name: Ensure web/dist placeholder exists
run: mkdir -p web/dist && touch web/dist/.gitkeep
- name: Build release
shell: bash
run: cargo build --release --locked --target ${{ matrix.target }}
env:
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER: clang
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS: "-C link-arg=-fuse-ld=mold"
security:
name: Security Audit
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: dtolnay/rust-toolchain@631a55b12751854ce901bb631d5902ceb48146f7 # stable
with:
toolchain: 1.92.0
- uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
- name: Install cargo-audit
run: cargo install cargo-audit --locked
- name: Install cargo-deny
run: cargo install cargo-deny --locked
- name: Audit dependencies
run: cargo audit
- name: Check licenses and sources
run: cargo deny check licenses sources
# Composite status check — branch protection only needs to require this
# single job instead of tracking every matrix leg individually.
gate:
name: CI Required Gate
if: always()
needs: [lint, test, build, security]
runs-on: ubuntu-latest
steps:
- name: Check upstream job results
run: |
if [[ "${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') }}" == "true" ]]; then
echo "::error::One or more upstream jobs failed or were cancelled"
exit 1
fi

View File

@ -1,75 +0,0 @@
name: CI
on:
pull_request:
branches: [master]
concurrency:
group: ci-${{ github.event.pull_request.number }}
cancel-in-progress: true
permissions:
contents: read
env:
CARGO_TERM_COLOR: always
CARGO_INCREMENTAL: 0
jobs:
test:
name: Test
runs-on: ubuntu-latest
timeout-minutes: 30
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
with:
toolchain: 1.92.0
- uses: Swatinem/rust-cache@v2
- name: Install mold linker
run: |
sudo apt-get update -qq
sudo apt-get install -y mold
- name: Install cargo-nextest
run: curl -LsSf https://get.nexte.st/latest/linux | tar zxf - -C ${CARGO_HOME:-~/.cargo}/bin
- name: Run tests
run: cargo nextest run --locked
env:
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER: clang
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS: "-C link-arg=-fuse-ld=mold"
build:
name: Build ${{ matrix.target }}
runs-on: ${{ matrix.os }}
timeout-minutes: 40
strategy:
fail-fast: false
matrix:
include:
- os: ubuntu-latest
target: x86_64-unknown-linux-gnu
- os: macos-14
target: aarch64-apple-darwin
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
with:
toolchain: 1.92.0
targets: ${{ matrix.target }}
- uses: Swatinem/rust-cache@v2
- name: Install mold linker
if: runner.os == 'Linux'
run: |
sudo apt-get update -qq
sudo apt-get install -y mold
- name: Build release
shell: bash
run: cargo build --release --locked --target ${{ matrix.target }}
env:
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER: clang
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS: "-C link-arg=-fuse-ld=mold"

View File

@ -1,4 +1,4 @@
name: CI Full Matrix
name: Cross-Platform Build
on:
workflow_dispatch:
@ -11,8 +11,28 @@ env:
CARGO_INCREMENTAL: 0
jobs:
web:
name: Build Web Dashboard
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
cache: npm
cache-dependency-path: web/package-lock.json
- name: Build web dashboard
run: cd web && npm ci && npm run build
- uses: actions/upload-artifact@v4
with:
name: web-dist
path: web/dist/
retention-days: 1
build:
name: Build ${{ matrix.target }}
needs: [web]
runs-on: ${{ matrix.os }}
timeout-minutes: 40
strategy:
@ -29,14 +49,19 @@ jobs:
- os: windows-latest
target: x86_64-pc-windows-msvc
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: dtolnay/rust-toolchain@631a55b12751854ce901bb631d5902ceb48146f7 # stable
with:
toolchain: 1.92.0
targets: ${{ matrix.target }}
- uses: Swatinem/rust-cache@v2
- uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
if: runner.os != 'Windows'
- uses: actions/download-artifact@v4
with:
name: web-dist
path: web/dist/
- name: Install cross compiler
if: matrix.cross_compiler
run: |

View File

@ -4,9 +4,9 @@ This document explains what runs when code is proposed to `master` and released.
Use this with:
- [`docs/ci-map.md`](../../docs/ci-map.md)
- [`docs/pr-workflow.md`](../../docs/pr-workflow.md)
- [`docs/release-process.md`](../../docs/release-process.md)
- [`docs/ci-map.md`](../../docs/contributing/ci-map.md)
- [`docs/pr-workflow.md`](../../docs/contributing/pr-workflow.md)
- [`docs/release-process.md`](../../docs/contributing/release-process.md)
## Branching Model
@ -14,174 +14,74 @@ ZeroClaw uses a single default branch: `master`. All contributor PRs target `mas
Current maintainers with PR approval authority: `theonlyhennygod` and `jordanthejet`.
## Active Workflows
| File | Trigger | Purpose |
| --- | --- | --- |
| `checks-on-pr.yml` | `pull_request``master` | Lint + test + build + security audit on every PR |
| `cross-platform-build-manual.yml` | `workflow_dispatch` | Full platform build matrix (manual) |
| `release-beta-on-push.yml` | `push``master` | Beta release on every master commit |
| `release-stable-manual.yml` | `workflow_dispatch` | Stable release (manual, version-gated) |
## Event Summary
| Event | Main workflows |
| Event | Workflows triggered |
| --- | --- |
| PR activity (`pull_request_target`) | `pr-intake-checks.yml`, `pr-labeler.yml`, `pr-auto-response.yml` |
| PR activity (`pull_request`) | `ci-run.yml`, `sec-audit.yml`, plus path-scoped workflows |
| Push to `master` | `ci-run.yml`, `sec-audit.yml`, plus path-scoped workflows |
| Tag push (`v*`) | `pub-release.yml` publish mode, `pub-docker-img.yml` publish job |
| Scheduled/manual | `pub-release.yml` verification mode, `pub-homebrew-core.yml` (manual), `sec-codeql.yml`, `feature-matrix.yml`, `test-fuzz.yml`, `pr-check-stale.yml`, `pr-check-status.yml`, `sync-contributors.yml`, `test-benchmarks.yml`, `test-e2e.yml` |
## Runtime and Docker Matrix
Observed averages below are from recent completed runs (sampled from GitHub Actions on February 17, 2026). Values are directional, not SLA.
| Workflow | Typical trigger in main flow | Avg runtime | Docker build? | Docker run? | Docker push? |
| --- | --- | ---:| --- | --- | --- |
| `pr-intake-checks.yml` | PR open/update (`pull_request_target`) | 14.5s | No | No | No |
| `pr-labeler.yml` | PR open/update (`pull_request_target`) | 53.7s | No | No | No |
| `pr-auto-response.yml` | PR/issue automation | 24.3s | No | No | No |
| `ci-run.yml` | PR + push to `master` | 74.7s | No | No | No |
| `sec-audit.yml` | PR + push to `master` | 127.2s | No | No | No |
| `workflow-sanity.yml` | Workflow-file changes | 34.2s | No | No | No |
| `pr-label-policy-check.yml` | Label policy/automation changes | 14.7s | No | No | No |
| `pub-docker-img.yml` (`pull_request`) | Docker build-input PR changes | 240.4s | Yes | Yes | No |
| `pub-docker-img.yml` (`push`) | tag push `v*` | 139.9s | Yes | No | Yes |
| `pub-release.yml` | Tag push `v*` (publish) + manual/scheduled verification (no publish) | N/A in recent sample | No | No | No |
| `pub-homebrew-core.yml` | Manual workflow dispatch only | N/A in recent sample | No | No | No |
Notes:
1. `pub-docker-img.yml` is the only workflow in the main PR/push path that builds Docker images.
2. Container runtime verification (`docker run`) occurs in PR smoke only.
3. Container registry push occurs on tag pushes (`v*`) only.
4. `ci-run.yml` "Build (Smoke)" builds Rust binaries, not Docker images.
| PR opened or updated against `master` | `checks-on-pr.yml` |
| Push to `master` (including after merge) | `release-beta-on-push.yml` |
| Manual dispatch | `cross-platform-build-manual.yml`, `release-stable-manual.yml` |
## Step-By-Step
### 1) PR from branch in this repository -> `master`
### 1) PR → `master`
1. Contributor opens or updates PR against `master`.
2. `pull_request_target` automation runs (typical runtime):
- `pr-intake-checks.yml` posts intake warnings/errors.
- `pr-labeler.yml` sets size/risk/scope labels.
- `pr-auto-response.yml` runs first-interaction and label routes.
3. `pull_request` CI workflows start:
- `ci-run.yml`
- `sec-audit.yml`
- path-scoped workflows if matching files changed:
- `pub-docker-img.yml` (Docker build-input paths only)
- `workflow-sanity.yml` (workflow files only)
- `pr-label-policy-check.yml` (label-policy files only)
4. In `ci-run.yml`, `changes` computes:
- `docs_only`
- `docs_changed`
- `rust_changed`
- `workflow_changed`
5. `build` runs for Rust-impacting changes.
6. On PRs, full lint/test/docs checks run when PR has label `ci:full`:
- `lint`
- `lint-strict-delta`
- `test`
- `docs-quality`
7. If `.github/workflows/**` changed, `workflow-owner-approval` must pass.
8. `lint-feedback` posts actionable comment if lint/docs gates fail.
9. `CI Required Gate` aggregates results to final pass/fail.
10. Maintainer (`theonlyhennygod` or `jordanthejet`) merges PR once checks and review policy are satisfied.
11. Merge emits a `push` event on `master` (see scenario 3).
1. Contributor opens or updates a PR against `master`.
2. `checks-on-pr.yml` starts:
- `lint` job: runs `cargo fmt --check` and `cargo clippy -D warnings`.
- `test` job: runs `cargo nextest run --locked` on `ubuntu-latest` with Rust 1.92.0 and mold linker.
- `build` job (matrix): compiles release binary on `x86_64-unknown-linux-gnu` and `aarch64-apple-darwin`.
- `security` job: runs `cargo audit` and `cargo deny check licenses sources`.
- Concurrency group cancels in-progress runs for the same PR on new pushes.
3. All jobs must pass before merge.
4. Maintainer (`theonlyhennygod` or `jordanthejet`) merges PR once checks and review policy are satisfied.
5. Merge emits a `push` event on `master` (see section 2).
### 2) PR from fork -> `master`
### 2) Push to `master` (including after merge)
1. External contributor opens PR from `fork/<branch>` into `zeroclaw:master`.
2. Immediately on `opened`:
- `pull_request_target` workflows start with base-repo context and base-repo token:
- `pr-intake-checks.yml`
- `pr-labeler.yml`
- `pr-auto-response.yml`
- `pull_request` workflows are queued for the fork head commit:
- `ci-run.yml`
- `sec-audit.yml`
- path-scoped workflows (`pub-docker-img.yml`, `workflow-sanity.yml`, `pr-label-policy-check.yml`) if changed files match.
3. Fork-specific permission behavior in `pull_request` workflows:
- token is restricted (read-focused), so jobs that try to write PR comments/status extras can be limited.
- secrets from the base repo are not exposed to fork PR `pull_request` jobs.
4. Approval gate possibility:
- if Actions settings require maintainer approval for fork workflows, the `pull_request` run stays in `action_required`/waiting state until approved.
5. Event fan-out after labeling:
- `pr-labeler.yml` and manual label changes emit `labeled`/`unlabeled` events.
- those events retrigger `pull_request_target` automation (`pr-labeler.yml` and `pr-auto-response.yml`), creating extra run volume/noise.
6. When contributor pushes new commits to fork branch (`synchronize`):
- reruns: `pr-intake-checks.yml`, `pr-labeler.yml`, `ci-run.yml`, `sec-audit.yml`, and matching path-scoped PR workflows.
- does not rerun `pr-auto-response.yml` unless label/open events occur.
7. `ci-run.yml` execution details for fork PR:
- `changes` computes `docs_only`, `docs_changed`, `rust_changed`, `workflow_changed`.
- `build` runs for Rust-impacting changes.
- `lint`/`lint-strict-delta`/`test`/`docs-quality` run on PR when `ci:full` label exists.
- `workflow-owner-approval` runs when `.github/workflows/**` changed.
- `CI Required Gate` emits final pass/fail for the PR head.
8. Fork PR merge blockers to check first when diagnosing stalls:
- run approval pending for fork workflows.
- `workflow-owner-approval` failing on workflow-file changes.
- `CI Required Gate` failure caused by upstream jobs.
- repeated `pull_request_target` reruns from label churn causing noisy signals.
9. After merge, normal `push` workflows on `master` execute (scenario 3).
1. Commit reaches `master`.
2. `release-beta-on-push.yml` (Release Beta) starts:
- `version` job: computes beta tag as `v{cargo_version}-beta.{run_number}`.
- `build` job (matrix, 4 targets): `x86_64-linux`, `aarch64-linux`, `aarch64-darwin`, `x86_64-windows`.
- `publish` job: generates `SHA256SUMS`, creates a GitHub pre-release with all artifacts. Artifact retention: 7 days.
- `docker` job: builds multi-platform image (`linux/amd64,linux/arm64`) and pushes to `ghcr.io` with `:beta` and the versioned beta tag.
3. This runs on every push to `master` without filtering. Every merged PR produces a beta pre-release.
### 3) Push to `master` (including after merge)
### 3) Stable Release (manual)
1. Commit reaches `master` (usually from a merged PR).
2. `ci-run.yml` runs on `push`.
3. `sec-audit.yml` runs on `push`.
4. Path-filtered workflows run only if touched files match their filters.
5. In `ci-run.yml`, push behavior differs from PR behavior:
- Rust path: `lint`, `lint-strict-delta`, `test`, `build` are expected.
- Docs/non-rust paths: fast-path behavior applies.
6. `CI Required Gate` computes overall push result.
1. Maintainer runs `release-stable-manual.yml` via `workflow_dispatch` with a version input (e.g. `0.2.0`).
2. `validate` job checks:
- Input matches semver `X.Y.Z` format.
- `Cargo.toml` version matches input exactly.
- Tag `vX.Y.Z` does not already exist on the remote.
3. `build` job (matrix, same 4 targets as beta): compiles release binary.
4. `publish` job: generates `SHA256SUMS`, creates a stable GitHub Release (not pre-release). Artifact retention: 14 days.
5. `docker` job: pushes to `ghcr.io` with `:latest` and `:vX.Y.Z`.
## Docker Publish Logic
### 4) Full Platform Build (manual)
Workflow: `.github/workflows/pub-docker-img.yml`
1. Maintainer runs `cross-platform-build-manual.yml` via `workflow_dispatch`.
2. `build` job (matrix, 3 targets): `aarch64-linux-gnu`, `x86_64-darwin` (macOS 15 Intel), `x86_64-windows-msvc`.
3. Build-only, no tests, no publish. Used to verify cross-compilation on platforms not covered by `checks-on-pr.yml`.
### PR behavior
## Build Targets by Workflow
1. Triggered on `pull_request` to `master` when Docker build-input paths change.
2. Runs `PR Docker Smoke` job:
- Builds local smoke image with Blacksmith builder.
- Verifies container with `docker run ... --version`.
3. Typical runtime in recent sample: ~240.4s.
4. No registry push happens on PR events.
### Push behavior
1. `publish` job runs on tag pushes `v*` only.
2. Workflow trigger includes semantic version tag pushes (`v*`) only.
3. Login to `ghcr.io` uses `${{ github.actor }}` and `${{ secrets.GITHUB_TOKEN }}`.
4. Tag computation includes semantic tag from pushed git tag (`vX.Y.Z`) + SHA tag.
5. Multi-platform publish is used for tag pushes (`linux/amd64,linux/arm64`).
6. Typical runtime in recent sample: ~139.9s.
7. Result: pushed image tags under `ghcr.io/<owner>/<repo>`.
Important: Docker publish requires a `v*` tag push; regular `master` branch pushes do not publish images.
## Release Logic
Workflow: `.github/workflows/pub-release.yml`
1. Trigger modes:
- Tag push `v*` -> publish mode.
- Manual dispatch -> verification-only or publish mode (input-driven).
- Weekly schedule -> verification-only mode.
2. `prepare` resolves release context (`release_ref`, `release_tag`, publish/draft mode) and validates manual publish inputs.
- publish mode enforces `release_tag` == `Cargo.toml` version at the tag commit.
3. `build-release` builds matrix artifacts across Linux/macOS/Windows targets.
4. `verify-artifacts` enforces presence of all expected archives before any publish attempt.
5. In publish mode, workflow generates SBOM (`CycloneDX` + `SPDX`), `SHA256SUMS`, keyless cosign signatures, and verifies GHCR release-tag availability.
6. In publish mode, workflow creates/updates the GitHub Release for the resolved tag and commit-ish.
Manual Homebrew formula flow:
1. Run `.github/workflows/pub-homebrew-core.yml` with `release_tag=vX.Y.Z`.
2. Use `dry_run=true` first to validate formula patch and metadata.
3. Use `dry_run=false` to push from bot fork and open `homebrew-core` PR.
## Merge/Policy Notes
1. Workflow-file changes (`.github/workflows/**`) activate owner-approval gate in `ci-run.yml`.
2. PR lint/test strictness is intentionally controlled by `ci:full` label.
3. `sec-audit.yml` runs on both PR and push, plus scheduled weekly.
4. Some workflows are operational and non-merge-path (`pr-check-stale`, `pr-check-status`, `sync-contributors`, etc.).
5. Workflow-specific JavaScript helpers are organized under `.github/workflows/scripts/`.
| Target | `checks-on-pr.yml` | `cross-platform-build-manual.yml` | `release-beta-on-push.yml` | `release-stable-manual.yml` |
| --- | :---: | :---: | :---: | :---: |
| `x86_64-unknown-linux-gnu` | ✓ | | ✓ | ✓ |
| `aarch64-unknown-linux-gnu` | | ✓ | ✓ | ✓ |
| `aarch64-apple-darwin` | ✓ | | ✓ | ✓ |
| `x86_64-apple-darwin` | | ✓ | | |
| `x86_64-pc-windows-msvc` | | ✓ | ✓ | ✓ |
## Mermaid Diagrams
@ -189,41 +89,42 @@ Manual Homebrew formula flow:
```mermaid
flowchart TD
A["PR opened or updated -> master"] --> B["pull_request_target lane"]
B --> B1["pr-intake-checks.yml"]
B --> B2["pr-labeler.yml"]
B --> B3["pr-auto-response.yml"]
A --> C["pull_request CI lane"]
C --> C1["ci-run.yml"]
C --> C2["sec-audit.yml"]
C --> C3["pub-docker-img.yml (if Docker paths changed)"]
C --> C4["workflow-sanity.yml (if workflow files changed)"]
C --> C5["pr-label-policy-check.yml (if policy files changed)"]
C1 --> D["CI Required Gate"]
D --> E{"Checks + review policy pass?"}
E -->|No| F["PR stays open"]
E -->|Yes| G["Merge PR"]
G --> H["push event on master"]
A["PR opened or updated → master"] --> B["checks-on-pr.yml"]
B --> B0["lint: fmt + clippy"]
B --> B1["test: cargo nextest (ubuntu-latest)"]
B --> B2["build: x86_64-linux + aarch64-darwin"]
B --> B3["security: audit + deny"]
B0 & B1 & B2 & B3 --> C{"Checks pass?"}
C -->|No| D["PR stays open"]
C -->|Yes| E["Maintainer merges"]
E --> F["push event on master"]
```
### Release
### Beta Release (on every master push)
```mermaid
flowchart TD
A["Commit reaches master"] --> B["ci-run.yml"]
A --> C["sec-audit.yml"]
A --> D["path-scoped workflows (if matched)"]
T["Tag push v*"] --> R["pub-release.yml"]
W["Manual/Scheduled release verify"] --> R
T --> P["pub-docker-img.yml publish job"]
R --> R1["Artifacts + SBOM + checksums + signatures + GitHub Release"]
W --> R2["Verification build only (no GitHub Release publish)"]
P --> P1["Push ghcr image tags (version + sha)"]
A["Push to master"] --> B["release-beta-on-push.yml"]
B --> B1["version: compute v{x.y.z}-beta.{N}"]
B1 --> B2["build: 4 targets"]
B2 --> B3["publish: GitHub pre-release + SHA256SUMS"]
B2 --> B4["docker: push ghcr.io :beta + versioned tag"]
```
### Stable Release (manual)
```mermaid
flowchart TD
A["workflow_dispatch: version=X.Y.Z"] --> B["release-stable-manual.yml"]
B --> B1["validate: semver + Cargo.toml + tag uniqueness"]
B1 --> B2["build: 4 targets"]
B2 --> B3["publish: GitHub stable release + SHA256SUMS"]
B2 --> B4["docker: push ghcr.io :latest + :vX.Y.Z"]
```
## Quick Troubleshooting
1. Unexpected skipped jobs: inspect `scripts/ci/detect_change_scope.sh` outputs.
2. Workflow-change PR blocked: verify `WORKFLOW_OWNER_LOGINS` and approvals.
3. Fork PR appears stalled: check whether Actions run approval is pending.
4. Docker not published: confirm a `v*` tag was pushed to the intended commit.
1. **Quality gate failing on PR**: check `lint` job for formatting/clippy issues; check `test` job for test failures; check `build` job for compile errors; check `security` job for audit/deny failures.
2. **Beta release not appearing**: confirm the push landed on `master` (not another branch); check `release-beta-on-push.yml` run status.
3. **Stable release failing at validate**: ensure `Cargo.toml` version matches the input version and the tag does not already exist.
4. **Full matrix build needed**: run `cross-platform-build-manual.yml` manually from the Actions tab.

View File

@ -1,4 +1,4 @@
name: Beta Release
name: Release Beta
on:
push:
@ -9,8 +9,7 @@ concurrency:
cancel-in-progress: false
permissions:
contents: write
packages: write
contents: read
env:
CARGO_TERM_COLOR: always
@ -25,7 +24,7 @@ jobs:
version: ${{ steps.ver.outputs.version }}
tag: ${{ steps.ver.outputs.tag }}
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- name: Compute beta version
id: ver
shell: bash
@ -37,9 +36,28 @@ jobs:
echo "tag=${beta_tag}" >> "$GITHUB_OUTPUT"
echo "Beta release: ${beta_tag}"
web:
name: Build Web Dashboard
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
cache: npm
cache-dependency-path: web/package-lock.json
- name: Build web dashboard
run: cd web && npm ci && npm run build
- uses: actions/upload-artifact@v4
with:
name: web-dist
path: web/dist/
retention-days: 1
build:
name: Build ${{ matrix.target }}
needs: [version]
needs: [version, web]
runs-on: ${{ matrix.os }}
timeout-minutes: 40
strategy:
@ -66,14 +84,19 @@ jobs:
artifact: zeroclaw.exe
ext: zip
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: dtolnay/rust-toolchain@631a55b12751854ce901bb631d5902ceb48146f7 # stable
with:
toolchain: 1.92.0
targets: ${{ matrix.target }}
- uses: Swatinem/rust-cache@v2
- uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
if: runner.os != 'Windows'
- uses: actions/download-artifact@v4
with:
name: web-dist
path: web/dist/
- name: Install cross compiler
if: matrix.cross_compiler
run: |
@ -100,7 +123,7 @@ jobs:
cd target/${{ matrix.target }}/release
7z a ../../../zeroclaw-${{ matrix.target }}.${{ matrix.ext }} ${{ matrix.artifact }}
- uses: actions/upload-artifact@v4
- uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
with:
name: zeroclaw-${{ matrix.target }}
path: zeroclaw-${{ matrix.target }}.${{ matrix.ext }}
@ -110,10 +133,12 @@ jobs:
name: Publish Beta Release
needs: [version, build]
runs-on: ubuntu-latest
permissions:
contents: write
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: actions/download-artifact@v4
- uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
with:
path: artifacts
@ -124,7 +149,7 @@ jobs:
cat SHA256SUMS
- name: Create GitHub Release
uses: softprops/action-gh-release@v2
uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2
with:
tag_name: ${{ needs.version.outputs.tag }}
name: ${{ needs.version.outputs.tag }}
@ -140,19 +165,22 @@ jobs:
needs: [version, build]
runs-on: ubuntu-latest
timeout-minutes: 30
permissions:
contents: read
packages: write
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: docker/setup-buildx-action@v3
- uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
- uses: docker/login-action@v3
- uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3
with:
registry: ${{ env.REGISTRY }}
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build and push
uses: docker/build-push-action@v6
uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
with:
context: .
push: true

View File

@ -1,4 +1,4 @@
name: Promote Release
name: Release Stable
on:
workflow_dispatch:
@ -13,8 +13,7 @@ concurrency:
cancel-in-progress: false
permissions:
contents: write
packages: write
contents: read
env:
CARGO_TERM_COLOR: always
@ -28,7 +27,7 @@ jobs:
outputs:
tag: ${{ steps.check.outputs.tag }}
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- name: Validate semver and Cargo.toml match
id: check
shell: bash
@ -55,9 +54,28 @@ jobs:
echo "tag=${tag}" >> "$GITHUB_OUTPUT"
web:
name: Build Web Dashboard
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
cache: npm
cache-dependency-path: web/package-lock.json
- name: Build web dashboard
run: cd web && npm ci && npm run build
- uses: actions/upload-artifact@v4
with:
name: web-dist
path: web/dist/
retention-days: 1
build:
name: Build ${{ matrix.target }}
needs: [validate]
needs: [validate, web]
runs-on: ${{ matrix.os }}
timeout-minutes: 40
strategy:
@ -84,14 +102,19 @@ jobs:
artifact: zeroclaw.exe
ext: zip
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: dtolnay/rust-toolchain@631a55b12751854ce901bb631d5902ceb48146f7 # stable
with:
toolchain: 1.92.0
targets: ${{ matrix.target }}
- uses: Swatinem/rust-cache@v2
- uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
if: runner.os != 'Windows'
- uses: actions/download-artifact@v4
with:
name: web-dist
path: web/dist/
- name: Install cross compiler
if: matrix.cross_compiler
run: |
@ -118,7 +141,7 @@ jobs:
cd target/${{ matrix.target }}/release
7z a ../../../zeroclaw-${{ matrix.target }}.${{ matrix.ext }} ${{ matrix.artifact }}
- uses: actions/upload-artifact@v4
- uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
with:
name: zeroclaw-${{ matrix.target }}
path: zeroclaw-${{ matrix.target }}.${{ matrix.ext }}
@ -128,10 +151,12 @@ jobs:
name: Publish Stable Release
needs: [validate, build]
runs-on: ubuntu-latest
permissions:
contents: write
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: actions/download-artifact@v4
- uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
with:
path: artifacts
@ -142,7 +167,7 @@ jobs:
cat SHA256SUMS
- name: Create GitHub Release
uses: softprops/action-gh-release@v2
uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2
with:
tag_name: ${{ needs.validate.outputs.tag }}
name: ${{ needs.validate.outputs.tag }}
@ -158,19 +183,22 @@ jobs:
needs: [validate, build]
runs-on: ubuntu-latest
timeout-minutes: 30
permissions:
contents: read
packages: write
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
- uses: docker/setup-buildx-action@v3
- uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
- uses: docker/login-action@v3
- uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3
with:
registry: ${{ env.REGISTRY }}
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build and push
uses: docker/build-push-action@v6
uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
with:
context: .
push: true

5
.gitignore vendored
View File

@ -1,5 +1,6 @@
/target
firmware/*/target
web/dist/
*.db
*.db-journal
.DS_Store
@ -29,3 +30,7 @@ venv/
*.pem
credentials.json
.worktrees/
.zeroclaw/*
# Coverage artifacts
lcov.info

14
.vscode/extensions.json vendored Normal file
View File

@ -0,0 +1,14 @@
{
"recommendations": [
"rust-lang.rust-analyzer",
"vadimcn.vscode-lldb",
"serayuzgur.crates",
"bungcip.better-toml",
"usernamehw.errorlens",
"eamodio.gitlens",
"tamasfe.even-better-toml",
"dbaeumer.vscode-eslint",
"oderwat.indent-rainbow",
"ryanluker.vscode-coverage-gutters"
]
}

73
.vscode/launch.json vendored Normal file
View File

@ -0,0 +1,73 @@
{
"version": "0.2.0",
"inputs": [
{
"id": "testName",
"description": "Exact test name to debug (e.g. tests::my_test)",
"type": "promptString",
"default": ""
}
],
"configurations": [
// Runtime
{
"type": "lldb",
"request": "launch",
"name": "Debug: Agent",
"program": "${workspaceFolder}/target/debug/zeroclaw",
"args": ["agent"],
"cwd": "${workspaceFolder}",
"preLaunchTask": "Build: Debug"
},
{
"type": "lldb",
"request": "launch",
"name": "Debug: Gateway",
"program": "${workspaceFolder}/target/debug/zeroclaw",
"args": ["gateway"],
"cwd": "${workspaceFolder}",
"preLaunchTask": "Build: Debug"
},
{
"type": "lldb",
"request": "launch",
"name": "Debug: Daemon",
"program": "${workspaceFolder}/target/debug/zeroclaw",
"args": ["daemon"],
"cwd": "${workspaceFolder}",
"preLaunchTask": "Build: Debug"
},
{
"type": "lldb",
"request": "launch",
"name": "Debug: Status",
"program": "${workspaceFolder}/target/debug/zeroclaw",
"args": ["status"],
"cwd": "${workspaceFolder}",
"preLaunchTask": "Build: Debug"
},
{
"type": "lldb",
"request": "launch",
"name": "Debug: Onboard",
"program": "${workspaceFolder}/target/debug/zeroclaw",
"args": ["onboard"],
"cwd": "${workspaceFolder}",
"preLaunchTask": "Build: Debug"
},
// Test
{
"type": "lldb",
"request": "launch",
"name": "Debug: Test (by name)",
"cargo": {
"args": ["test", "--no-run", "--lib", "--"],
"filter": {
"kind": "lib"
}
},
"args": ["--exact", "${input:testName}", "--nocapture"],
"cwd": "${workspaceFolder}"
}
]
}

22
.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,22 @@
{
"git.autofetch": true,
"git.autofetchPeriod": 90,
"search.exclude": {
"**/target": true
},
"files.watcherExclude": {
"**/target/**": true
},
"[rust]": {
"editor.defaultFormatter": "rust-lang.rust-analyzer"
},
"editor.formatOnSave": true,
"editor.formatOnPaste": true,
"files.autoSave": "afterDelay",
"files.autoSaveDelay": 1000,
"rust-analyzer.check.command": "clippy",
"rust-analyzer.check.extraArgs": ["--all-targets", "--", "-D", "warnings"],
"window.title": "${activeRepositoryBranchName}",
"coverage-gutters.coverageFileNames": ["lcov.info"],
"git.postCommitCommand": "push"
}

133
.vscode/tasks.json vendored Normal file
View File

@ -0,0 +1,133 @@
{
"version": "2.0.0",
"inputs": [
{
"id": "testFilter",
"description": "Test name or filter pattern",
"type": "promptString",
"default": ""
}
],
"tasks": [
// Build
{
"label": "Build: Debug",
"type": "shell",
"command": "cargo",
"args": ["build"],
"group": {
"kind": "build",
"isDefault": true
},
"problemMatcher": ["$rustc"]
},
{
"label": "Build: Release",
"type": "shell",
"command": "cargo",
"args": ["build", "--release"],
"problemMatcher": ["$rustc"]
},
{
"label": "Build: Check (fast)",
"type": "shell",
"command": "cargo",
"args": ["check", "--all-targets"],
"problemMatcher": ["$rustc"]
},
// Lint
{
"label": "Lint: Clippy",
"type": "shell",
"command": "cargo",
"args": ["clippy", "--all-targets", "--", "-D", "warnings"],
"problemMatcher": ["$rustc"]
},
{
"label": "Lint: Format Check",
"type": "shell",
"command": "cargo",
"args": ["fmt", "--all", "--", "--check"],
"problemMatcher": []
},
{
"label": "Lint: Format Fix",
"type": "shell",
"command": "cargo",
"args": ["fmt", "--all"],
"problemMatcher": []
},
// Test
{
"label": "Test: All",
"type": "shell",
"command": "cargo nextest --version >/dev/null 2>&1 || cargo install cargo-nextest && cargo nextest run",
"group": {
"kind": "test",
"isDefault": true
},
"problemMatcher": ["$rustc"]
},
{
"label": "Test: Filtered",
"type": "shell",
"command": "cargo nextest --version >/dev/null 2>&1 || cargo install cargo-nextest && cargo nextest run -E 'test(${input:testFilter})'",
"problemMatcher": ["$rustc"]
},
{
"label": "Test: Coverage Report",
"type": "shell",
"command": "cargo llvm-cov --version >/dev/null 2>&1 || cargo install cargo-llvm-cov && cargo llvm-cov --lcov --output-path lcov.info",
"problemMatcher": []
},
{
"label": "Test: Benchmarks",
"type": "shell",
"command": "cargo",
"args": ["bench"],
"problemMatcher": []
},
// Security
{
"label": "Security: Audit",
"type": "shell",
"command": "cargo audit --version >/dev/null 2>&1 || cargo install cargo-audit && cargo audit",
"problemMatcher": []
},
{
"label": "Security: Deny (licenses + sources)",
"type": "shell",
"command": "cargo deny --version >/dev/null 2>&1 || cargo install cargo-deny && cargo deny check licenses sources",
"problemMatcher": []
},
// CI (Docker)
{
"label": "CI: All (Docker)",
"type": "shell",
"command": "./dev/ci.sh",
"args": ["all"],
"problemMatcher": []
},
{
"label": "CI: Lint (Docker)",
"type": "shell",
"command": "./dev/ci.sh",
"args": ["lint"],
"problemMatcher": []
},
{
"label": "CI: Test (Docker)",
"type": "shell",
"command": "./dev/ci.sh",
"args": ["test"],
"problemMatcher": []
},
{
"label": "CI: Security (Docker)",
"type": "shell",
"command": "./dev/ci.sh",
"args": ["security"],
"problemMatcher": []
}
]
}

483
AGENTS.md
View File

@ -1,483 +0,0 @@
# AGENTS.md — ZeroClaw Agent Engineering Protocol
This file defines the default working protocol for coding agents in this repository.
Scope: entire repository.
## 1) Project Snapshot (Read First)
ZeroClaw is a Rust-first autonomous agent runtime optimized for:
- high performance
- high efficiency
- high stability
- high extensibility
- high sustainability
- high security
Core architecture is trait-driven and modular. Most extension work should be done by implementing traits and registering in factory modules.
Key extension points:
- `src/providers/traits.rs` (`Provider`)
- `src/channels/traits.rs` (`Channel`)
- `src/tools/traits.rs` (`Tool`)
- `src/memory/traits.rs` (`Memory`)
- `src/observability/traits.rs` (`Observer`)
- `src/runtime/traits.rs` (`RuntimeAdapter`)
- `src/peripherals/traits.rs` (`Peripheral`) — hardware boards (STM32, RPi GPIO)
## 2) Deep Architecture Observations (Why This Protocol Exists)
These codebase realities should drive every design decision:
1. **Trait + factory architecture is the stability backbone**
- Extension points are intentionally explicit and swappable.
- Most features should be added via trait implementation + factory registration, not cross-cutting rewrites.
2. **Security-critical surfaces are first-class and internet-adjacent**
- `src/gateway/`, `src/security/`, `src/tools/`, `src/runtime/` carry high blast radius.
- Defaults already lean secure-by-default (pairing, bind safety, limits, secret handling); keep it that way.
3. **Performance and binary size are product goals, not nice-to-have**
- `Cargo.toml` release profile and dependency choices optimize for size and determinism.
- Convenience dependencies and broad abstractions can silently regress these goals.
4. **Config and runtime contracts are user-facing API**
- `src/config/schema.rs` and CLI commands are effectively public interfaces.
- Backward compatibility and explicit migration matter.
5. **The project now runs in high-concurrency collaboration mode**
- CI + docs governance + label routing are part of the product delivery system.
- PR throughput is a design constraint; not just a maintainer inconvenience.
## 3) Engineering Principles (Normative)
These principles are mandatory by default. They are not slogans; they are implementation constraints.
### 3.1 KISS (Keep It Simple, Stupid)
**Why here:** Runtime + security behavior must stay auditable under pressure.
Required:
- Prefer straightforward control flow over clever meta-programming.
- Prefer explicit match branches and typed structs over hidden dynamic behavior.
- Keep error paths obvious and localized.
### 3.2 YAGNI (You Aren't Gonna Need It)
**Why here:** Premature features increase attack surface and maintenance burden.
Required:
- Do not add new config keys, trait methods, feature flags, or workflow branches without a concrete accepted use case.
- Do not introduce speculative “future-proof” abstractions without at least one current caller.
- Keep unsupported paths explicit (error out) rather than adding partial fake support.
### 3.3 DRY + Rule of Three
**Why here:** Naive DRY can create brittle shared abstractions across providers/channels/tools.
Required:
- Duplicate small, local logic when it preserves clarity.
- Extract shared utilities only after repeated, stable patterns (rule-of-three).
- When extracting, preserve module boundaries and avoid hidden coupling.
### 3.4 SRP + ISP (Single Responsibility + Interface Segregation)
**Why here:** Trait-driven architecture already encodes subsystem boundaries.
Required:
- Keep each module focused on one concern.
- Extend behavior by implementing existing narrow traits whenever possible.
- Avoid fat interfaces and “god modules” that mix policy + transport + storage.
### 3.5 Fail Fast + Explicit Errors
**Why here:** Silent fallback in agent runtimes can create unsafe or costly behavior.
Required:
- Prefer explicit `bail!`/errors for unsupported or unsafe states.
- Never silently broaden permissions/capabilities.
- Document fallback behavior when fallback is intentional and safe.
### 3.6 Secure by Default + Least Privilege
**Why here:** Gateway/tools/runtime can execute actions with real-world side effects.
Required:
- Deny-by-default for access and exposure boundaries.
- Never log secrets, raw tokens, or sensitive payloads.
- Keep network/filesystem/shell scope as narrow as possible unless explicitly justified.
### 3.7 Determinism + Reproducibility
**Why here:** Reliable CI and low-latency triage depend on deterministic behavior.
Required:
- Prefer reproducible commands and locked dependency behavior in CI-sensitive paths.
- Keep tests deterministic (no flaky timing/network dependence without guardrails).
- Ensure local validation commands map to CI expectations.
### 3.8 Reversibility + Rollback-First Thinking
**Why here:** Fast recovery is mandatory under high PR volume.
Required:
- Keep changes easy to revert (small scope, clear blast radius).
- For risky changes, define rollback path before merge.
- Avoid mixed mega-patches that block safe rollback.
## 4) Repository Map (High-Level)
- `src/main.rs` — CLI entrypoint and command routing
- `src/lib.rs` — module exports and shared command enums
- `src/config/` — schema + config loading/merging
- `src/agent/` — orchestration loop
- `src/gateway/` — webhook/gateway server
- `src/security/` — policy, pairing, secret store
- `src/memory/` — markdown/sqlite memory backends + embeddings/vector merge
- `src/providers/` — model providers and resilient wrapper
- `src/channels/` — Telegram/Discord/Slack/etc channels
- `src/tools/` — tool execution surface (shell, file, memory, browser)
- `src/peripherals/` — hardware peripherals (STM32, RPi GPIO); see `docs/hardware-peripherals-design.md`
- `src/runtime/` — runtime adapters (currently native)
- `docs/` — task-oriented documentation system (hubs, unified TOC, references, operations, security proposals, multilingual guides)
- `.github/` — CI, templates, automation workflows
## 4.1 Documentation System Contract (Required)
Treat documentation as a first-class product surface, not a post-merge artifact.
Canonical entry points:
- root READMEs: `README.md`, `README.zh-CN.md`, `README.ja.md`, `README.ru.md`, `README.fr.md`, `README.vi.md`
- docs hubs: `docs/README.md`, `docs/README.zh-CN.md`, `docs/README.ja.md`, `docs/README.ru.md`, `docs/README.fr.md`, `docs/i18n/vi/README.md`
- unified TOC: `docs/SUMMARY.md`
Supported locales (current contract):
- `en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`
Collection indexes (category navigation):
- `docs/getting-started/README.md`
- `docs/reference/README.md`
- `docs/operations/README.md`
- `docs/security/README.md`
- `docs/hardware/README.md`
- `docs/contributing/README.md`
- `docs/project/README.md`
Runtime-contract references (must track behavior changes):
- `docs/commands-reference.md`
- `docs/providers-reference.md`
- `docs/channels-reference.md`
- `docs/config-reference.md`
- `docs/operations-runbook.md`
- `docs/troubleshooting.md`
- `docs/one-click-bootstrap.md`
Required docs governance rules:
- Keep README/hub top navigation and quick routes intuitive and non-duplicative.
- Keep entry-point parity across all supported locales (`en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`) when changing navigation architecture.
- If a change touches docs IA, runtime-contract references, or user-facing wording in shared docs, perform i18n follow-through for currently supported locales in the same PR:
- Update locale navigation links (`README*`, `docs/README*`, `docs/SUMMARY.md`).
- Update localized runtime-contract docs where equivalents exist (at minimum `commands-reference`, `config-reference`, `troubleshooting` for `fr` and `vi`).
- For Vietnamese, treat `docs/i18n/vi/**` as canonical. Keep `docs/*.<locale>.md` compatibility shims aligned if present.
- Keep proposal/roadmap docs explicitly labeled; avoid mixing proposal text into runtime-contract docs.
- Keep project snapshots date-stamped and immutable once superseded by a newer date.
## 5) Risk Tiers by Path (Review Depth Contract)
Use these tiers when deciding validation depth and review rigor.
- **Low risk**: docs/chore/tests-only changes
- **Medium risk**: most `src/**` behavior changes without boundary/security impact
- **High risk**: `src/security/**`, `src/runtime/**`, `src/gateway/**`, `src/tools/**`, `.github/workflows/**`, access-control boundaries
When uncertain, classify as higher risk.
## 6) Agent Workflow (Required)
1. **Read before write**
- Inspect existing module, factory wiring, and adjacent tests before editing.
2. **Define scope boundary**
- One concern per PR; avoid mixed feature+refactor+infra patches.
3. **Implement minimal patch**
- Apply KISS/YAGNI/DRY rule-of-three explicitly.
4. **Validate by risk tier**
- Docs-only: lightweight checks.
- Code/risky changes: full relevant checks and focused scenarios.
5. **Document impact**
- Update docs/PR notes for behavior, risk, side effects, and rollback.
- If CLI/config/provider/channel behavior changed, update corresponding runtime-contract references.
- If docs entry points changed, keep all supported locale README/docs-hub navigation aligned (`en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`).
6. **Respect queue hygiene**
- If stacked PR: declare `Depends on #...`.
- If replacing old PR: declare `Supersedes #...`.
### 6.1 Branch / Commit / PR Flow (Required)
All contributors (human or agent) must follow the same collaboration flow:
- Create and work from a non-`master` branch.
- Commit changes to that branch with clear, scoped commit messages.
- Open a PR to `master`; do not push directly to `master`.
- Wait for required checks and review outcomes before merging.
- Merge via PR controls (squash/rebase/merge as repository policy allows).
- Branch deletion after merge is optional; long-lived branches are allowed when intentionally maintained.
### 6.2 Worktree Workflow (Required for Multi-Track Agent Work)
Use Git worktrees to isolate concurrent agent/human tracks safely and predictably:
- Use one worktree per active branch/PR stream to avoid cross-task contamination.
- Keep each worktree on a single branch; do not mix unrelated edits in one worktree.
- Run validation commands inside the corresponding worktree before commit/PR.
- Name worktrees clearly by scope (for example: `wt/ci-hardening`, `wt/provider-fix`) and remove stale worktrees when no longer needed.
- PR checkpoint rules from section 6.1 still apply to worktree-based development.
### 6.3 Code Naming Contract (Required)
Apply these naming rules for all code changes unless a subsystem has a stronger existing pattern.
- Use Rust standard casing consistently: modules/files `snake_case`, types/traits/enums `PascalCase`, functions/variables `snake_case`, constants/statics `SCREAMING_SNAKE_CASE`.
- Name types and modules by domain role, not implementation detail (for example `DiscordChannel`, `SecurityPolicy`, `MemoryStore` over vague names like `Manager`/`Helper`).
- Keep trait implementer naming explicit and predictable: `<ProviderName>Provider`, `<ChannelName>Channel`, `<ToolName>Tool`, `<BackendName>Memory`.
- Keep factory registration keys stable, lowercase, and user-facing (for example `"openai"`, `"discord"`, `"shell"`), and avoid alias sprawl without migration need.
- Name tests by behavior/outcome (`<subject>_<expected_behavior>`) and keep fixture identifiers neutral/project-scoped.
- If identity-like naming is required in tests/examples, use ZeroClaw-native labels only (`ZeroClawAgent`, `zeroclaw_user`, `zeroclaw_node`).
### 6.4 Architecture Boundary Contract (Required)
Use these rules to keep the trait/factory architecture stable under growth.
- Extend capabilities by adding trait implementations + factory wiring first; avoid cross-module rewrites for isolated features.
- Keep dependency direction inward to contracts: concrete integrations depend on trait/config/util layers, not on other concrete integrations.
- Avoid creating cross-subsystem coupling (for example provider code importing channel internals, tool code mutating gateway policy directly).
- Keep module responsibilities single-purpose: orchestration in `agent/`, transport in `channels/`, model I/O in `providers/`, policy in `security/`, execution in `tools/`.
- Introduce new shared abstractions only after repeated use (rule-of-three), with at least one real caller in current scope.
- For config/schema changes, treat keys as public contract: document defaults, compatibility impact, and migration/rollback path.
## 7) Change Playbooks
### 7.1 Adding a Provider
- Implement `Provider` in `src/providers/`.
- Register in `src/providers/mod.rs` factory.
- Add focused tests for factory wiring and error paths.
- Avoid provider-specific behavior leaks into shared orchestration code.
### 7.2 Adding a Channel
- Implement `Channel` in `src/channels/`.
- Keep `send`, `listen`, `health_check`, typing semantics consistent.
- Cover auth/allowlist/health behavior with tests.
### 7.3 Adding a Tool
- Implement `Tool` in `src/tools/` with strict parameter schema.
- Validate and sanitize all inputs.
- Return structured `ToolResult`; avoid panics in runtime path.
### 7.4 Adding a Peripheral
- Implement `Peripheral` in `src/peripherals/`.
- Peripherals expose `tools()` — each tool delegates to the hardware (GPIO, sensors, etc.).
- Register board type in config schema if needed.
- See `docs/hardware-peripherals-design.md` for protocol and firmware notes.
### 7.5 Security / Runtime / Gateway Changes
- Include threat/risk notes and rollback strategy.
- Add/update tests or validation evidence for failure modes and boundaries.
- Keep observability useful but non-sensitive.
- For `.github/workflows/**` changes, include Actions allowlist impact in PR notes and update `docs/actions-source-policy.md` when sources change.
### 7.6 Docs System / README / IA Changes
- Treat docs navigation as product UX: preserve clear pathing from README -> docs hub -> SUMMARY -> category index.
- Keep top-level nav concise; avoid duplicative links across adjacent nav blocks.
- When runtime surfaces change, update related references (`commands/providers/channels/config/runbook/troubleshooting`).
- Keep multilingual entry-point parity for all supported locales (`en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`) when nav or key wording changes.
- When shared docs wording changes, sync corresponding localized docs for supported locales in the same PR (or explicitly document deferral and follow-up PR).
- For docs snapshots, add new date-stamped files for new sprints rather than rewriting historical context.
## 8) Validation Matrix
Default local checks for code changes:
```bash
cargo fmt --all -- --check
cargo clippy --all-targets -- -D warnings
cargo test
```
Preferred local pre-PR validation path (recommended, not required):
```bash
./dev/ci.sh all
```
Notes:
- Local Docker-based CI is strongly recommended when Docker is available.
- Contributors are not blocked from opening a PR if local Docker CI is unavailable; in that case run the most relevant native checks and document what was run.
Additional expectations by change type:
- **Docs/template-only**:
- run markdown lint and link-integrity checks
- if touching README/docs-hub/SUMMARY/collection indexes, verify EN/ZH/JA/RU navigation parity
- if touching bootstrap docs/scripts, run `bash -n bootstrap.sh scripts/bootstrap.sh scripts/install.sh`
- **Workflow changes**: validate YAML syntax; run workflow lint/sanity checks when available.
- **Security/runtime/gateway/tools**: include at least one boundary/failure-mode validation.
If full checks are impractical, run the most relevant subset and document what was skipped and why.
## 9) Collaboration and PR Discipline
- Follow `.github/pull_request_template.md` fully (including side effects / blast radius).
- Keep PR descriptions concrete: problem, change, non-goals, risk, rollback.
- Use conventional commit titles.
- Prefer small PRs (`size: XS/S/M`) when possible.
- Agent-assisted PRs are welcome, **but contributors remain accountable for understanding what their code will do**.
### 9.1 Privacy/Sensitive Data and Neutral Wording (Required)
Treat privacy and neutrality as merge gates, not best-effort guidelines.
- Never commit personal or sensitive data in code, docs, tests, fixtures, snapshots, logs, examples, or commit messages.
- Prohibited data includes (non-exhaustive): real names, personal emails, phone numbers, addresses, access tokens, API keys, credentials, IDs, and private URLs.
- Use neutral project-scoped placeholders (for example: `user_a`, `test_user`, `project_bot`, `example.com`) instead of real identity data.
- Test names/messages/fixtures must be impersonal and system-focused; avoid first-person or identity-specific language.
- If identity-like context is unavoidable, use ZeroClaw-scoped roles/labels only (for example: `ZeroClawAgent`, `ZeroClawOperator`, `zeroclaw_user`) and avoid real-world personas.
- Recommended identity-safe naming palette (use when identity-like context is required):
- actor labels: `ZeroClawAgent`, `ZeroClawOperator`, `ZeroClawMaintainer`, `zeroclaw_user`
- service/runtime labels: `zeroclaw_bot`, `zeroclaw_service`, `zeroclaw_runtime`, `zeroclaw_node`
- environment labels: `zeroclaw_project`, `zeroclaw_workspace`, `zeroclaw_channel`
- If reproducing external incidents, redact and anonymize all payloads before committing.
- Before push, review `git diff --cached` specifically for accidental sensitive strings and identity leakage.
### 9.2 Superseded-PR Attribution (Required)
When a PR supersedes another contributor's PR and carries forward substantive code or design decisions, preserve authorship explicitly.
- In the integrating commit message, add one `Co-authored-by: Name <email>` trailer per superseded contributor whose work is materially incorporated.
- Use a GitHub-recognized email (`<login@users.noreply.github.com>` or the contributor's verified commit email) so attribution is rendered correctly.
- Keep trailers on their own lines after a blank line at commit-message end; never encode them as escaped `\\n` text.
- In the PR body, list superseded PR links and briefly state what was incorporated from each.
- If no actual code/design was incorporated (only inspiration), do not use `Co-authored-by`; give credit in PR notes instead.
### 9.3 Superseded-PR PR Template (Recommended)
When superseding multiple PRs, use a consistent title/body structure to reduce reviewer ambiguity.
- Recommended title format: `feat(<scope>): unify and supersede #<pr_a>, #<pr_b> [and #<pr_n>]`
- If this is docs/chore/meta only, keep the same supersede suffix and use the appropriate conventional-commit type.
- In the PR body, include the following template (fill placeholders, remove non-applicable lines):
```md
## Supersedes
- #<pr_a> by @<author_a>
- #<pr_b> by @<author_b>
- #<pr_n> by @<author_n>
## Integrated Scope
- From #<pr_a>: <what was materially incorporated>
- From #<pr_b>: <what was materially incorporated>
- From #<pr_n>: <what was materially incorporated>
## Attribution
- Co-authored-by trailers added for materially incorporated contributors: Yes/No
- If No, explain why (for example: no direct code/design carry-over)
## Non-goals
- <explicitly list what was not carried over>
## Risk and Rollback
- Risk: <summary>
- Rollback: <revert commit/PR strategy>
```
### 9.4 Superseded-PR Commit Template (Recommended)
When a commit unifies or supersedes prior PR work, use a deterministic commit message layout so attribution is machine-parsed and reviewer-friendly.
- Keep one blank line between message sections, and exactly one blank line before trailer lines.
- Keep each trailer on its own line; do not wrap, indent, or encode as escaped `\n` text.
- Add one `Co-authored-by` trailer per materially incorporated contributor, using GitHub-recognized email.
- If no direct code/design is carried over, omit `Co-authored-by` and explain attribution in the PR body instead.
```text
feat(<scope>): unify and supersede #<pr_a>, #<pr_b> [and #<pr_n>]
<one-paragraph summary of integrated outcome>
Supersedes:
- #<pr_a> by @<author_a>
- #<pr_b> by @<author_b>
- #<pr_n> by @<author_n>
Integrated scope:
- <subsystem_or_feature_a>: from #<pr_x>
- <subsystem_or_feature_b>: from #<pr_y>
Co-authored-by: <Name A> <login_a@users.noreply.github.com>
Co-authored-by: <Name B> <login_b@users.noreply.github.com>
```
Reference docs:
- `CONTRIBUTING.md`
- `docs/README.md`
- `docs/SUMMARY.md`
- `docs/docs-inventory.md`
- `docs/commands-reference.md`
- `docs/providers-reference.md`
- `docs/channels-reference.md`
- `docs/config-reference.md`
- `docs/operations-runbook.md`
- `docs/troubleshooting.md`
- `docs/one-click-bootstrap.md`
- `docs/pr-workflow.md`
- `docs/reviewer-playbook.md`
- `docs/ci-map.md`
- `docs/actions-source-policy.md`
## 10) Anti-Patterns (Do Not)
- Do not add heavy dependencies for minor convenience.
- Do not silently weaken security policy or access constraints.
- Do not add speculative config/feature flags “just in case”.
- Do not mix massive formatting-only changes with functional changes.
- Do not modify unrelated modules “while here”.
- Do not bypass failing checks without explicit explanation.
- Do not hide behavior-changing side effects in refactor commits.
- Do not include personal identity or sensitive information in test data, examples, docs, or commits.
## 11) Handoff Template (Agent -> Agent / Maintainer)
When handing off work, include:
1. What changed
2. What did not change
3. Validation run and results
4. Remaining risks / unknowns
5. Next recommended action
## 12) Vibe Coding Guardrails
When working in fast iterative mode:
- Keep each iteration reversible (small commits, clear rollback).
- Validate assumptions with code search before implementing.
- Prefer deterministic behavior over clever shortcuts.
- Do not “ship and hope” on security-sensitive paths.
- If uncertain, leave a concrete TODO with verification context, not a hidden guess.

1
AGENTS.md Symbolic link
View File

@ -0,0 +1 @@
CLAUDE.md

View File

@ -64,4 +64,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
- Workspace escape prevention
- Forbidden system path protection (`/etc`, `/root`, `~/.ssh`)
[0.1.0]: https://github.com/theonlyhennygod/zeroclaw/releases/tag/v0.1.0
[0.1.0]: https://github.com/zeroclaw-labs/zeroclaw/releases/tag/v0.1.0

475
CLAUDE.md
View File

@ -1,20 +1,26 @@
# CLAUDE.md — ZeroClaw Agent Engineering Protocol
# CLAUDE.md — ZeroClaw
This file defines the default working protocol for Claude agents in this repository.
Scope: entire repository.
## Commands
## 1) Project Snapshot (Read First)
```bash
cargo fmt --all -- --check
cargo clippy --all-targets -- -D warnings
cargo test
```
ZeroClaw is a Rust-first autonomous agent runtime optimized for:
Full pre-PR validation (recommended):
- high performance
- high efficiency
- high stability
- high extensibility
- high sustainability
- high security
```bash
./dev/ci.sh all
```
Core architecture is trait-driven and modular. Most extension work should be done by implementing traits and registering in factory modules.
Docs-only changes: run markdown lint and link-integrity checks. If touching bootstrap scripts: `bash -n install.sh`.
## Project Snapshot
ZeroClaw is a Rust-first autonomous agent runtime optimized for performance, efficiency, stability, extensibility, sustainability, and security.
Core architecture is trait-driven and modular. Extend by implementing traits and registering in factory modules.
Key extension points:
@ -26,111 +32,7 @@ Key extension points:
- `src/runtime/traits.rs` (`RuntimeAdapter`)
- `src/peripherals/traits.rs` (`Peripheral`) — hardware boards (STM32, RPi GPIO)
## 2) Deep Architecture Observations (Why This Protocol Exists)
These codebase realities should drive every design decision:
1. **Trait + factory architecture is the stability backbone**
- Extension points are intentionally explicit and swappable.
- Most features should be added via trait implementation + factory registration, not cross-cutting rewrites.
2. **Security-critical surfaces are first-class and internet-adjacent**
- `src/gateway/`, `src/security/`, `src/tools/`, `src/runtime/` carry high blast radius.
- Defaults already lean secure-by-default (pairing, bind safety, limits, secret handling); keep it that way.
3. **Performance and binary size are product goals, not nice-to-have**
- `Cargo.toml` release profile and dependency choices optimize for size and determinism.
- Convenience dependencies and broad abstractions can silently regress these goals.
4. **Config and runtime contracts are user-facing API**
- `src/config/schema.rs` and CLI commands are effectively public interfaces.
- Backward compatibility and explicit migration matter.
5. **The project now runs in high-concurrency collaboration mode**
- CI + docs governance + label routing are part of the product delivery system.
- PR throughput is a design constraint; not just a maintainer inconvenience.
## 3) Engineering Principles (Normative)
These principles are mandatory by default. They are not slogans; they are implementation constraints.
### 3.1 KISS (Keep It Simple, Stupid)
**Why here:** Runtime + security behavior must stay auditable under pressure.
Required:
- Prefer straightforward control flow over clever meta-programming.
- Prefer explicit match branches and typed structs over hidden dynamic behavior.
- Keep error paths obvious and localized.
### 3.2 YAGNI (You Aren't Gonna Need It)
**Why here:** Premature features increase attack surface and maintenance burden.
Required:
- Do not add new config keys, trait methods, feature flags, or workflow branches without a concrete accepted use case.
- Do not introduce speculative “future-proof” abstractions without at least one current caller.
- Keep unsupported paths explicit (error out) rather than adding partial fake support.
### 3.3 DRY + Rule of Three
**Why here:** Naive DRY can create brittle shared abstractions across providers/channels/tools.
Required:
- Duplicate small, local logic when it preserves clarity.
- Extract shared utilities only after repeated, stable patterns (rule-of-three).
- When extracting, preserve module boundaries and avoid hidden coupling.
### 3.4 SRP + ISP (Single Responsibility + Interface Segregation)
**Why here:** Trait-driven architecture already encodes subsystem boundaries.
Required:
- Keep each module focused on one concern.
- Extend behavior by implementing existing narrow traits whenever possible.
- Avoid fat interfaces and “god modules” that mix policy + transport + storage.
### 3.5 Fail Fast + Explicit Errors
**Why here:** Silent fallback in agent runtimes can create unsafe or costly behavior.
Required:
- Prefer explicit `bail!`/errors for unsupported or unsafe states.
- Never silently broaden permissions/capabilities.
- Document fallback behavior when fallback is intentional and safe.
### 3.6 Secure by Default + Least Privilege
**Why here:** Gateway/tools/runtime can execute actions with real-world side effects.
Required:
- Deny-by-default for access and exposure boundaries.
- Never log secrets, raw tokens, or sensitive payloads.
- Keep network/filesystem/shell scope as narrow as possible unless explicitly justified.
### 3.7 Determinism + Reproducibility
**Why here:** Reliable CI and low-latency triage depend on deterministic behavior.
Required:
- Prefer reproducible commands and locked dependency behavior in CI-sensitive paths.
- Keep tests deterministic (no flaky timing/network dependence without guardrails).
- Ensure local validation commands map to CI expectations.
### 3.8 Reversibility + Rollback-First Thinking
**Why here:** Fast recovery is mandatory under high PR volume.
Required:
- Keep changes easy to revert (small scope, clear blast radius).
- For risky changes, define rollback path before merge.
- Avoid mixed mega-patches that block safe rollback.
## 4) Repository Map (High-Level)
## Repository Map
- `src/main.rs` — CLI entrypoint and command routing
- `src/lib.rs` — module exports and shared command enums
@ -142,59 +44,12 @@ Required:
- `src/providers/` — model providers and resilient wrapper
- `src/channels/` — Telegram/Discord/Slack/etc channels
- `src/tools/` — tool execution surface (shell, file, memory, browser)
- `src/peripherals/` — hardware peripherals (STM32, RPi GPIO); see `docs/hardware-peripherals-design.md`
- `src/peripherals/` — hardware peripherals (STM32, RPi GPIO)
- `src/runtime/` — runtime adapters (currently native)
- `docs/` — task-oriented documentation system (hubs, unified TOC, references, operations, security proposals, multilingual guides)
- `docs/` — topic-based documentation (setup-guides, reference, ops, security, hardware, contributing, maintainers)
- `.github/` — CI, templates, automation workflows
## 4.1 Documentation System Contract (Required)
Treat documentation as a first-class product surface, not a post-merge artifact.
Canonical entry points:
- root READMEs: `README.md`, `README.zh-CN.md`, `README.ja.md`, `README.ru.md`, `README.fr.md`, `README.vi.md`
- docs hubs: `docs/README.md`, `docs/README.zh-CN.md`, `docs/README.ja.md`, `docs/README.ru.md`, `docs/README.fr.md`, `docs/i18n/vi/README.md`
- unified TOC: `docs/SUMMARY.md`
Supported locales (current contract):
- `en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`
Collection indexes (category navigation):
- `docs/getting-started/README.md`
- `docs/reference/README.md`
- `docs/operations/README.md`
- `docs/security/README.md`
- `docs/hardware/README.md`
- `docs/contributing/README.md`
- `docs/project/README.md`
Runtime-contract references (must track behavior changes):
- `docs/commands-reference.md`
- `docs/providers-reference.md`
- `docs/channels-reference.md`
- `docs/config-reference.md`
- `docs/operations-runbook.md`
- `docs/troubleshooting.md`
- `docs/one-click-bootstrap.md`
Required docs governance rules:
- Keep README/hub top navigation and quick routes intuitive and non-duplicative.
- Keep entry-point parity across all supported locales (`en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`) when changing navigation architecture.
- If a change touches docs IA, runtime-contract references, or user-facing wording in shared docs, perform i18n follow-through for currently supported locales in the same PR:
- Update locale navigation links (`README*`, `docs/README*`, `docs/SUMMARY.md`).
- Update localized runtime-contract docs where equivalents exist (at minimum `commands-reference`, `config-reference`, `troubleshooting` for `fr` and `vi`).
- For Vietnamese, treat `docs/i18n/vi/**` as canonical. Keep `docs/*.<locale>.md` compatibility shims aligned if present.
- Keep proposal/roadmap docs explicitly labeled; avoid mixing proposal text into runtime-contract docs.
- Keep project snapshots date-stamped and immutable once superseded by a newer date.
## 5) Risk Tiers by Path (Review Depth Contract)
Use these tiers when deciding validation depth and review rigor.
## Risk Tiers
- **Low risk**: docs/chore/tests-only changes
- **Medium risk**: most `src/**` behavior changes without boundary/security impact
@ -202,282 +57,34 @@ Use these tiers when deciding validation depth and review rigor.
When uncertain, classify as higher risk.
## 6) Agent Workflow (Required)
## Workflow
1. **Read before write**
- Inspect existing module, factory wiring, and adjacent tests before editing.
2. **Define scope boundary**
- One concern per PR; avoid mixed feature+refactor+infra patches.
3. **Implement minimal patch**
- Apply KISS/YAGNI/DRY rule-of-three explicitly.
4. **Validate by risk tier**
- Docs-only: lightweight checks.
- Code/risky changes: full relevant checks and focused scenarios.
5. **Document impact**
- Update docs/PR notes for behavior, risk, side effects, and rollback.
- If CLI/config/provider/channel behavior changed, update corresponding runtime-contract references.
- If docs entry points changed, keep all supported locale README/docs-hub navigation aligned (`en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`).
6. **Respect queue hygiene**
- If stacked PR: declare `Depends on #...`.
- If replacing old PR: declare `Supersedes #...`.
1. **Read before write** — inspect existing module, factory wiring, and adjacent tests before editing.
2. **One concern per PR** — avoid mixed feature+refactor+infra patches.
3. **Implement minimal patch** — no speculative abstractions, no config keys without a concrete use case.
4. **Validate by risk tier** — docs-only: lightweight checks. Code changes: full relevant checks.
5. **Document impact** — update PR notes for behavior, risk, side effects, and rollback.
6. **Queue hygiene** — stacked PR: declare `Depends on #...`. Replacing old PR: declare `Supersedes #...`.
### 6.1 Branch / Commit / PR Flow (Required)
Branch/commit/PR rules:
- Work from a non-`master` branch. Open a PR to `master`; do not push directly.
- Use conventional commit titles. Prefer small PRs (`size: XS/S/M`).
- Follow `.github/pull_request_template.md` fully.
- Never commit secrets, personal data, or real identity information (see `@docs/contributing/pr-discipline.md`).
All contributors (human or agent) must follow the same collaboration flow:
- Create and work from a non-`master` branch.
- Commit changes to that branch with clear, scoped commit messages.
- Open a PR to `master`; do not push directly to `master`.
- Wait for required checks and review outcomes before merging.
- Merge via PR controls (squash/rebase/merge as repository policy allows).
- Branch deletion after merge is optional; long-lived branches are allowed when intentionally maintained.
### 6.2 Worktree Workflow (Required for Multi-Track Agent Work)
Use Git worktrees to isolate concurrent agent/human tracks safely and predictably:
- Use one worktree per active branch/PR stream to avoid cross-task contamination.
- Keep each worktree on a single branch; do not mix unrelated edits in one worktree.
- Run validation commands inside the corresponding worktree before commit/PR.
- Name worktrees clearly by scope (for example: `wt/ci-hardening`, `wt/provider-fix`) and remove stale worktrees when no longer needed.
- PR checkpoint rules from section 6.1 still apply to worktree-based development.
### 6.3 Code Naming Contract (Required)
Apply these naming rules for all code changes unless a subsystem has a stronger existing pattern.
- Use Rust standard casing consistently: modules/files `snake_case`, types/traits/enums `PascalCase`, functions/variables `snake_case`, constants/statics `SCREAMING_SNAKE_CASE`.
- Name types and modules by domain role, not implementation detail (for example `DiscordChannel`, `SecurityPolicy`, `MemoryStore` over vague names like `Manager`/`Helper`).
- Keep trait implementer naming explicit and predictable: `<ProviderName>Provider`, `<ChannelName>Channel`, `<ToolName>Tool`, `<BackendName>Memory`.
- Keep factory registration keys stable, lowercase, and user-facing (for example `"openai"`, `"discord"`, `"shell"`), and avoid alias sprawl without migration need.
- Name tests by behavior/outcome (`<subject>_<expected_behavior>`) and keep fixture identifiers neutral/project-scoped.
- If identity-like naming is required in tests/examples, use ZeroClaw-native labels only (`ZeroClawAgent`, `zeroclaw_user`, `zeroclaw_node`).
### 6.4 Architecture Boundary Contract (Required)
Use these rules to keep the trait/factory architecture stable under growth.
- Extend capabilities by adding trait implementations + factory wiring first; avoid cross-module rewrites for isolated features.
- Keep dependency direction inward to contracts: concrete integrations depend on trait/config/util layers, not on other concrete integrations.
- Avoid creating cross-subsystem coupling (for example provider code importing channel internals, tool code mutating gateway policy directly).
- Keep module responsibilities single-purpose: orchestration in `agent/`, transport in `channels/`, model I/O in `providers/`, policy in `security/`, execution in `tools/`.
- Introduce new shared abstractions only after repeated use (rule-of-three), with at least one real caller in current scope.
- For config/schema changes, treat keys as public contract: document defaults, compatibility impact, and migration/rollback path.
## 7) Change Playbooks
### 7.1 Adding a Provider
- Implement `Provider` in `src/providers/`.
- Register in `src/providers/mod.rs` factory.
- Add focused tests for factory wiring and error paths.
- Avoid provider-specific behavior leaks into shared orchestration code.
### 7.2 Adding a Channel
- Implement `Channel` in `src/channels/`.
- Keep `send`, `listen`, `health_check`, typing semantics consistent.
- Cover auth/allowlist/health behavior with tests.
### 7.3 Adding a Tool
- Implement `Tool` in `src/tools/` with strict parameter schema.
- Validate and sanitize all inputs.
- Return structured `ToolResult`; avoid panics in runtime path.
### 7.4 Adding a Peripheral
- Implement `Peripheral` in `src/peripherals/`.
- Peripherals expose `tools()` — each tool delegates to the hardware (GPIO, sensors, etc.).
- Register board type in config schema if needed.
- See `docs/hardware-peripherals-design.md` for protocol and firmware notes.
### 7.5 Security / Runtime / Gateway Changes
- Include threat/risk notes and rollback strategy.
- Add/update tests or validation evidence for failure modes and boundaries.
- Keep observability useful but non-sensitive.
- For `.github/workflows/**` changes, include Actions allowlist impact in PR notes and update `docs/actions-source-policy.md` when sources change.
### 7.6 Docs System / README / IA Changes
- Treat docs navigation as product UX: preserve clear pathing from README -> docs hub -> SUMMARY -> category index.
- Keep top-level nav concise; avoid duplicative links across adjacent nav blocks.
- When runtime surfaces change, update related references (`commands/providers/channels/config/runbook/troubleshooting`).
- Keep multilingual entry-point parity for all supported locales (`en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`) when nav or key wording changes.
- When shared docs wording changes, sync corresponding localized docs for supported locales in the same PR (or explicitly document deferral and follow-up PR).
- For docs snapshots, add new date-stamped files for new sprints rather than rewriting historical context.
## 8) Validation Matrix
Default local checks for code changes:
```bash
cargo fmt --all -- --check
cargo clippy --all-targets -- -D warnings
cargo test
```
Preferred local pre-PR validation path (recommended, not required):
```bash
./dev/ci.sh all
```
Notes:
- Local Docker-based CI is strongly recommended when Docker is available.
- Contributors are not blocked from opening a PR if local Docker CI is unavailable; in that case run the most relevant native checks and document what was run.
Additional expectations by change type:
- **Docs/template-only**:
- run markdown lint and link-integrity checks
- if touching README/docs-hub/SUMMARY/collection indexes, verify EN/ZH/JA/RU navigation parity
- if touching bootstrap docs/scripts, run `bash -n bootstrap.sh scripts/bootstrap.sh scripts/install.sh`
- **Workflow changes**: validate YAML syntax; run workflow lint/sanity checks when available.
- **Security/runtime/gateway/tools**: include at least one boundary/failure-mode validation.
If full checks are impractical, run the most relevant subset and document what was skipped and why.
## 9) Collaboration and PR Discipline
- Follow `.github/pull_request_template.md` fully (including side effects / blast radius).
- Keep PR descriptions concrete: problem, change, non-goals, risk, rollback.
- Use conventional commit titles.
- Prefer small PRs (`size: XS/S/M`) when possible.
- Agent-assisted PRs are welcome, **but contributors remain accountable for understanding what their code will do**.
### 9.1 Privacy/Sensitive Data and Neutral Wording (Required)
Treat privacy and neutrality as merge gates, not best-effort guidelines.
- Never commit personal or sensitive data in code, docs, tests, fixtures, snapshots, logs, examples, or commit messages.
- Prohibited data includes (non-exhaustive): real names, personal emails, phone numbers, addresses, access tokens, API keys, credentials, IDs, and private URLs.
- Use neutral project-scoped placeholders (for example: `user_a`, `test_user`, `project_bot`, `example.com`) instead of real identity data.
- Test names/messages/fixtures must be impersonal and system-focused; avoid first-person or identity-specific language.
- If identity-like context is unavoidable, use ZeroClaw-scoped roles/labels only (for example: `ZeroClawAgent`, `ZeroClawOperator`, `zeroclaw_user`) and avoid real-world personas.
- Recommended identity-safe naming palette (use when identity-like context is required):
- actor labels: `ZeroClawAgent`, `ZeroClawOperator`, `ZeroClawMaintainer`, `zeroclaw_user`
- service/runtime labels: `zeroclaw_bot`, `zeroclaw_service`, `zeroclaw_runtime`, `zeroclaw_node`
- environment labels: `zeroclaw_project`, `zeroclaw_workspace`, `zeroclaw_channel`
- If reproducing external incidents, redact and anonymize all payloads before committing.
- Before push, review `git diff --cached` specifically for accidental sensitive strings and identity leakage.
### 9.2 Superseded-PR Attribution (Required)
When a PR supersedes another contributor's PR and carries forward substantive code or design decisions, preserve authorship explicitly.
- In the integrating commit message, add one `Co-authored-by: Name <email>` trailer per superseded contributor whose work is materially incorporated.
- Use a GitHub-recognized email (`<login@users.noreply.github.com>` or the contributor's verified commit email) so attribution is rendered correctly.
- Keep trailers on their own lines after a blank line at commit-message end; never encode them as escaped `\\n` text.
- In the PR body, list superseded PR links and briefly state what was incorporated from each.
- If no actual code/design was incorporated (only inspiration), do not use `Co-authored-by`; give credit in PR notes instead.
### 9.3 Superseded-PR PR Template (Recommended)
When superseding multiple PRs, use a consistent title/body structure to reduce reviewer ambiguity.
- Recommended title format: `feat(<scope>): unify and supersede #<pr_a>, #<pr_b> [and #<pr_n>]`
- If this is docs/chore/meta only, keep the same supersede suffix and use the appropriate conventional-commit type.
- In the PR body, include the following template (fill placeholders, remove non-applicable lines):
```md
## Supersedes
- #<pr_a> by @<author_a>
- #<pr_b> by @<author_b>
- #<pr_n> by @<author_n>
## Integrated Scope
- From #<pr_a>: <what was materially incorporated>
- From #<pr_b>: <what was materially incorporated>
- From #<pr_n>: <what was materially incorporated>
## Attribution
- Co-authored-by trailers added for materially incorporated contributors: Yes/No
- If No, explain why (for example: no direct code/design carry-over)
## Non-goals
- <explicitly list what was not carried over>
## Risk and Rollback
- Risk: <summary>
- Rollback: <revert commit/PR strategy>
```
### 9.4 Superseded-PR Commit Template (Recommended)
When a commit unifies or supersedes prior PR work, use a deterministic commit message layout so attribution is machine-parsed and reviewer-friendly.
- Keep one blank line between message sections, and exactly one blank line before trailer lines.
- Keep each trailer on its own line; do not wrap, indent, or encode as escaped `\n` text.
- Add one `Co-authored-by` trailer per materially incorporated contributor, using GitHub-recognized email.
- If no direct code/design is carried over, omit `Co-authored-by` and explain attribution in the PR body instead.
```text
feat(<scope>): unify and supersede #<pr_a>, #<pr_b> [and #<pr_n>]
<one-paragraph summary of integrated outcome>
Supersedes:
- #<pr_a> by @<author_a>
- #<pr_b> by @<author_b>
- #<pr_n> by @<author_n>
Integrated scope:
- <subsystem_or_feature_a>: from #<pr_x>
- <subsystem_or_feature_b>: from #<pr_y>
Co-authored-by: <Name A> <login_a@users.noreply.github.com>
Co-authored-by: <Name B> <login_b@users.noreply.github.com>
```
Reference docs:
- `CONTRIBUTING.md`
- `docs/README.md`
- `docs/SUMMARY.md`
- `docs/docs-inventory.md`
- `docs/commands-reference.md`
- `docs/providers-reference.md`
- `docs/channels-reference.md`
- `docs/config-reference.md`
- `docs/operations-runbook.md`
- `docs/troubleshooting.md`
- `docs/one-click-bootstrap.md`
- `docs/pr-workflow.md`
- `docs/reviewer-playbook.md`
- `docs/ci-map.md`
- `docs/actions-source-policy.md`
## 10) Anti-Patterns (Do Not)
## Anti-Patterns
- Do not add heavy dependencies for minor convenience.
- Do not silently weaken security policy or access constraints.
- Do not add speculative config/feature flags “just in case”.
- Do not add speculative config/feature flags "just in case".
- Do not mix massive formatting-only changes with functional changes.
- Do not modify unrelated modules “while here”.
- Do not modify unrelated modules "while here".
- Do not bypass failing checks without explicit explanation.
- Do not hide behavior-changing side effects in refactor commits.
- Do not include personal identity or sensitive information in test data, examples, docs, or commits.
## 11) Handoff Template (Agent -> Agent / Maintainer)
## Linked References
When handing off work, include:
1. What changed
2. What did not change
3. Validation run and results
4. Remaining risks / unknowns
5. Next recommended action
## 12) Vibe Coding Guardrails
When working in fast iterative mode:
- Keep each iteration reversible (small commits, clear rollback).
- Validate assumptions with code search before implementing.
- Prefer deterministic behavior over clever shortcuts.
- Do not “ship and hope” on security-sensitive paths.
- If uncertain, leave a concrete TODO with verification context, not a hidden guess.
- `@docs/contributing/change-playbooks.md` — adding providers, channels, tools, peripherals; security/gateway changes; architecture boundaries
- `@docs/contributing/pr-discipline.md` — privacy rules, superseded-PR attribution/templates, handoff template
- `@docs/contributing/docs-contract.md` — docs system contract, i18n rules, locale parity

View File

@ -210,20 +210,20 @@ To keep docs useful under high PR volume, we use these rules:
- **Side-effect visibility**: document blast radius, failure modes, and rollback before merge.
- **Automation assists, humans decide**: bots triage and label, but merge accountability stays human.
- **Index-first discoverability**: `docs/README.md` is the first entry point for operational documentation.
- **Template-first authoring**: start new operational docs from `docs/doc-template.md`.
- **Template-first authoring**: start new operational docs from `docs/contributing/doc-template.md`.
### Documentation System Map
| Doc | Primary purpose | When to update |
|---|---|---|
| `docs/README.md` | canonical docs index and taxonomy | add/remove docs or change documentation ownership/navigation |
| `docs/doc-template.md` | standard skeleton for new operational documentation | when required sections or documentation quality bar changes |
| `docs/contributing/doc-template.md` | standard skeleton for new operational documentation | when required sections or documentation quality bar changes |
| `CONTRIBUTING.md` | contributor contract and readiness baseline | contributor expectations or policy changes |
| `docs/pr-workflow.md` | governance logic and merge contract | workflow/risk/merge gate changes |
| `docs/reviewer-playbook.md` | reviewer operating checklist | review depth or triage behavior changes |
| `docs/ci-map.md` | CI ownership and triage entry points | workflow trigger/job ownership changes |
| `docs/network-deployment.md` | runtime deployment and network operating guide | gateway/channel/tunnel/network runtime behavior changes |
| `docs/proxy-agent-playbook.md` | agent-operable proxy runbook and rollback recipes | proxy scope/selector/tooling behavior changes |
| `docs/contributing/pr-workflow.md` | governance logic and merge contract | workflow/risk/merge gate changes |
| `docs/contributing/reviewer-playbook.md` | reviewer operating checklist | review depth or triage behavior changes |
| `docs/contributing/ci-map.md` | CI ownership and triage entry points | workflow trigger/job ownership changes |
| `docs/ops/network-deployment.md` | runtime deployment and network operating guide | gateway/channel/tunnel/network runtime behavior changes |
| `docs/ops/proxy-agent-playbook.md` | agent-operable proxy runbook and rollback recipes | proxy scope/selector/tooling behavior changes |
## PR Definition of Ready (DoR)
@ -237,7 +237,7 @@ Before requesting review, ensure all of the following are true:
- Tests/fixtures/examples use neutral project-scoped wording (no identity-specific or first-person phrasing).
- If identity-like wording is required, use ZeroClaw-centric labels only (for example: `ZeroClawAgent`, `ZeroClawOperator`, `zeroclaw_user`).
- If docs were changed, update `docs/README.md` navigation and reciprocal links with related docs.
- If a new operational doc was added, start from `docs/doc-template.md` and keep risk/rollback/troubleshooting sections where applicable.
- If a new operational doc was added, start from `docs/contributing/doc-template.md` and keep risk/rollback/troubleshooting sections where applicable.
- Linked issue (or rationale for no issue) is included.
## PR Definition of Done (DoD)
@ -265,9 +265,9 @@ When PR traffic is high (especially with AI-assisted contributions), these rules
- **Identity normalization**: when identity traits are unavoidable, use ZeroClaw/project-native roles instead of personal or real-world identities.
- **Supersede hygiene**: if your PR replaces an older open PR, add `Supersedes #...` and request maintainers close the outdated one.
Full maintainer workflow: [`docs/pr-workflow.md`](docs/pr-workflow.md).
CI workflow ownership and triage map: [`docs/ci-map.md`](docs/ci-map.md).
Reviewer operating checklist: [`docs/reviewer-playbook.md`](docs/reviewer-playbook.md).
Full maintainer workflow: [`docs/contributing/pr-workflow.md`](docs/contributing/pr-workflow.md).
CI workflow ownership and triage map: [`docs/contributing/ci-map.md`](docs/contributing/ci-map.md).
Reviewer operating checklist: [`docs/contributing/reviewer-playbook.md`](docs/contributing/reviewer-playbook.md).
## Agent Collaboration Guidance

4
Cargo.lock generated
View File

@ -4797,9 +4797,9 @@ dependencies = [
[[package]]
name = "quinn-proto"
version = "0.11.13"
version = "0.11.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
dependencies = [
"bytes",
"getrandom 0.3.4",

2
NOTICE
View File

@ -17,7 +17,7 @@ License
This software is available under a dual-license model:
1. MIT License — see LICENSE
1. MIT License — see LICENSE-MIT
2. Apache License 2.0 — see LICENSE-APACHE
You may use either license. Contributors grant rights under both.

914
README.ar.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center" dir="rtl">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center" dir="rtl">
<strong>صفر عبء. صفر تنازلات. 100% Rust. 100% محايد.</strong><br>
<strong dir="ltr">⚡️ يعمل على أجهزة بقيمة $10 بأقل من 5MB RAM: ذاكرة أقل بنسبة 99% من OpenClaw وأرخص بنسبة 98% من Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center" dir="rtl">
بني من قبل طلاب وأعضاء مجتمعات هارفارد ومعهد ماساتشوستس للتكنولوجيا وSundai.Club.
</p>
<p align="center" dir="rtl">
🌐 <strong>اللغات:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center" dir="rtl">
<a href="#البدء-السريع">البدء السريع</a> |
<a href="bootstrap.sh">الإعداد بنقرة واحدة</a> |
<a href="docs/README.md">مركز التوثيق</a> |
<a href="docs/SUMMARY.md">فهرس التوثيق</a>
</p>
<p align="center" dir="rtl">
<strong>الوصول السريع:</strong>
<a href="docs/reference/README.md">المرجع</a> ·
<a href="docs/operations/README.md">العمليات</a> ·
<a href="docs/troubleshooting.md">استكشاف الأخطاء</a> ·
<a href="docs/security/README.md">الأمان</a> ·
<a href="docs/hardware/README.md">الأجهزة</a> ·
<a href="docs/contributing/README.md">المساهمة</a>
</p>
<p align="center" dir="rtl">
<strong>بنية تحتية سريعة وخفيفة ومستقلة تمامًا لمساعد الذكاء الاصطناعي</strong><br />
انشر في أي مكان. استبدل أي شيء.
</p>
<p align="center" dir="rtl">
ZeroClaw هو <strong>نظام تشغيل وقت التشغيل</strong> لعمليات العمل الآلية — بنية تحتية تجرد النماذج والأدوات والذاكرة والتنفيذ لبناء وكلاء مرة واحدة وتشغيلهم في أي مكان.
</p>
<p align="center"><code>بنية قائمة على السمات · وقت تشغيل آمن افتراضيًا · موفر/قناة/أداة قابلة للتبديل · كل شيء قابل للتوصيل</code></p>
### 📢 الإعلانات
استخدم هذا الجدول للإشعارات المهمة (تغييرات التوافق، إشعارات الأمان، نوافذ الصيانة، وحجوز الإصدارات).
| التاريخ (UTC) | المستوى | الإشعار | الإجراء |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _حرج_ | **نحن غير مرتبطين** بـ `openagen/zeroclaw` أو `zeroclaw.org`. نطاق `zeroclaw.org` يشير حاليًا إلى الفرع `openagen/zeroclaw`، وهذا النطاق/المستودع ينتحل شخصية موقعنا/مشروعنا الرسمي. | لا تثق بالمعلومات أو الملفات الثنائية أو جمع التبرعات أو الإعلانات من هذه المصادر. استخدم فقط [هذا المستودع](https://github.com/zeroclaw-labs/zeroclaw) وحساباتنا الموثقة على وسائل التواصل الاجتماعي. |
| 2026-02-21 | هم_ | موقعنا الرسمي أصبح متاحًا الآن: [zeroclawlabs.ai](https://zeroclawlabs.ai). شكرًا لصبرك أثناء الانتظار. لا نزال نكتشف محاولات الانتحال: لا تشارك في أي نشاط استثمار/تمويل باسم ZeroClaw إذا لم يتم نشره عبر قنواتنا الرسمية. | استخدم [هذا المستودع](https://github.com/zeroclaw-labs/zeroclaw) كمصدر وحيد للحقيقة. تابع [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21)، [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs)، [Facebook (مجموعة)](https://www.facebook.com/groups/zeroclaw)، [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/)، و[Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) للتحديثات الرسمية. |
| 2026-02-19 | هم_ | قامت Anthropic بتحديث شروط استخدام المصادقة وبيانات الاعتماد في 2026-02-19. مصادقة OAuth (Free، Pro، Max) حصريًا لـ Claude Code و Claude.ai؛ استخدام رموز Claude Free/Pro/Max OAuth في أي منتج أو أداة أو خدمة أخرى (بما في ذلك Agent SDK) غير مسموح به وقد ينتهك شروط استخدام المستهلك. | يرجى تجنب مؤقتًا تكاملات Claude Code OAuth لمنع أي خسارة محتملة. البند الأصلي: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ الميزات
- 🏎️ **وقت تشغيل خفيف افتراضيًا:** عمليات سطر الأوامر الشائعة وأوامر الحالة تعمل ضمن مساحة ذاكرة بضع ميغابايت في إصدارات الإنتاج.
- 💰 **نشر فعال من حيث التكلفة:** مصمم للوحات منخفضة التكلفة وحالات السحابة الصغيرة بدون تبعيات وقت تشغيل ثقيلة.
- ⚡ **بدء تشغيل سريع من البارد:** وقت تشغيل Rust الثنائي الواحد يحافظ على بدء الأوامر والبرامج الخلفية شبه فوري للعمليات اليومية.
- 🌍 **بنية محمولة:** سير عمل ثنائي واحد على ARM و x86 و RISC-V مع موفر/قناة/أداة قابلة للتبديل.
### لماذا تختار الفرق ZeroClaw
- **خفيف افتراضيًا:** ملف Rust ثنائي صغير، بدء تشغيل سريع، بصمة ذاكرة منخفضة.
- **آمن بالتصميم:** الاقتران، الصندوق الرملي الصارم، قوائم السماح الصريحة، نطاق مساحة العمل.
- **قابل للتبديل بالكامل:** الأنظمة الأساسية هي سمات (الموفرون، القنوات، الأدوات، الذاكرة، الأنفاق).
- **لا قفل للمورد:** دعم موفر متوافق مع OpenAI + نقاط نهاية مخصصة قابلة للتوصيل.
## لقطة قياس الأداء (ZeroClaw مقابل OpenClaw، قابلة للتكرار)
قياس أداء سريع على جهاز محلي (macOS arm64، فبراير 2026) مُطبع لأجهزة الحافة بسرعة 0.8 GHz.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **اللغة** | TypeScript | Python | Go | **Rust** |
| **الذاكرة العشوائية** | > 1 غيغابايت | > 100 ميغابايت | < 10 ميغابايت | **< 5 ميغابايت** |
| **بدء التشغيل (نواة 0.8 GHz)** | > 500 ثانية | > 30 ثانية | < 1 ثانية | **< 10 ملي ثانية** |
| **حجم الملف الثنائي** | ~28 ميغابايت (dist) | N/A (Scripts) | ~8 ميغابايت | **3.4 ميغابايت** |
| **التكلفة** | Mac Mini $599 | Linux SBC ~$50 | لوحة Linux $10 | **أي جهاز $10** |
> ملاحظات: تم قياس نتائج ZeroClaw في إصدارات الإنتاج باستخدام `/usr/bin/time -l`. يتطلب OpenClaw وقت تشغيل Node.js (عادةً ~390 ميغابايت من عبء الذاكرة الإضافي)، بينما يتطلب NanoBot وقت تشغيل Python. PicoClaw و ZeroClaw هما ملفات ثنائية ثابتة. أرقام الذاكرة العشوائية أعلاه هي ذاكرة وقت التشغيل؛ متطلبات التجميع في وقت البناء أعلى.
<p align="center">
<img src="zero-claw.jpeg" alt="مقارنة ZeroClaw مقابل OpenClaw" width="800" />
</p>
### قياس محلي قابل للتكرار
قد تتغير ادعاءات قياس الأداء مع تطور الكود وسلاسل الأدوات، لذا قم دائمًا بقياس إصدارك الحالي محليًا:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
عينة مثال (macOS arm64، تم قياسها في 18 فبراير 2026):
- حجم الملف الثنائي للإصدار: `8.8M`
- `zeroclaw --help`: وقت حقيقي حوالي `0.02s`، بصمة ذاكرة قصوى ~`3.9 ميغابايت`
- `zeroclaw status`: وقت حقيقي حوالي `0.01s`، بصمة ذاكرة قصوى ~`4.1 ميغابايت`
## المتطلبات الأساسية
<details>
<summary><strong>Windows</strong></summary>
### Windows — مطلوب
1. **Visual Studio Build Tools** (يوفر رابط MSVC و Windows SDK):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
أثناء التثبيت (أو عبر Visual Studio Installer)، حدد عبء عمل **"تطوير سطح المكتب باستخدام C++"**.
2. **سلسلة أدوات Rust:**
```powershell
winget install Rustlang.Rustup
```
بعد التثبيت، افتح محطة طرفية جديدة وقم بتشغيل `rustup default stable` للتأكد من أن سلسلة الأدوات المستقرة نشطة.
3. **تحقق** من أن كلاهما يعمل:
```powershell
rustc --version
cargo --version
```
### Windows — اختياري
- **Docker Desktop** — مطلوب فقط إذا كنت تستخدم [وقت تشغيل Docker المعزول](#دعم-وقت-التشغيل-الحالي) (`runtime.kind = "docker"`). قم بالتثبيت عبر `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — مطلوب
1. **أدوات البناء الأساسية:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** قم بتثبيت Xcode Command Line Tools: `xcode-select --install`
2. **سلسلة أدوات Rust:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
راجع [rustup.rs](https://rustup.rs) للتفاصيل.
3. **تحقق:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — اختياري
- **Docker** — مطلوب فقط إذا كنت تستخدم [وقت تشغيل Docker المعزول](#دعم-وقت-التشغيل-الحالي) (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** راجع [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** راجع [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** قم بتثبيت Docker Desktop عبر [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## البدء السريع
### الخيار 1: الإعداد الآلي (موصى به)
يقوم نص `bootstrap.sh` بتثبيت Rust ونسخ ZeroClaw وتجميعه وإعداد بيئة التطوير الأولية الخاصة بك:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
سيقوم هذا بـ:
1. تثبيت Rust (إذا لم يكن موجودًا)
2. نسخ مستودع ZeroClaw
3. تجميع ZeroClaw في وضع الإصدار
4. تثبيت `zeroclaw` في `~/.cargo/bin/`
5. إنشاء هيكل مساحة العمل الافتراضية في `~/.zeroclaw/workspace/`
6. إنشاء ملف تكوين بدء التشغيل `~/.zeroclaw/workspace/config.toml`
بعد التمهيد، أعد تحميل shell الخاص بك أو قم بتشغيل `source ~/.cargo/env` لاستخدام أمر `zeroclaw` عالميًا.
### الخيار 2: التثبيت اليدوي
<details>
<summary><strong>انقر لرؤية خطوات التثبيت اليدوي</strong></summary>
```bash
# 1. نسخ المستودع
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. التجميع في وضع الإصدار
cargo build --release --locked
# 3. تثبيت الملف الثنائي
cargo install --path . --locked
# 4. تهيئة مساحة العمل
zeroclaw init
# 5. التحقق من التثبيت
zeroclaw --version
zeroclaw status
```
</details>
### بعد التثبيت
بمجرد التثبيت (عبر التمهيد أو يدويًا)، يجب أن ترى:
```
~/.zeroclaw/workspace/
├── config.toml # التكوين الرئيسي
├── .pairing # أسرار الاقتران (تُنشأ عند التشغيل الأول)
├── logs/ # سجلات البرنامج الخفي/الوكيل
├── skills/ # المهارات المخصصة
└── memory/ # تخزين سياق المحادثة
```
**الخطوات التالية:**
1. قم بتكوين موفري الذكاء الاصطناعي الخاص بك في `~/.zeroclaw/workspace/config.toml`
2. تحقق من [مرجع التكوين](docs/config-reference.md) للخيارات المتقدمة
3. ابدأ الوكيل: `zeroclaw agent start`
4. اختبر عبر قناتك المفضلة (راجع [مرجع القنوات](docs/channels-reference.md))
## التكوين
قم بتحرير `~/.zeroclaw/workspace/config.toml` لتكوين الموفرون والقنوات وسلوك النظام.
### مرجع التكوين السريع
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # أو "sqlite" أو "none"
[runtime]
kind = "native" # أو "docker" (يتطلب Docker)
```
**مستندات المرجع الكاملة:**
- [مرجع التكوين](docs/config-reference.md) — جميع الإعدادات والتحقق والقيم الافتراضية
- [مرجع الموفرون](docs/providers-reference.md) — تكوينات محددة لموفري الذكاء الاصطناعي
- [مرجع القنوات](docs/channels-reference.md) — Telegram و Matrix و Slack و Discord والمزيد
- [العمليات](docs/operations-runbook.md) — المراقبة في الإنتاج وتدوير الأسرار والتوسع
### دعم وقت التشغيل الحالي
يدعم ZeroClaw واجهتين خلفيتين لتنفيذ الكود:
- **`native`** (افتراضي) — تنفيذ العملية المباشر، المسار الأسرع، مثالي للبيئات الموثوقة
- **`docker`** — عزل الحاوية الكامل، سياسات الأمان المحصنة، يتطلب Docker
استخدم `runtime.kind = "docker"` إذا كنت بحاجة إلى صندوق رملي صارم أو عزل الشبكة. راجع [مرجع التكوين](docs/config-reference.md#runtime) للتفاصيل الكاملة.
## الأوامر
```bash
# إدارة مساحة العمل
zeroclaw init # تهيئة مساحة عمل جديدة
zeroclaw status # عرض حالة البرنامج الخفي/الوكيل
zeroclaw config validate # التحقق من بنية وقيم config.toml
# إدارة البرنامج الخفي
zeroclaw daemon start # بدء البرنامج الخفي في الخلفية
zeroclaw daemon stop # إيقاف البرنامج الخفي قيد التشغيل
zeroclaw daemon restart # إعادة تشغيل البرنامج الخفي (إعادة تحميل التكوين)
zeroclaw daemon logs # عرض سجلات البرنامج الخفي
# إدارة الوكيل
zeroclaw agent start # بدء الوكيل (يتطلب تشغيل البرنامج الخفي)
zeroclaw agent stop # إيقاف الوكيل
zeroclaw agent restart # إعادة تشغيل الوكيل (إعادة تحميل التكوين)
# عمليات الاقتران
zeroclaw pairing init # إنشاء سر اقتران جديد
zeroclaw pairing rotate # تدوير سر الاقتران الحالي
# الأنفاق (للتعرض العام)
zeroclaw tunnel start # بدء نفق إلى البرنامج الخفي المحلي
zeroclaw tunnel stop # إيقاف النفق النشط
# التشخيص
zeroclaw doctor # تشغيل فحوصات صحة النظام
zeroclaw version # عرض الإصدار ومعلومات البناء
```
راجع [مرجع الأوامر](docs/commands-reference.md) للخيارات والأمثلة الكاملة.
## البنية
```
┌─────────────────────────────────────────────────────────────────┐
│ القنوات (سمة) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ منسق الوكيل │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ توجيه │ │ السياق │ │ التنفيذ │ │
│ │ الرسائل │ │ الذاكرة │ │ الأداة │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ الموفرون │ │ الذاكرة │ │ الأدوات │
│ (سمة) │ │ (سمة) │ │ (سمة) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ وقت التشغيل (سمة) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**المبادئ الأساسية:**
- كل شيء هو **سمة** — الموفرون والقنوات والأدوات والذاكرة والأنفاق
- القنوات تستدعي المنسق؛ المنسق يستدعي الموفرون + الأدوات
- نظام الذاكرة يدير سياق المحادثة (markdown أو SQLite أو لا شيء)
- وقت التشغيل يجرد تنفيذ الكود (أصلي أو Docker)
- لا قفل للمورد — استبدل Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama بدون تغييرات في الكود
راجع [توثيق البنية](docs/architecture.svg) للرسوم البيانية التفصيلية وتفاصيل التنفيذ.
## الأمثلة
### بوت Telegram
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # معرف مستخدم Telegram الخاص بك
```
ابدأ البرنامج الخفي + الوكيل، ثم أرسل رسالة إلى بوتك على Telegram:
```
/start
مرحباً! هل يمكنك مساعدتي في كتابة نص Python؟
```
يستجيب البوت بكود مُنشأ بالذكاء الاصطناعي، وينفذ الأدوات إذا طُلب، ويحافظ على سياق المحادثة.
### Matrix (تشفير من طرف إلى طرف)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
ادعُ `@zeroclaw:matrix.org` إلى غرفة مشفرة، وسيستجيب البوت بتشفير كامل. راجع [دليل Matrix E2EE](docs/matrix-e2ee-guide.md) لإعداد التحقق من الجهاز.
### متعدد الموفرون
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # التبديل عند خطأ المورد
```
إذا فشل Anthropic أو وصل إلى حد السرعة، يتبادل المنسق تلقائيًا إلى OpenAI.
### ذاكرة مخصصة
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # حذف تلقائي بعد 90 يومًا
```
أو استخدم Markdown للتخزين القابل للقراءة البشرية:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
راجع [مرجع التكوين](docs/config-reference.md#memory) لجميع خيارات الذاكرة.
## دعم الموفرون
| المورد | الحالة | مفتاح API | النماذج المثال |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ مستقر | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ مستقر | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ مستقر | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ مستقر | N/A (محلي) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ مستقر | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ مستقر | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 مخطط | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 مخطط | `COHERE_API_KEY` | TBD |
### نقاط النهاية المخصصة
يدعم ZeroClaw نقاط النهاية المتوافقة مع OpenAI:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
مثال: استخدم [LiteLLM](https://github.com/BerriAI/litellm) كوكيل للوصول إلى أي LLM عبر واجهة OpenAI.
راجع [مرجع الموفرون](docs/providers-reference.md) لتفاصيل التكوين الكاملة.
## دعم القنوات
| القناة | الحالة | المصادقة | ملاحظات |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ مستقر | رمز البوت | دعم كامل بما في ذلك الملفات والصور والأزرار المضمنة |
| **Matrix** | ✅ مستقر | كلمة المرور أو الرمز | دعم E2EE مع التحقق من الجهاز |
| **Slack** | 🚧 مخطط | OAuth أو رمز البوت | يتطلب الوصول إلى مساحة العمل |
| **Discord** | 🚧 مخطط | رمز البوت | يتطلب أذونات النقابة |
| **WhatsApp** | 🚧 مخطط | Twilio أو API الرسمية | يتطلب حساب تجاري |
| **CLI** | ✅ مستقر | لا شيء | واجهة محادثة مباشرة |
| **Web** | 🚧 مخطط | مفتاح API أو OAuth | واجهة دردشة قائمة على المتصفح |
راجع [مرجع القنوات](docs/channels-reference.md) لتعليمات التكوين الكاملة.
## دعم الأدوات
يوفر ZeroClaw أدوات مدمجة لتنفيذ الكود والوصول إلى نظام الملفات واسترجاع الويب:
| الأداة | الوصف | وقت التشغيل المطلوب |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | ينفذ أوامر الصدفة | أصلي أو Docker |
| **python** | ينفذ نصوص Python | Python 3.8+ (أصلي) أو Docker |
| **javascript** | ينفذ كود Node.js | Node.js 18+ (أصلي) أو Docker |
| **filesystem_read** | يقرأ الملفات | أصلي أو Docker |
| **filesystem_write** | يكتب الملفات | أصلي أو Docker |
| **web_fetch** | يجلب محتوى الويب | أصلي أو Docker |
### أمان التنفيذ
- **وقت التشغيل الأصلي** — يعمل كعملية مستخدم البرنامج الخفي، وصول كامل لنظام الملفات
- **وقت تشغيل Docker** — عزل حاوية كامل، أنظمة ملفات وشبكات منفصلة
قم بتكوين سياسة التنفيذ في `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # قائمة سماح صريحة
```
راجع [مرجع التكوين](docs/config-reference.md#runtime) لخيارات الأمان الكاملة.
## النشر
### النشر المحلي (التطوير)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### نشر الخادم (الإنتاج)
استخدم systemd لإدارة البرنامج الخفي والوكيل كخدمات:
```bash
# تثبيت الملف الثنائي
cargo install --path . --locked
# تكوين مساحة العمل
zeroclaw init
# إنشاء ملفات خدمة systemd
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# تمكين وبدء الخدمات
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# التحقق من الحالة
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
راجع [دليل نشر الشبكة](docs/network-deployment.md) لتعليمات نشر الإنتاج الكاملة.
### Docker
```bash
# بناء الصورة
docker build -t zeroclaw:latest .
# تشغيل الحاوية
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
راجع [`Dockerfile`](Dockerfile) لتفاصيل البناء وخيارات التكوين.
### أجهزة الحافة
تم تصميم ZeroClaw للعمل على أجهزة منخفضة الطاقة:
- **Raspberry Pi Zero 2 W** — ~512 ميغابايت ذاكرة عشوائية، نواة ARMv8 واحدة، < $5 تكلفة الأجهزة
- **Raspberry Pi 4/5** — 1 غيغابايت+ ذاكرة عشوائية، متعدد النوى، مثالي لأحمال العمل المتزامنة
- **Orange Pi Zero 2** — ~512 ميغابايت ذاكرة عشوائية، رباعي النواة ARMv8، تكلفة منخفضة جدًا
- **أجهزة SBCs x86 (Intel N100)** — 4-8 غيغابايت ذاكرة عشوائية، بناء سريع، دعم Docker أصلي
راجع [دليل الأجهزة](docs/hardware/README.md) لتعليمات الإعداد الخاصة بالجهاز.
## الأنفاق (التعرض العام)
اعرض البرنامج الخفي ZeroClaw المحلي الخاص بك للشبكة العامة عبر أنفاق آمنة:
```bash
zeroclaw tunnel start --provider cloudflare
```
موفرو الأنفاق المدعومون:
- **Cloudflare Tunnel** — HTTPS مجاني، لا تعرض للمنافذ، دعم متعدد المجالات
- **Ngrok** — إعداد سريع، مجالات مخصصة (خطة مدفوعة)
- **Tailscale** — شبكة شبكية خاصة، لا منفذ عام
راجع [مرجع التكوين](docs/config-reference.md#tunnel) لخيارات التكوين الكاملة.
## الأمان
ينفذ ZeroClaw طبقات متعددة من الأمان:
### الاقتران
يُنشئ البرنامج الخفي سر اقتران عند التشغيل الأول مخزن في `~/.zeroclaw/workspace/.pairing`. يجب على العملاء (الوكيل، CLI) تقديم هذا السر للاتصال.
```bash
zeroclaw pairing rotate # يُنشئ سرًا جديدًا ويبطل القديم
```
### الصندوق الرملي
- **وقت تشغيل Docker** — عزل حاوية كامل مع أنظمة ملفات وشبكات منفصلة
- **وقت التشغيل الأصلي** — يعمل كعملية مستخدم، محدد النطاق في مساحة العمل افتراضيًا
### قوائم السماح
يمكن للقنوات تقييد الوصول حسب معرف المستخدم:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # قائمة سماح صريحة
```
### التشفير
- **Matrix E2EE** — تشفير من طرف إلى طرف كامل مع التحقق من الجهاز
- **نقل TLS** — جميع حركة API والنفق تستخدم HTTPS/TLS
راجع [توثيق الأمان](docs/security/README.md) للسياسات والممارسات الكاملة.
## إمكانية الملاحظة
يسجل ZeroClaw في `~/.zeroclaw/workspace/logs/` افتراضيًا. يتم تخزين السجلات حسب المكون:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # سجلات البرنامج الخفي (بدء التشغيل، طلبات API، الأخطاء)
├── agent.log # سجلات الوكيل (توجيه الرسائل، تنفيذ الأدوات)
├── telegram.log # سجلات خاصة بالقناة (إذا مُكنت)
└── matrix.log # سجلات خاصة بالقناة (إذا مُكنت)
```
### تكوين التسجيل
```toml
[logging]
level = "info" # debug، info، warn، error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # يومي، ساعي، حجم
max_size_mb = 100 # للتدوير القائم على الحجم
retention_days = 30 # حذف تلقائي بعد N يومًا
```
راجع [مرجع التكوين](docs/config-reference.md#logging) لجميع خيارات التسجيل.
### المقاييس (مخطط)
دعم مقاييس Prometheus لمراقبة الإنتاج قريبًا. التتبع في [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## المهارات
يدعم ZeroClaw المهارات المخصصة — وحدات قابلة لإعادة الاستخدام توسع قدرات النظام.
### تعريف المهارة
يتم تخزين المهارات في `~/.zeroclaw/workspace/skills/<skill-name>/` بهذا الهيكل:
```
skills/
└── my-skill/
├── skill.toml # بيانات المهارة (الاسم، الوصف، التبعيات)
├── prompt.md # موجه النظام للذكاء الاصطناعي
└── tools/ # أدوات مخصصة اختيارية
└── my_tool.py
```
### مثال المهارة
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "يبحث في الويب ويلخص النتائج"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
أنت مساعد بحث. عند طلب البحث عن شيء ما:
1. استخدم web_fetch لاسترجاع المحتوى
2. لخص النتائج بتنسيق سهل القراءة
3. استشهد بالمصادر مع عناوين URL
```
### استخدام المهارات
يتم تحميل المهارات تلقائيًا عند بدء تشغيل الوكيل. أشر إليها بالاسم في المحادثات:
```
المستخدم: استخدم مهارة البحث على الويب للعثور على أخبار الذكاء الاصطناعي الأخيرة
البوت: [يحمل مهارة البحث على الويب، ينفذ web_fetch، يلخص النتائج]
```
راجع قسم [المهارات](#المهارات) لتعليمات إنشاء المهارات الكاملة.
## المهارات المفتوحة
يدعم ZeroClaw [Open Skills](https://github.com/openagents-com/open-skills) — نظام معياري ومحايد للمورد لتوسيع قدرات وكلاء الذكاء الاصطناعي.
### تمكين المهارات المفتوحة
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # اختياري
```
يمكنك أيضًا التجاوز في وقت التشغيل باستخدام `ZEROCLAW_OPEN_SKILLS_ENABLED` و `ZEROCLAW_OPEN_SKILLS_DIR`.
## التطوير
```bash
cargo build # بناء التطوير
cargo build --release # بناء الإصدار (codegen-units=1، يعمل على جميع الأجهزة بما في ذلك Raspberry Pi)
cargo build --profile release-fast # بناء أسرع (codegen-units=8، يتطلب 16 غيغابايت+ ذاكرة عشوائية)
cargo test # تشغيل مجموعة الاختبار الكاملة
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # تنسيق
# تشغيل معيار مقارنة SQLite مقابل Markdown
cargo test --test memory_comparison -- --nocapture
```
### خطاف ما قبل الدفع
يقوم خطاف git بتشغيل `cargo fmt --check` و `cargo clippy -- -D warnings` و `cargo test` قبل كل دفع. قم بتمكينه مرة واحدة:
```bash
git config core.hooksPath .githooks
```
### استكشاف أخطاء البناء وإصلاحها (أخطاء OpenSSL على Linux)
إذا واجهت خطأ بناء `openssl-sys`، قم بمزامنة التبعيات وأعد التجميع باستخدام ملف قفل المستودع:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
تم تكوين ZeroClaw لاستخدام `rustls` لتبعيات HTTP/TLS؛ `--locked` يحافظ على الرسم البياني العابر حتمي في البيئات النظيفة.
لتخطي الخطاف عندما تحتاج إلى دفع سريع أثناء التطوير:
```bash
git push --no-verify
```
## التعاون والتوثيق
ابدأ بمركز التوثيق لخريطة قائمة على المهام:
- مركز التوثيق: [`docs/README.md`](docs/README.md)
- فهرس التوثيق الموحد: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- مرجع الأوامر: [`docs/commands-reference.md`](docs/commands-reference.md)
- مرجع التكوين: [`docs/config-reference.md`](docs/config-reference.md)
- مرجع الموفرون: [`docs/providers-reference.md`](docs/providers-reference.md)
- مرجع القنوات: [`docs/channels-reference.md`](docs/channels-reference.md)
- دليل العمليات: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- استكشاف الأخطاء: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- مخزون/تصنيف التوثيق: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- لقطة فرز PR/المشكلة (اعتبارًا من 18 فبراير 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
مراجع التعاون الرئيسية:
- مركز التوثيق: [docs/README.md](docs/README.md)
- قالب التوثيق: [docs/doc-template.md](docs/doc-template.md)
- قائمة تغيير التوثيق: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- مرجع تكوين القنوات: [docs/channels-reference.md](docs/channels-reference.md)
- عمليات غرف Matrix المشفرة: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- دليل المساهمة: [CONTRIBUTING.md](CONTRIBUTING.md)
- سياسة سير عمل PR: [docs/pr-workflow.md](docs/pr-workflow.md)
- دليل المراجع (الفرز + المراجعة العميقة): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- خريطة الملكية وفرز CI: [docs/ci-map.md](docs/ci-map.md)
- سياسة الإفصاح الأمني: [SECURITY.md](SECURITY.md)
للنشر وعمليات وقت التشغيل:
- دليل نشر الشبكة: [docs/network-deployment.md](docs/network-deployment.md)
- دليل وكيل الوكيل: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## دعم ZeroClaw
إذا كان ZeroClaw يساعد عملك وترغب في دعم التطوير المستمر، يمكنك التبرع هنا:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="اشترِ لي قهوة" /></a>
### 🙏 شكر خاص
شكر خالص للمجتمعات والمؤسسات التي تلهم وتغذي هذا العمل مفتوح المصدر:
- **جامعة هارفارد** — لتعزيز الفضول الفكري ودفع حدود ما هو ممكن.
- **MIT** — للدفاع عن المعرفة المفتوحة والمصدر المفتوح والاعتقاد بأن التكنولوجيا يجب أن تكون متاحة للجميع.
- **Sundai Club** — للمجتمع والطاقة والإرادة الدؤوبة لبناء أشياء مهمة.
- **العالم وما بعده** 🌍✨ — لكل مساهم وحالم وباني هناك يجعل المصدر المفتوح قوة للخير. هذا من أجلك.
نحن نبني في المصدر المفتوح لأن أفضل الأفكار تأتي من كل مكان. إذا كنت تقرأ هذا، فأنت جزء منه. مرحبًا. 🦀❤️
## ⚠️ المستودع الرسمي وتحذير الانتحال
**هذا هو مستودع ZeroClaw الرسمي الوحيد:**
> <https://github.com/zeroclaw-labs/zeroclaw>
أي مستودع أو منظمة أو نطاق أو حزمة آخر يدعي أنه "ZeroClaw" أو يلمح إلى الارتباط بـ ZeroClaw Labs هو **غير مصرح به وغير مرتبط بهذا المشروع**. سيتم إدراج الفروع غير المصرح بها المعروفة في [TRADEMARK.md](TRADEMARK.md).
إذا واجهت انتحالًا أو سوء استخدام للعلامة التجارية، يرجى [فتح مشكلة](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## الترخيص
ZeroClaw مرخص بشكل مزدوج لأقصى قدر من الانفتاح وحماية المساهمين:
| الترخيص | حالات الاستخدام |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | مفتوح المصدر، البحث، الأكاديمي، الاستخدام الشخصي |
| [Apache 2.0](LICENSE-APACHE) | حماية براءات الاختراع، المؤسسي، النشر التجاري |
يمكنك اختيار أي من الترخيصين. **يمنح المساهمون تلقائيًا حقوقًا بموجب كليهما** — راجع [CLA.md](CLA.md) لاتفاقية المساهم الكاملة.
### العلامة التجارية
اسم **ZeroClaw** والشعار علامتان تجاريتان مسجلتان لـ ZeroClaw Labs. لا يمنح هذا الترخيص الإذن باستخدامهما للإيحاء بالموافقة أو الارتباط. راجع [TRADEMARK.md](TRADEMARK.md) للاستخدامات المسموح بها والمحظورة.
### حماية المساهمين
- **تحتفظ بحقوق النشر** لمساهماتك
- **منح براءة الاختراع** (Apache 2.0) يحميك من مطالبات براءات الاختراع من مساهمين آخرين
- يتم **نسب مساهماتك بشكل دائم** في تاريخ الالتزامات و [NOTICE](NOTICE)
- لا يتم نقل حقوق العلامة التجارية من خلال المساهمة
## المساهمة
راجع [CONTRIBUTING.md](CONTRIBUTING.md) و [CLA.md](CLA.md). قم بتنفيذ سمة، أرسل PR:
- دليل سير عمل CI: [docs/ci-map.md](docs/ci-map.md)
- `Provider` جديد ← `src/providers/`
- `Channel` جديد ← `src/channels/`
- `Observer` جديد ← `src/observability/`
- `Tool` جديد ← `src/tools/`
- `Memory` جديدة ← `src/memory/`
- `Tunnel` جديد ← `src/tunnel/`
- `Skill` جديدة ← `~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — صفر عبء. صفر تنازلات. انشر في أي مكان. استبدل أي شيء. 🦀
## تاريخ النجوم
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="رسم بياني لتاريخ النجوم" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

179
README.bn.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>শূন্য ওভারহেড। শূন্য আপস। 100% রাস্ট। 100% অজ্ঞেয়বাদী।</strong><br>
⚡️ <strong>$10 হার্ডওয়্যারে <5MB RAM িয় চল: এটি OpenClaw 99% কম ি এব Mac mini 98% সস্ত!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>ভাষা:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## ZeroClaw কী?
ZeroClaw হল একটি হালকা, মিউটেবল এবং এক্সটেনসিবল AI অ্যাসিস্ট্যান্ট ইনফ্রাস্ট্রাকচার যা রাস্টে তৈরি। এটি বিভিন্ন LLM প্রদানকারীদের (Anthropic, OpenAI, Google, Ollama, ইত্যাদি) একটি ইউনিফাইড ইন্টারফেসের মাধ্যমে সংযুক্ত করে এবং একাধিক চ্যানেল (Telegram, Matrix, CLI, ইত্যাদি) সমর্থন করে।
### মূল বৈশিষ্ট্যসমূহ
- **🦀 রাস্টে লেখা**: উচ্চ পারফরম্যান্স, মেমোরি নিরাপত্তা, এবং জিরো-কস্ট অ্যাবস্ট্রাকশন
- **🔌 প্রদানকারী-অজ্ঞেয়বাদী**: OpenAI, Anthropic, Google Gemini, Ollama, এবং অন্যান্য সমর্থন
- **📱 মাল্টি-চ্যানেল**: Telegram, Matrix (E2EE সহ), CLI, এবং অন্যান্য
- **🧠 প্লাগেবল মেমোরি**: SQLite এবং Markdown ব্যাকএন্ড
- **🛠️ এক্সটেন্সিবল টুলস**: সহজেই কাস্টম টুল যোগ করুন
- **🔒 নিরাপত্তা-প্রথম**: রিভার্স-প্রক্সি, গোপনীয়তা-প্রথম ডিজাইন
---
## দ্রুত শুরু
### প্রয়োজনীয়তা
- রাস্ট 1.70+
- একটি LLM প্রদানকারী API কী (Anthropic, OpenAI, ইত্যাদি)
### ইনস্টলেশন
```bash
# রিপোজিটরি ক্লোন করুন
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# বিল্ড করুন
cargo build --release
# চালান
cargo run --release
```
### Docker দিয়ে
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## কনফিগারেশন
ZeroClaw একটি YAML কনফিগারেশন ফাইল ব্যবহার করে। ডিফল্টরূপে, এটি `config.yaml` দেখে।
```yaml
# ডিফল্ট প্রদানকারী
provider: anthropic
# প্রদানকারী কনফিগারেশন
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# মেমোরি কনফিগারেশন
memory:
backend: sqlite
path: data/memory.db
# চ্যানেল কনফিগারেশন
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## ডকুমেন্টেশন
বিস্তারিত ডকুমেন্টেশনের জন্য, দেখুন:
- [ডকুমেন্টেশন হাব](docs/README.md)
- [কমান্ড রেফারেন্স](docs/commands-reference.md)
- [প্রদানকারী রেফারেন্স](docs/providers-reference.md)
- [চ্যানেল রেফারেন্স](docs/channels-reference.md)
- [কনফিগারেশন রেফারেন্স](docs/config-reference.md)
---
## অবদান
অবদান স্বাগত! অনুগ্রহ করে [অবদান গাইড](CONTRIBUTING.md) পড়ুন।
---
## লাইসেন্স
এই প্রজেক্টটি ডুয়াল লাইসেন্সপ্রাপ্ত:
- MIT লাইসেন্স
- Apache লাইসেন্স, সংস্করণ 2.0
বিস্তারিতের জন্য [LICENSE-APACHE](LICENSE-APACHE) এবং [LICENSE-MIT](LICENSE-MIT) দেখুন।
---
## কমিউনিটি
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## স্পনসর
যদি ZeroClaw আপনার জন্য উপযোগী হয়, তবে অনুগ্রহ করে আমাদের একটি কফি কিনতে বিবেচনা করুন:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

914
README.cs.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Nulová režie. Nulové kompromisy. 100% Rust. 100% Agnostický.</strong><br>
⚡️ <strong>Beží na hardwaru za $10 s <5MB RAM: To je o 99% méně paměti než OpenClaw a o 98% levnější než Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Postaveno studenty a členy komunit Harvard, MIT a Sundai.Club.
</p>
<p align="center">
🌐 <strong>Jazyky:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#rychlý-start">Rychlý Start</a> |
<a href="bootstrap.sh">Jedno-klikové nastavení</a> |
<a href="docs/README.md">Dokumentační Centrum</a> |
<a href="docs/SUMMARY.md">Obsah Dokumentace</a>
</p>
<p align="center">
<strong>Rychlý přístup:</strong>
<a href="docs/reference/README.md">Reference</a> ·
<a href="docs/operations/README.md">Operace</a> ·
<a href="docs/troubleshooting.md">Řešení problémů</a> ·
<a href="docs/security/README.md">Bezpečnost</a> ·
<a href="docs/hardware/README.md">Hardware</a> ·
<a href="docs/contributing/README.md">Příspívání</a>
</p>
<p align="center">
<strong>Rychlá, lehká a plně autonomní AI asistent infrastruktura</strong><br />
Nasazujte kdekoliv. Měňte cokoliv.
</p>
<p align="center">
ZeroClaw je <strong>operační systém runtime</strong> pro workflow agentů — infrastruktura která abstrahuje modely, nástroje, paměť a provádění pro stavbu agentů jednou a spouštění kdekoliv.
</p>
<p align="center"><code>Architektura založená na traitech · bezpečný runtime defaultně · vyměnitelný poskytovatel/kanál/nástroj · vše je připojitelné</code></p>
### 📢 Oznámení
Použijte tuto tabulku pro důležitá oznámení (změny kompatibility, bezpečnostní upozornění, servisní okna a blokování verzí).
| Datum (UTC) | Úroveň | Oznámení | Akce |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Kritické_ | **Nejsme propojeni** s `openagen/zeroclaw` nebo `zeroclaw.org`. Doména `zeroclaw.org` aktuálně směřuje na fork `openagen/zeroclaw`, a tato doména/repoziťář se vydává za náš oficiální web/projekt. | Nevěřte informacím, binárním souborům, fundraisingu nebo oznámením z těchto zdrojů. Používejte pouze [tento repoziťář](https://github.com/zeroclaw-labs/zeroclaw) a naše ověřené sociální účty. |
| 2026-02-21 | _Důležité_ | Náš oficiální web je nyní online: [zeroclawlabs.ai](https://zeroclawlabs.ai). Děkujeme za trpělivost během čekání. Stále detekujeme pokusy o vydávání se: neúčastněte žádné investiční/fundraisingové aktivity ve jménu ZeroClaw pokud není publikována přes naše oficiální kanály. | Používejte [tento repoziťář](https://github.com/zeroclaw-labs/zeroclaw) jako jediný zdroj pravdy. Sledujte [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (skupina)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), a [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) pro oficiální aktualizace. |
| 2026-02-19 | _Důležité_ | Anthropic aktualizoval podmínky použití autentizace a přihlašovacích údajů dne 2026-02-19. OAuth autentizace (Free, Pro, Max) je výhradně pro Claude Code a Claude.ai; použití Claude Free/Pro/Max OAuth tokenů v jakémkoliv jiném produktu, nástroji nebo službě (včetně Agent SDK) není povoleno a může porušit Podmínky použití spotřebitele. | Prosím dočasně se vyhněte Claude Code OAuth integracím pro předcházení potenciálním ztrátám. Původní klauzule: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Funkce
- 🏎️ **Lehký Runtime Defaultně:** Běžné CLI workflowy a stavové příkazy běží v paměťovém prostoru několika megabytů v produkčních buildech.
- 💰 **Cenově efektivní nasazení:** Navrženo pro nízkonákladové desky a malé cloud instance bez těžkých runtime závislostí.
- ⚡ **Rychlé studené starty:** Single-binary Rust runtime udržuje start příkazů a daemonů téměř okamžitý pro denní operace.
- 🌍 **Přenosná architektura:** Single-binary workflow na ARM, x86 a RISC-V s vyměnitelným poskytovatelem/kanálem/nástrojem.
### Proč týmy volí ZeroClaw
- **Lehký defaultně:** malý Rust binary, rychlý start, nízká paměťová stopa.
- **Bezpečný designem:** párování, striktní sandboxing, explicitní allowlisty, workspace scope.
- **Plně vyměnitelné:** jádrové systémy jsou traity (poskytovatelé, kanály, nástroje, paměť, tunely).
- **Žádné vendor lock-in:** OpenAI-kompatibilní podpora poskytovatele + připojitelné vlastní endpointy.
## Benchmark Snapshot (ZeroClaw vs OpenClaw, Reprodukovatelné)
Rychlý benchmark na lokálním stroji (macOS arm64, únor 2026) normalizovaný pro 0.8 GHz edge hardware.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Jazyk** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Start (0.8 GHz jádro)** | > 500s | > 30s | < 1s | **< 10ms** |
| **Velikost Binary** | ~28 MB (dist) | N/A (Skripty) | ~8 MB | **3.4 MB** |
| **Náklady** | Mac Mini $599 | Linux SBC ~$50 | Linux deska $10 | **Jakýkoliv hardware $10** |
> Poznámky: Výsledky ZeroClaw jsou měřeny na produkčních buildech pomocí `/usr/bin/time -l`. OpenClaw vyžaduje Node.js runtime (typicky ~390 MB dodatečného paměťového režijního nákladu), zatímco NanoBot vyžaduje Python runtime. PicoClaw a ZeroClaw jsou statická binaria. Výše uvedené RAM čísla jsou runtime paměť; build-time kompilační požadavky jsou vyšší.
<p align="center">
<img src="zero-claw.jpeg" alt="Porovnání ZeroClaw vs OpenClaw" width="800" />
</p>
### Reprodukovatelné lokální měření
Benchmark tvrzení se mohou měnit jak se kód a toolchainy vyvíjejí, takže vždy měřte svůj aktuální build lokálně:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Ukázková vzorka (macOS arm64, měřeno 18. února 2026):
- Velikost release binary: `8.8M`
- `zeroclaw --help`: reálný čas přibližně `0.02s`, špičková paměťová stopa ~`3.9 MB`
- `zeroclaw status`: reálný čas přibližně `0.01s`, špičková paměťová stopa ~`4.1 MB`
## Předpoklady
<details>
<summary><strong>Windows</strong></summary>
### Windows — Vyžadováno
1. **Visual Studio Build Tools** (poskytuje MSVC linker a Windows SDK):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Během instalace (nebo přes Visual Studio Installer), vyberte workload **"Desktop development with C++"**.
2. **Rust Toolchain:**
```powershell
winget install Rustlang.Rustup
```
Po instalaci otevřete nový terminál a spusťte `rustup default stable` pro zajištění, že stabilní toolchain je aktivní.
3. **Ověřte** že oba fungují:
```powershell
rustc --version
cargo --version
```
### Windows — Volitelné
- **Docker Desktop** — vyžadováno pouze pokud používáte [Docker sandboxed runtime](#aktuální-runtime-podpora) (`runtime.kind = "docker"`). Nainstalujte přes `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Vyžadováno
1. **Essenciální build nástroje:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Nainstalujte Xcode Command Line Tools: `xcode-select --install`
2. **Rust Toolchain:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Viz [rustup.rs](https://rustup.rs) pro detaily.
3. **Ověřte:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — Volitelné
- **Docker** — vyžadováno pouze pokud používáte [Docker sandboxed runtime](#aktuální-runtime-podpora) (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** viz [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** viz [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** nainstalujte Docker Desktop přes [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## Rychlý Start
### Možnost 1: Automatické nastavení (doporučeno)
Skript `bootstrap.sh` nainstaluje Rust, naklonuje ZeroClaw, zkompiluje ho a nastaví vaše počáteční vývojové prostředí:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
Toto:
1. Nainstaluje Rust (pokud chybí)
2. Naklonuje ZeroClaw repoziťář
3. Zkompiluje ZeroClaw v release módu
4. Nainstaluje `zeroclaw` do `~/.cargo/bin/`
5. Vytvoří výchozí workspace strukturu v `~/.zeroclaw/workspace/`
6. Vygeneruje počáteční konfigurační soubor `~/.zeroclaw/workspace/config.toml`
Po bootstrapu znovu načtěte váš shell nebo spusťte `source ~/.cargo/env` pro použití příkazu `zeroclaw` globálně.
### Možnost 2: Manuální instalace
<details>
<summary><strong>Klikněte pro zobrazení kroků manuální instalace</strong></summary>
```bash
# 1. Naklonujte repoziťář
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. Zkompilujte v release
cargo build --release --locked
# 3. Nainstalujte binary
cargo install --path . --locked
# 4. Inicializujte workspace
zeroclaw init
# 5. Ověřte instalaci
zeroclaw --version
zeroclaw status
```
</details>
### Po instalaci
Jakmile nainstalováno (přes bootstrap nebo manuálně), měli byste vidět:
```
~/.zeroclaw/workspace/
├── config.toml # Hlavní konfigurace
├── .pairing # Párovací tajemství (generováno při prvním spuštění)
├── logs/ # Daemon/agent logy
├── skills/ # Vlastní dovednosti
└── memory/ # Uložení konverzačního kontextu
```
**Další kroky:**
1. Nakonfigurujte své AI poskytovatele v `~/.zeroclaw/workspace/config.toml`
2. Podívejte se na [konfigurační referenci](docs/config-reference.md) pro pokročilé možnosti
3. Spusťte agenta: `zeroclaw agent start`
4. Otestujte přes váš preferovaný kanál (viz [kanálová reference](docs/channels-reference.md))
## Konfigurace
Upravte `~/.zeroclaw/workspace/config.toml` pro konfiguraci poskytovatelů, kanálů a chování systému.
### Rychlá konfigurační reference
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # nebo "sqlite" nebo "none"
[runtime]
kind = "native" # nebo "docker" (vyžaduje Docker)
```
**Kompletní referenční dokumenty:**
- [Konfigurační reference](docs/config-reference.md) — všechna nastavení, validace, výchozí hodnoty
- [Poskytovatel reference](docs/providers-reference.md) — AI poskytovatel-specifické konfigurace
- [Kanálová reference](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord a další
- [Operace](docs/operations-runbook.md) — produkční monitoring, rotace tajemství, škálování
### Aktuální Runtime Podpora
ZeroClaw podporuje dva backendy provádění kódu:
- **`native`** (výchozí) — přímé provedení procesu, nejrychlejší cesta, ideální pro důvěryhodná prostředí
- **`docker`** — plná kontejnerová izolace, zpřísněné bezpečnostní politiky, vyžaduje Docker
Použijte `runtime.kind = "docker"` pokud potřebujete striktní sandboxing nebo síťovou izolaci. Viz [konfigurační reference](docs/config-reference.md#runtime) pro úplné detaily.
## Příkazy
```bash
# Správa workspace
zeroclaw init # Inicializuje nový workspace
zeroclaw status # Zobrazuje stav daemon/agent
zeroclaw config validate # Ověřuje syntaxi a hodnoty config.toml
# Správa daemon
zeroclaw daemon start # Spouští daemon na pozadí
zeroclaw daemon stop # Zastavuje běžící daemon
zeroclaw daemon restart # Restartuje daemon (znovunačtení config)
zeroclaw daemon logs # Zobrazuje daemon logy
# Správa agent
zeroclaw agent start # Spouští agenta (vyžaduje běžící daemon)
zeroclaw agent stop # Zastavuje agenta
zeroclaw agent restart # Restartuje agenta (znovunačtení config)
# Párovací operace
zeroclaw pairing init # Generuje nové párovací tajemství
zeroclaw pairing rotate # Rotuje existující párovací tajemství
# Tunneling (pro veřejnou expozici)
zeroclaw tunnel start # Spouští tunnel k lokálnímu daemon
zeroclaw tunnel stop # Zastavuje aktivní tunnel
# Diagnostika
zeroclaw doctor # Spouští kontroly zdraví systému
zeroclaw version # Zobrazuje verzi a build informace
```
Viz [Příkazová reference](docs/commands-reference.md) pro kompletní možnosti a příklady.
## Architektura
```
┌─────────────────────────────────────────────────────────────────┐
│ Kanály (trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Agent Orchestrátor │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Směrování │ │ Kontext │ │ Provedení │ │
│ │ Zpráva │ │ Paměť │ │ Nástroj │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Poskytovatel│ │ Paměť │ │ Nástroje │
│ (trait) │ │ (trait) │ │ (trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Runtime (trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Klíčové principy:**
- Vše je **trait** — poskytovatelé, kanály, nástroje, paměť, tunely
- Kanály volají orchestrátor; orchestrátor volá poskytovatele + nástroje
- Paměťový systém spravuje konverzační kontext (markdown, SQLite, nebo žádný)
- Runtime abstrahuje provádění kódu (nativní nebo Docker)
- Žádné vendor lock-in — vyměňujte Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama beze změn kódu
Viz [dokumentace architektury](docs/architecture.svg) pro detailní diagramy a detaily implementace.
## Příklady
### Telegram Bot
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Vaše Telegram user ID
```
Spusťte daemon + agent, pak pošlete zprávu vašemu botovi na Telegram:
```
/start
Ahoj! Mohl bys mi pomoci napsat Python skript?
```
Bot odpoví AI-generovaným kódem, provede nástroje pokud požadováno a udržuje konverzační kontext.
### Matrix (end-to-end šifrování)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Pozvěte `@zeroclaw:matrix.org` do šifrované místnosti a bot odpoví s plným šifrováním. Viz [Matrix E2EE Guide](docs/matrix-e2ee-guide.md) pro nastavení ověření zařízení.
### Multi-Poskytovatel
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Failover při chybě poskytovatele
```
Pokud Anthropic selže nebo má rate-limit, orchestrátor automaticky přepne na OpenAI.
### Vlastní Paměť
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # Automatické čištění po 90 dnech
```
Nebo použijte Markdown pro lidsky čitelné ukládání:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Viz [Konfigurační reference](docs/config-reference.md#memory) pro všechny možnosti paměti.
## Podpora Poskytovatelů
| Poskytovatel | Stav | API Klíč | Příklad Modelů |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Stabilní | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Stabilní | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Stabilní | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Stabilní | N/A (lokální) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Stabilní | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Stabilní | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Plánováno | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Plánováno | `COHERE_API_KEY` | TBD |
### Vlastní Endpointy
ZeroClaw podporuje OpenAI-kompatibilní endpointy:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Příklad: použijte [LiteLLM](https://github.com/BerriAI/litellm) jako proxy pro přístup k jakémukoli LLM přes OpenAI rozhraní.
Viz [Poskytovatel reference](docs/providers-reference.md) pro kompletní detaily konfigurace.
## Podpora Kanálů
| Kanál | Stav | Autentizace | Poznámky |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Stabilní | Bot Token | Plná podpora včetně souborů, obrázků, inline tlačítek |
| **Matrix** | ✅ Stabilní | Heslo nebo Token | E2EE podpora s ověřením zařízení |
| **Slack** | 🚧 Plánováno | OAuth nebo Bot Token | Vyžaduje workspace přístup |
| **Discord** | 🚧 Plánováno | Bot Token | Vyžaduje guild oprávnění |
| **WhatsApp** | 🚧 Plánováno | Twilio nebo oficiální API | Vyžaduje business účet |
| **CLI** | ✅ Stabilní | Žádné | Přímé konverzační rozhraní |
| **Web** | 🚧 Plánováno | API Klíč nebo OAuth | Prohlížečové chat rozhraní |
Viz [Kanálová reference](docs/channels-reference.md) pro kompletní instrukce konfigurace.
## Podpora Nástrojů
ZeroClaw poskytuje vestavěné nástroje pro provádění kódu, přístup k souborovému systému a web retrieval:
| Nástroj | Popis | Vyžadovaný Runtime |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Provádí shell příkazy | Nativní nebo Docker |
| **python** | Provádí Python skripty | Python 3.8+ (nativní) nebo Docker |
| **javascript** | Provádí Node.js kód | Node.js 18+ (nativní) nebo Docker |
| **filesystem_read** | Čte soubory | Nativní nebo Docker |
| **filesystem_write** | Zapisuje soubory | Nativní nebo Docker |
| **web_fetch** | Získává web obsah | Nativní nebo Docker |
### Bezpečnost Provedení
- **Nativní Runtime** — běží jako uživatelský proces daemon, plný přístup k souborovému systému
- **Docker Runtime** — plná kontejnerová izolace, oddělené souborové systémy a sítě
Nakonfigurujte politiku provedení v `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Explicitní allowlist
```
Viz [Konfigurační reference](docs/config-reference.md#runtime) pro kompletní možnosti bezpečnosti.
## Nasazení
### Lokální Nasazení (Vývoj)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Serverové Nasazení (Produkce)
Použijte systemd pro správu daemon a agent jako služby:
```bash
# Nainstalujte binary
cargo install --path . --locked
# Nakonfigurujte workspace
zeroclaw init
# Vytvořte systemd servisní soubory
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# Povolte a spusťte služby
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# Ověřte stav
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Viz [Průvodce síťovým nasazením](docs/network-deployment.md) pro kompletní instrukce produkčního nasazení.
### Docker
```bash
# Sestavte image
docker build -t zeroclaw:latest .
# Spusťte kontejner
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Viz [`Dockerfile`](Dockerfile) pro detaily sestavení a konfigurační možnosti.
### Edge Hardware
ZeroClaw je navržen pro běh na nízko-příkonovém hardwaru:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, jedno ARMv8 jádro, < $5 hardwarové náklady
- **Raspberry Pi 4/5** — 1 GB+ RAM, vícejádrový, ideální pro souběžné úlohy
- **Orange Pi Zero 2** — ~512 MB RAM, čtyřjádrový ARMv8, ultra-nízké náklady
- **x86 SBCs (Intel N100)** — 4-8 GB RAM, rychlé buildy, nativní Docker podpora
Viz [Hardware Guide](docs/hardware/README.md) pro instrukce nastavení specifické pro zařízení.
## Tunneling (Veřejná Expozice)
Exponujte svůj lokální ZeroClaw daemon do veřejné sítě přes bezpečné tunely:
```bash
zeroclaw tunnel start --provider cloudflare
```
Podporovaní tunnel poskytovatelé:
- **Cloudflare Tunnel** — bezplatný HTTPS, bez expozice portů, multi-doména podpora
- **Ngrok** — rychlé nastavení, vlastní domény (placený plán)
- **Tailscale** — soukromá mesh síť, bez veřejného portu
Viz [Konfigurační reference](docs/config-reference.md#tunnel) pro kompletní konfigurační možnosti.
## Bezpečnost
ZeroClaw implementuje více vrstev bezpečnosti:
### Párování
Daemon generuje párovací tajemství při prvním spuštění uložené v `~/.zeroclaw/workspace/.pairing`. Klienti (agent, CLI) musí předložit toto tajemství pro připojení.
```bash
zeroclaw pairing rotate # Generuje nové tajemství a zneplatňuje staré
```
### Sandboxing
- **Docker Runtime** — plná kontejnerová izolace s oddělenými souborovými systémy a sítěmi
- **Nativní Runtime** — běží jako uživatelský proces, scoped na workspace defaultně
### Allowlisty
Kanály mohou omezit přístup podle user ID:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Explicitní allowlist
```
### Šifrování
- **Matrix E2EE** — plné end-to-end šifrování s ověřením zařízení
- **TLS Transport** — veškerý API a tunnel provoz používá HTTPS/TLS
Viz [Bezpečnostní dokumentace](docs/security/README.md) pro kompletní politiky a praktiky.
## Pozorovatelnost
ZeroClaw loguje do `~/.zeroclaw/workspace/logs/` defaultně. Logy jsou ukládány podle komponenty:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Daemon logy (startup, API požadavky, chyby)
├── agent.log # Agent logy (směrování zpráv, provedení nástrojů)
├── telegram.log # Kanál-specifické logy (pokud povoleno)
└── matrix.log # Kanál-specifické logy (pokud povoleno)
```
### Konfigurace Logování
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # Pro rotaci založenou na velikosti
retention_days = 30 # Automatické čištění po N dnech
```
Viz [Konfigurační reference](docs/config-reference.md#logging) pro všechny možnosti logování.
### Metriky (Plánováno)
Podpora Prometheus metrik pro produkční monitoring již brzy. Sledování v [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## Dovednosti
ZeroClaw podporuje vlastní dovednosti — opakovaně použitelné moduly rozšiřující schopnosti systému.
### Definice Dovednosti
Dovednosti jsou uloženy v `~/.zeroclaw/workspace/skills/<skill-name>/` s touto strukturou:
```
skills/
└── my-skill/
├── skill.toml # Metadata dovednosti (název, popis, závislosti)
├── prompt.md # Systémový prompt pro AI
└── tools/ # Volitelné vlastní nástroje
└── my_tool.py
```
### Příklad Dovednosti
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Hledá na webu a shrnuje výsledky"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
Jste výzkumný asistent. Když požádáte o výzkum něčeho:
1. Použijte web_fetch pro získání obsahu
2. Shrňte výsledky v snadno čitelném formátu
3. Citujte zdroje s URL
```
### Použití Dovedností
Dovednosti jsou automaticky načítány při startu agenta. Odkazujte na ně jménem v konverzacích:
```
Uživatel: Použij dovednost web-research k nalezení nejnovějších AI zpráv
Bot: [načte dovednost web-research, provede web_fetch, shrne výsledky]
```
Viz sekce [Dovednosti](#dovednosti) pro kompletní instrukce tvorby dovedností.
## Open Skills
ZeroClaw podporuje [Open Skills](https://github.com/openagents-com/open-skills) — modulární a poskytovatel-agnostický systém pro rozšíření schopností AI agentů.
### Povolit Open Skills
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # volitelné
```
Můžete také přepsat za běhu pomocí `ZEROCLAW_OPEN_SKILLS_ENABLED` a `ZEROCLAW_OPEN_SKILLS_DIR`.
## Vývoj
```bash
cargo build # Dev build
cargo build --release # Release build (codegen-units=1, funguje na všech zařízeních včetně Raspberry Pi)
cargo build --profile release-fast # Rychlejší build (codegen-units=8, vyžaduje 16 GB+ RAM)
cargo test # Spustí plnou testovací sadu
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Formátování
# Spusťte SQLite vs Markdown srovnávací benchmark
cargo test --test memory_comparison -- --nocapture
```
### Pre-push hook
Git hook spouští `cargo fmt --check`, `cargo clippy -- -D warnings`, a `cargo test` před každým push. Povolte jej jednou:
```bash
git config core.hooksPath .githooks
```
### Řešení problémů s Buildem (OpenSSL chyby na Linuxu)
Pokud narazíte na `openssl-sys` build chybu, synchronizujte závislosti a znovu zkompilujte s lockfile repoziťáře:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw je nakonfigurován pro použití `rustls` pro HTTP/TLS závislosti; `--locked` udržuje transitivní graf deterministický v čistých prostředích.
Pro přeskočení hooku když potřebujete rychlý push během vývoje:
```bash
git push --no-verify
```
## Spolupráce & Docs
Začněte s dokumentačním centrem pro task-based mapu:
- Dokumentační Centrum: [`docs/README.md`](docs/README.md)
- Sjednocený Docs TOC: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Příkazová reference: [`docs/commands-reference.md`](docs/commands-reference.md)
- Konfigurační reference: [`docs/config-reference.md`](docs/config-reference.md)
- Poskytovatel reference: [`docs/providers-reference.md`](docs/providers-reference.md)
- Kanálová reference: [`docs/channels-reference.md`](docs/channels-reference.md)
- Operations Runbook: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Řešení problémů: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Docs Inventář/Klasifikace: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- PR/Issue Triage Snapshot (k 18. únoru 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Hlavní spolupráční reference:
- Dokumentační Centrum: [docs/README.md](docs/README.md)
- Šablona dokumentace: [docs/doc-template.md](docs/doc-template.md)
- Checklist změn dokumentace: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Reference konfigurace kanálů: [docs/channels-reference.md](docs/channels-reference.md)
- Operace šifrovaných místností Matrix: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Průvodce příspíváním: [CONTRIBUTING.md](CONTRIBUTING.md)
- PR Workflow politika: [docs/pr-workflow.md](docs/pr-workflow.md)
- Reviewer Playbook (triage + hluboká recenze): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Mapa vlastnictví a CI triage: [docs/ci-map.md](docs/ci-map.md)
- Bezpečnostní disclosure politika: [SECURITY.md](SECURITY.md)
Pro nasazení a runtime operace:
- Průvodce síťovým nasazením: [docs/network-deployment.md](docs/network-deployment.md)
- Proxy Agent Playbook: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## Podpořte ZeroClaw
Pokud ZeroClaw pomáhá vaší práci a chcete podpořit pokračující vývoj, můžete darovat zde:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Kup Mi Kávu" /></a>
### 🙏 Speciální Poděkování
Upřímné poděkování komunitám a institucím které inspirují a živí tuto open-source práci:
- **Harvard University** — za podporu intelektuální zvídavosti a posouvání hranic toho co je možné.
- **MIT** — za obhajobu otevřeného vědění, open source, a přesvědčení že technologie by měla být přístupná všem.
- **Sundai Club** — za komunitu, energii, a neustálou vůli stavět věci které na něčem záleží.
- **Svět a Dál** 🌍✨ — každému přispěvateli, snílkovi, a staviteli tam venku který dělá z open source sílu pro dobro. To je pro tebe.
Stavíme v open source protože nejlepší nápady přicházejí odkudkoliv. Pokud toto čtete, jste součástí toho. Vítejte. 🦀❤️
## ⚠️ Oficiální Repoziťář a Varování před Vydáváním se
**Toto je jediný oficiální ZeroClaw repoziťář:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Jakýkoliv jiný repoziťář, organizace, doména nebo balík tvrdící že je "ZeroClaw" nebo naznačující afiliaci s ZeroClaw Labs je **neautorizovaný a není spojen s tímto projektem**. Známé neautorizované forky budou uvedeny v [TRADEMARK.md](TRADEMARK.md).
Pokud narazíte na vydávání se nebo zneužití ochranné známky, prosím [otevřete issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## Licence
ZeroClaw je duálně licencován pro maximální otevřenost a ochranu přispěvatelů:
| Licence | Případy použití |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Open-source, výzkum, akademické, osobní použití |
| [Apache 2.0](LICENSE-APACHE) | Ochrana patentů, institucionální, komerční nasazení |
Můžete si vybrat jednu z licencí. **Přispěvatelé automaticky udělují práva pod oběma** — viz [CLA.md](CLA.md) pro plnou dohodu přispěvatele.
### Ochranná známka
Název **ZeroClaw** a logo jsou registrované ochranné známky ZeroClaw Labs. Tato licence neuděluje povolení je používat k naznačení schválení nebo afiliace. Viz [TRADEMARK.md](TRADEMARK.md) pro povolená a zakázaná použití.
### Ochrany přispěvatelů
- **Si zachováváte autorská práva** k vašim příspěvkům
- **Patentový grant** (Apache 2.0) vás chrání před patentovými nároky ostatních přispěvatelů
- Vaše příspěvky jsou **trvale připsány** v historii commitů a [NOTICE](NOTICE)
- Žádná práva ochranné známky nejsou přenesena příspěvkem
## Příspívání
Viz [CONTRIBUTING.md](CONTRIBUTING.md) a [CLA.md](CLA.md). Implementujte trait, odešlete PR:
- Průvodce CI workflow: [docs/ci-map.md](docs/ci-map.md)
- Nový `Provider``src/providers/`
- Nový `Channel``src/channels/`
- Nový `Observer``src/observability/`
- Nový `Tool``src/tools/`
- Nová `Memory``src/memory/`
- Nový `Tunnel``src/tunnel/`
- Nová `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Nulová režie. Nulové kompromisy. Nasazujte kdekoliv. Měňte cokoliv. 🦀
## Historie Hvězd
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Graf Historie Hvězd" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

179
README.da.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Nul overhead. Nul kompromis. 100% Rust. 100% Agnostisk.</strong><br>
⚡️ <strong>Kører på $10 hardware med <5MB RAM: Det er 99% mindre hukommelse end OpenClaw og 98% billigere end en Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Sprog:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## Hvad er ZeroClaw?
ZeroClaw er en letvægts, foranderlig og udvidbar AI-assistent-infrastruktur bygget i Rust. Den forbinder forskellige LLM-udbydere (Anthropic, OpenAI, Google, Ollama osv.) via en samlet grænseflade og understøtter flere kanaler (Telegram, Matrix, CLI osv.).
### Nøglefunktioner
- **🦀 Skrevet i Rust**: Høj ydeevne, hukommelsessikkerhed og nul-omkostningsabstraktioner
- **🔌 Udbyder-agnostisk**: Understøtter OpenAI, Anthropic, Google Gemini, Ollama og andre
- **📱 Multi-kanal**: Telegram, Matrix (med E2EE), CLI og andre
- **🧠 Pluggbar hukommelse**: SQLite og Markdown-backends
- **🛠️ Udvidbare værktøjer**: Tilføj brugerdefinerede værktøjer nemt
- **🔒 Sikkerhed først**: Omvendt proxy, privatlivs-først design
---
## Hurtig Start
### Krav
- Rust 1.70+
- En LLM-udbyder API-nøgle (Anthropic, OpenAI osv.)
### Installation
```bash
# Klon repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Byg
cargo build --release
# Kør
cargo run --release
```
### Med Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Konfiguration
ZeroClaw bruger en YAML-konfigurationsfil. Som standard leder den efter `config.yaml`.
```yaml
# Standardudbyder
provider: anthropic
# Udbyderkonfiguration
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Hukommelseskonfiguration
memory:
backend: sqlite
path: data/memory.db
# Kanalkonfiguration
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Dokumentation
For detaljeret dokumentation, se:
- [Dokumentationshub](docs/README.md)
- [Kommandoreference](docs/commands-reference.md)
- [Udbyderreference](docs/providers-reference.md)
- [Kanalreference](docs/channels-reference.md)
- [Konfigurationsreference](docs/config-reference.md)
---
## Bidrag
Bidrag er velkomne! Læs venligst [Bidragsguiden](CONTRIBUTING.md).
---
## Licens
Dette projekt er dobbelt-licenseret:
- MIT License
- Apache License, version 2.0
Se [LICENSE-APACHE](LICENSE-APACHE) og [LICENSE-MIT](LICENSE-MIT) for detaljer.
---
## Fællesskab
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Sponsorer
Hvis ZeroClaw er nyttigt for dig, overvej venligst at købe os en kaffe:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

918
README.de.md Normal file
View File

@ -0,0 +1,918 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Null Overhead. Null Kompromiss. 100% Rust. 100% Agnostisch.</strong><br>
⚡️ <strong>Läuft auf 10$ Hardware mit <5MB RAM: Das ist 99% weniger Speicher als OpenClaw und 98% günstiger als ein Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Erstellt von Studenten und Mitgliedern der Harvard, MIT und Sundai.Club Gemeinschaften.
</p>
<p align="center">
🌐 <strong>Sprachen:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#schnellstart">Schnellstart</a> |
<a href="bootstrap.sh">Ein-Klick-Einrichtung</a> |
<a href="docs/README.md">Dokumentations-Hub</a> |
<a href="docs/SUMMARY.md">Dokumentations-Inhaltsverzeichnis</a>
</p>
<p align="center">
<em>📝 Hinweis: Die Dokumentationslinks verweisen auf die englischsprachige Dokumentation. Lokalisierte Dokumentation für Deutsch ist noch nicht verfügbar.</em>
</p>
<p align="center">
<strong>Schnellzugriffe:</strong>
<a href="docs/reference/README.md">Referenz</a> ·
<a href="docs/operations/README.md">Betrieb</a> ·
<a href="docs/troubleshooting.md">Fehlerbehebung</a> ·
<a href="docs/security/README.md">Sicherheit</a> ·
<a href="docs/hardware/README.md">Hardware</a> ·
<a href="docs/contributing/README.md">Mitwirken</a>
</p>
<p align="center">
<strong>Schnelle, leichtgewichtige und vollständig autonome KI-Assistenten-Infrastruktur</strong><br />
Deploy überall. Tausche alles.
</p>
<p align="center">
ZeroClaw ist das <strong>Runtime-Betriebssystem</strong> für Agenten-Workflows — eine Infrastruktur, die Modelle, Tools, Speicher und Ausführung abstrahiert, um Agenten einmal zu bauen und überall auszuführen.
</p>
<p align="center"><code>Trait-basierte Architektur · sicheres Runtime standardmäßig · Provider/Channel/Tool austauschbar · alles ist steckbar</code></p>
### 📢 Ankündigungen
Verwende diese Tabelle für wichtige Hinweise (Kompatibilitätsänderungen, Sicherheitshinweise, Wartungsfenster und Versionsblockierungen).
| Datum (UTC) | Ebene | Hinweis | Aktion |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Kritisch_ | Wir sind **nicht verbunden** mit `openagen/zeroclaw` oder `zeroclaw.org`. Die Domain `zeroclaw.org` zeigt derzeit auf den Fork `openagen/zeroclaw`, und diese Domain/Repository fälscht unsere offizielle Website/Projekt. | Vertraue keinen Informationen, Binärdateien, Fundraising oder Ankündigungen aus diesen Quellen. Verwende nur [dieses Repository](https://github.com/zeroclaw-labs/zeroclaw) und unsere verifizierten Social-Media-Konten. |
| 2026-02-21 | _Wichtig_ | Unsere offizielle Website ist jetzt online: [zeroclawlabs.ai](https://zeroclawlabs.ai). Danke für deine Geduld während der Wartezeit. Wir erkennen weiterhin Fälschungsversuche: nimm an keiner Investitions-/Finanzierungsaktivität im Namen von ZeroClaw teil, wenn sie nicht über unsere offiziellen Kanäle veröffentlicht wird. | Verwende [dieses Repository](https://github.com/zeroclaw-labs/zeroclaw) als einzige Quelle der Wahrheit. Folge [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (Gruppe)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), und [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) für offizielle Updates. |
| 2026-02-19 | _Wichtig_ | Anthropic hat die Nutzungsbedingungen für Authentifizierung und Anmeldedaten am 2026-02-19 aktualisiert. Die OAuth-Authentifizierung (Free, Pro, Max) ist ausschließlich für Claude Code und Claude.ai; die Verwendung von Claude Free/Pro/Max OAuth-Token in einem anderen Produkt, Tool oder Dienst (einschließlich Agent SDK) ist nicht erlaubt und kann gegen die Verbrauchernutzungsbedingungen verstoßen. | Bitte vermeide vorübergehend Claude Code OAuth-Integrationen, um potenzielle Verluste zu verhindern. Originalklausel: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Funktionen
- 🏎️ **Leichtgewichtiges Runtime standardmäßig:** Gängige CLI-Workflows und Statusbefehle laufen in einem Speicherbereich von wenigen Megabyte bei Produktions-Builds.
- 💰 **Kosteneffizientes Deployment:** Entwickelt für Low-Cost-Boards und kleine Cloud-Instanzen ohne schwere Runtime-Abhängigkeiten.
- ⚡ **Schnelle Kaltstarts:** Die Single-Binary-Rust-Runtime hält Befehls- und Daemon-Starts für tägliche Operationen nahezu augenblicklich.
- 🌍 **Portable Architektur:** Ein Single-Binary-Workflow auf ARM, x86 und RISC-V mit austauschbaren Providern/Channels/Tools.
### Warum Teams ZeroClaw wählen
- **Leichtgewichtig standardmäßig:** kleines Rust-Binary, schneller Start, geringer Speicherbedarf.
- **Sicher by Design:** Pairing, striktes Sandboxing, explizite Allowlists, Workspace-Scope.
- **Vollständig austauschbar:** Kernsysteme sind Traits (Provider, Channels, Tools, Speicher, Tunnel).
- **Kein Provider-Lock-in:** OpenAI-kompatible Provider-Unterstützung + steckbare Custom-Endpoints.
## Benchmark-Snapshot (ZeroClaw vs OpenClaw, Reproduzierbar)
Schneller Benchmark auf lokalem Rechner (macOS arm64, Feb. 2026) normalisiert für 0.8 GHz Edge-Hardware.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Sprache** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Start (0.8 GHz Kern)** | > 500s | > 30s | < 1s | **< 10ms** |
| **Binary-Größe** | ~28 MB (dist) | N/A (Scripts) | ~8 MB | **3.4 MB** |
| **Kosten** | Mac Mini $599 | Linux SBC ~$50 | Linux-Board $10 | **Jede Hardware $10** |
> Hinweise: ZeroClaw-Ergebnisse werden auf Produktions-Builds mit `/usr/bin/time -l` gemessen. OpenClaw benötigt die Node.js-Runtime (typischerweise ~390 MB zusätzlicher Speicher-Overhead), während NanoBot die Python-Runtime benötigt. PicoClaw und ZeroClaw sind statische Binaries. Die oben genannten RAM-Zahlen sind Runtime-Speicher; Build-time-Kompilierungsanforderungen sind höher.
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw Vergleich" width="800" />
</p>
### Reproduzierbare lokale Messung
Benchmark-Behauptungen können sich ändern, wenn Code und Toolchains sich weiterentwickeln, also miss deinen aktuellen Build immer lokal:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Beispielstichprobe (macOS arm64, gemessen am 18. Februar 2026):
- Release-Binary-Größe: `8.8M`
- `zeroclaw --help`: Echtzeit ca. `0.02s`, maximaler Speicherbedarf ~`3.9 MB`
- `zeroclaw status`: Echtzeit ca. `0.01s`, maximaler Speicherbedarf ~`4.1 MB`
## Voraussetzungen
<details>
<summary><strong>Windows</strong></summary>
### Windows — Erforderlich
1. **Visual Studio Build Tools** (stellt MSVC-Linker und Windows SDK bereit):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Wähle während der Installation (oder über Visual Studio Installer) die Workload **"Desktop-Entwicklung mit C++"**.
2. **Rust-Toolchain:**
```powershell
winget install Rustlang.Rustup
```
Öffne nach der Installation ein neues Terminal und führe `rustup default stable` aus, um sicherzustellen, dass die stabile Toolchain aktiv ist.
3. **Überprüfe**, dass beide funktionieren:
```powershell
rustc --version
cargo --version
```
### Windows — Optional
- **Docker Desktop** — nur erforderlich, wenn du die [Docker-Sandbox-Runtime](#aktuelle-runtime-unterstützung) verwendest (`runtime.kind = "docker"`). Installiere über `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Erforderlich
1. **Essentielle Build-Tools:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Installiere Xcode Command Line Tools: `xcode-select --install`
2. **Rust-Toolchain:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Siehe [rustup.rs](https://rustup.rs) für Details.
3. **Überprüfe:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — Optional
- **Docker** — nur erforderlich, wenn du die [Docker-Sandbox-Runtime](#aktuelle-runtime-unterstützung) verwendest (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** siehe [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** siehe [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** installiere Docker Desktop über [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## Schnellstart
### Option 1: Automatisierte Einrichtung (empfohlen)
Das `bootstrap.sh`-Skript installiert Rust, klont ZeroClaw, kompiliert es und richtet deine anfängliche Entwicklungsumgebung ein:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
Dies wird:
1. Rust installieren (falls nicht vorhanden)
2. Das ZeroClaw-Repository klonen
3. ZeroClaw im Release-Modus kompilieren
4. `zeroclaw` in `~/.cargo/bin/` installieren
5. Die Standard-Workspace-Struktur in `~/.zeroclaw/workspace/` erstellen
6. Eine Startkonfigurationsdatei `~/.zeroclaw/workspace/config.toml` generieren
Nach dem Bootstrap lade deine Shell neu oder führe `source ~/.cargo/env` aus, um den `zeroclaw`-Befehl global zu verwenden.
### Option 2: Manuelle Installation
<details>
<summary><strong>Klicke, um die manuellen Installationsschritte zu sehen</strong></summary>
```bash
# 1. Klone das Repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. Kompiliere im Release-Modus
cargo build --release --locked
# 3. Installiere das Binary
cargo install --path . --locked
# 4. Initialisiere den Workspace
zeroclaw init
# 5. Überprüfe die Installation
zeroclaw --version
zeroclaw status
```
</details>
### Nach der Installation
Nach der Installation (via Bootstrap oder manuell) solltest du sehen:
```
~/.zeroclaw/workspace/
├── config.toml # Hauptkonfiguration
├── .pairing # Pairing-Geheimnisse (beim ersten Start generiert)
├── logs/ # Daemon/Agent-Logs
├── skills/ # Benutzerdefinierte Skills
└── memory/ # Konversationskontext-Speicherung
```
**Nächste Schritte:**
1. Konfiguriere deine KI-Provider in `~/.zeroclaw/workspace/config.toml`
2. Sieh dir die [Konfigurationsreferenz](docs/config-reference.md) für erweiterte Optionen an
3. Starte den Agent: `zeroclaw agent start`
4. Teste über deinen bevorzugten Channel (siehe [Channel-Referenz](docs/channels-reference.md))
## Konfiguration
Bearbeite `~/.zeroclaw/workspace/config.toml`, um Provider, Channels und Systemverhalten zu konfigurieren.
### Schnelle Konfigurationsreferenz
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # oder "sqlite" oder "none"
[runtime]
kind = "native" # oder "docker" (erfordert Docker)
```
**Vollständige Referenzdokumente:**
- [Konfigurationsreferenz](docs/config-reference.md) — alle Einstellungen, Validierungen, Standardwerte
- [Provider-Referenz](docs/providers-reference.md) — KI-Provider-spezifische Konfigurationen
- [Channel-Referenz](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord und mehr
- [Betrieb](docs/operations-runbook.md) — Produktionsüberwachung, Secret-Rotation, Skalierung
### Aktuelle Runtime-Unterstützung
ZeroClaw unterstützt zwei Code-Ausführungs-Backends:
- **`native`** (Standard) — direkte Prozessausführung, schnellster Pfad, ideal für vertrauenswürdige Umgebungen
- **`docker`** — vollständige Container-Isolierung, gehärtete Sicherheitsrichtlinien, erfordert Docker
Verwende `runtime.kind = "docker"`, wenn du striktes Sandboxing oder Netzwerkisolierung benötigst. Siehe [Konfigurationsreferenz](docs/config-reference.md#runtime) für vollständige Details.
## Befehle
```bash
# Workspace-Verwaltung
zeroclaw init # Initialisiert einen neuen Workspace
zeroclaw status # Zeigt Daemon/Agent-Status
zeroclaw config validate # Überprüft config.toml Syntax und Werte
# Daemon-Verwaltung
zeroclaw daemon start # Startet den Daemon im Hintergrund
zeroclaw daemon stop # Stoppt den laufenden Daemon
zeroclaw daemon restart # Startet den Daemon neu (Config-Neuladen)
zeroclaw daemon logs # Zeigt Daemon-Logs
# Agent-Verwaltung
zeroclaw agent start # Startet den Agent (erfordert laufenden Daemon)
zeroclaw agent stop # Stoppt den Agent
zeroclaw agent restart # Startet den Agent neu (Config-Neuladen)
# Pairing-Operationen
zeroclaw pairing init # Generiert ein neues Pairing-Geheimnis
zeroclaw pairing rotate # Rotiert das bestehende Pairing-Geheimnis
# Tunneling (für öffentliche Exposition)
zeroclaw tunnel start # Startet einen Tunnel zum lokalen Daemon
zeroclaw tunnel stop # Stoppt den aktiven Tunnel
# Diagnose
zeroclaw doctor # Führt System-Gesundheitsprüfungen durch
zeroclaw version # Zeigt Version und Build-Informationen
```
Siehe [Befehlsreferenz](docs/commands-reference.md) für vollständige Optionen und Beispiele.
## Architektur
```
┌─────────────────────────────────────────────────────────────────┐
│ Channels (Trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Agent-Orchestrator │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Routing │ │ Kontext │ │ Ausführung │ │
│ │ Nachricht │ │ Speicher │ │ Werkzeug │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Provider │ │ Speicher │ │ Werkzeuge │
│ (Trait) │ │ (Trait) │ │ (Trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Runtime (Trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Schlüsselprinzipien:**
- Alles ist ein **Trait** — Provider, Channels, Tools, Speicher, Tunnel
- Channels rufen den Orchestrator auf; der Orchestrator ruft Provider + Tools auf
- Das Speichersystem verwaltet Konversationskontext (Markdown, SQLite, oder keiner)
- Das Runtime abstrahiert Code-Ausführung (nativ oder Docker)
- Kein Provider-Lock-in — tausche Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama ohne Code-Änderungen
Siehe [Architektur-Dokumentation](docs/architecture.svg) für detaillierte Diagramme und Implementierungsdetails.
## Beispiele
### Telegram-Bot
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Deine Telegram-Benutzer-ID
```
Starte den Daemon + Agent, dann sende eine Nachricht an deinen Bot auf Telegram:
```
/start
Hallo! Könntest du mir helfen, ein Python-Skript zu schreiben?
```
Der Bot antwortet mit KI-generiertem Code, führt Tools auf Anfrage aus und behält den Konversationskontext.
### Matrix (Ende-zu-Ende-Verschlüsselung)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Lade `@zeroclaw:matrix.org` in einen verschlüsselten Raum ein, und der Bot wird mit vollständiger Verschlüsselung antworten. Siehe [Matrix E2EE-Leitfaden](docs/matrix-e2ee-guide.md) für Geräteverifizierungs-Setup.
### Multi-Provider
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Failover bei Provider-Fehler
```
Wenn Anthropic fehlschlägt oder Rate-Limit erreicht, wechselt der Orchestrator automatisch zu OpenAI.
### Benutzerdefinierter Speicher
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # Automatische Bereinigung nach 90 Tagen
```
Oder verwende Markdown für menschenlesbaren Speicher:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Siehe [Konfigurationsreferenz](docs/config-reference.md#memory) für alle Speicheroptionen.
## Provider-Unterstützung
| Provider | Status | API-Schlüssel | Beispielmodelle |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Stabil | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Stabil | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Stabil | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Stabil | N/A (lokal) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Stabil | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Stabil | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Geplant | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Geplant | `COHERE_API_KEY` | TBD |
### Benutzerdefinierte Endpoints
ZeroClaw unterstützt OpenAI-kompatible Endpoints:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Beispiel: verwende [LiteLLM](https://github.com/BerriAI/litellm) als Proxy, um auf jedes LLM über die OpenAI-Schnittstelle zuzugreifen.
Siehe [Provider-Referenz](docs/providers-reference.md) für vollständige Konfigurationsdetails.
## Channel-Unterstützung
| Channel | Status | Authentifizierung | Hinweise |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Stabil | Bot-Token | Vollständige Unterstützung inklusive Dateien, Bilder, Inline-Buttons |
| **Matrix** | ✅ Stabil | Passwort oder Token | E2EE-Unterstützung mit Geräteverifizierung |
| **Slack** | 🚧 Geplant | OAuth oder Bot-Token | Erfordert Workspace-Zugriff |
| **Discord** | 🚧 Geplant | Bot-Token | Erfordert Guild-Berechtigungen |
| **WhatsApp** | 🚧 Geplant | Twilio oder offizielle API | Erfordert Business-Konto |
| **CLI** | ✅ Stabil | Keine | Direkte konversationelle Schnittstelle |
| **Web** | 🚧 Geplant | API-Schlüssel oder OAuth | Browserbasierte Chat-Schnittstelle |
Siehe [Channel-Referenz](docs/channels-reference.md) für vollständige Konfigurationsanleitungen.
## Tool-Unterstützung
ZeroClaw bietet integrierte Tools für Code-Ausführung, Dateisystemzugriff und Web-Abruf:
| Tool | Beschreibung | Erforderliches Runtime |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Führt Shell-Befehle aus | Nativ oder Docker |
| **python** | Führt Python-Skripte aus | Python 3.8+ (nativ) oder Docker |
| **javascript** | Führt Node.js-Code aus | Node.js 18+ (nativ) oder Docker |
| **filesystem_read** | Liest Dateien | Nativ oder Docker |
| **filesystem_write** | Schreibt Dateien | Nativ oder Docker |
| **web_fetch** | Ruft Web-Inhalte ab | Nativ oder Docker |
### Ausführungssicherheit
- **Natives Runtime** — läuft als Benutzerprozess des Daemons, voller Dateisystemzugriff
- **Docker-Runtime** — vollständige Container-Isolierung, separate Dateisysteme und Netzwerke
Konfiguriere die Ausführungsrichtlinie in `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Explizite Allowlist
```
Siehe [Konfigurationsreferenz](docs/config-reference.md#runtime) für vollständige Sicherheitsoptionen.
## Deployment
### Lokales Deployment (Entwicklung)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Server-Deployment (Produktion)
Verwende systemd, um Daemon und Agent als Dienste zu verwalten:
```bash
# Installiere das Binary
cargo install --path . --locked
# Konfiguriere den Workspace
zeroclaw init
# Erstelle systemd-Dienstdateien
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# Aktiviere und starte die Dienste
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# Überprüfe den Status
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Siehe [Netzwerk-Deployment-Leitfaden](docs/network-deployment.md) für vollständige Produktions-Deployment-Anleitungen.
### Docker
```bash
# Baue das Image
docker build -t zeroclaw:latest .
# Führe den Container aus
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Siehe [`Dockerfile`](Dockerfile) für Build-Details und Konfigurationsoptionen.
### Edge-Hardware
ZeroClaw ist für den Betrieb auf Low-Power-Hardware konzipiert:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, einzelner ARMv8-Kern, < $5 Hardware-Kosten
- **Raspberry Pi 4/5** — 1 GB+ RAM, Multi-Core, ideal für gleichzeitige Workloads
- **Orange Pi Zero 2** — ~512 MB RAM, Quad-Core ARMv8, Ultra-Low-Cost
- **x86 SBCs (Intel N100)** — 4-8 GB RAM, schnelle Builds, nativer Docker-Support
Siehe [Hardware-Leitfaden](docs/hardware/README.md) für gerätespezifische Einrichtungsanleitungen.
## Tunneling (Öffentliche Exposition)
Exponiere deinen lokalen ZeroClaw-Daemon über sichere Tunnel zum öffentlichen Netzwerk:
```bash
zeroclaw tunnel start --provider cloudflare
```
Unterstützte Tunnel-Provider:
- **Cloudflare Tunnel** — kostenloses HTTPS, keine Port-Exposition, Multi-Domain-Support
- **Ngrok** — schnelle Einrichtung, benutzerdefinierte Domains (kostenpflichtiger Plan)
- **Tailscale** — privates Mesh-Netzwerk, kein öffentlicher Port
Siehe [Konfigurationsreferenz](docs/config-reference.md#tunnel) für vollständige Konfigurationsoptionen.
## Sicherheit
ZeroClaw implementiert mehrere Sicherheitsebenen:
### Pairing
Der Daemon generiert beim ersten Start ein Pairing-Geheimnis, das in `~/.zeroclaw/workspace/.pairing` gespeichert wird. Clients (Agent, CLI) müssen dieses Geheimnis präsentieren, um eine Verbindung herzustellen.
```bash
zeroclaw pairing rotate # Generiert ein neues Geheimnis und erklärt das alte für ungültig
```
### Sandboxing
- **Docker-Runtime** — vollständige Container-Isolierung mit separaten Dateisystemen und Netzwerken
- **Natives Runtime** — läuft als Benutzerprozess, standardmäßig auf Workspace beschränkt
### Allowlists
Channels können den Zugriff nach Benutzer-ID einschränken:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Explizite Allowlist
```
### Verschlüsselung
- **Matrix E2EE** — vollständige Ende-zu-Ende-Verschlüsselung mit Geräteverifizierung
- **TLS-Transport** — der gesamte API- und Tunnel-Verkehr verwendet HTTPS/TLS
Siehe [Sicherheitsdokumentation](docs/security/README.md) für vollständige Richtlinien und Praktiken.
## Observability
ZeroClaw protokolliert standardmäßig in `~/.zeroclaw/workspace/logs/`. Logs werden nach Komponente gespeichert:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Daemon-Logs (Start, API-Anfragen, Fehler)
├── agent.log # Agent-Logs (Nachrichten-Routing, Tool-Ausführung)
├── telegram.log # Kanalspezifische Logs (falls aktiviert)
└── matrix.log # Kanalspezifische Logs (falls aktiviert)
```
### Logging-Konfiguration
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # Für größenbasierte Rotation
retention_days = 30 # Automatische Bereinigung nach N Tagen
```
Siehe [Konfigurationsreferenz](docs/config-reference.md#logging) für alle Logging-Optionen.
### Metriken (Geplant)
Prometheus-Metrik-Unterstützung für Produktionsüberwachung kommt bald. Verfolgung in [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## Skills
ZeroClaw unterstützt benutzerdefinierte Skills — wiederverwendbare Module, die die Systemfähigkeiten erweitern.
### Skill-Definition
Skills werden in `~/.zeroclaw/workspace/skills/<skill-name>/` mit dieser Struktur gespeichert:
```
skills/
└── my-skill/
├── skill.toml # Skill-Metadaten (Name, Beschreibung, Abhängigkeiten)
├── prompt.md # System-Prompt für die KI
└── tools/ # Optionale benutzerdefinierte Tools
└── my_tool.py
```
### Skill-Beispiel
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Sucht im Web und fasst Ergebnisse zusammen"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
Du bist ein Forschungsassistent. Wenn du gebeten wirst, etwas zu recherchieren:
1. Verwende web_fetch, um den Inhalt abzurufen
2. Fasse die Ergebnisse in einem leicht lesbaren Format zusammen
3. Zitiere die Quellen mit URLs
```
### Skill-Verwendung
Skills werden beim Agent-Start automatisch geladen. Referenziere sie nach Namen in Konversationen:
```
Benutzer: Verwende den Web-Research-Skill, um die neuesten KI-Nachrichten zu finden
Bot: [lädt den Web-Research-Skill, führt web_fetch aus, fasst Ergebnisse zusammen]
```
Siehe Abschnitt [Skills](#skills) für vollständige Skill-Erstellungsanleitungen.
## Open Skills
ZeroClaw unterstützt [Open Skills](https://github.com/openagents-com/open-skills) — ein modulares und provider-agnostisches System zur Erweiterung von KI-Agenten-Fähigkeiten.
### Open Skills aktivieren
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # optional
```
Du kannst auch zur Laufzeit mit `ZEROCLAW_OPEN_SKILLS_ENABLED` und `ZEROCLAW_OPEN_SKILLS_DIR` überschreiben.
## Entwicklung
```bash
cargo build # Entwicklungs-Build
cargo build --release # Release-Build (codegen-units=1, funktioniert auf allen Geräten einschließlich Raspberry Pi)
cargo build --profile release-fast # Schnellerer Build (codegen-units=8, erfordert 16 GB+ RAM)
cargo test # Führt die vollständige Test-Suite aus
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Formatierung
# Führe den SQLite vs Markdown Vergleichs-Benchmark aus
cargo test --test memory_comparison -- --nocapture
```
### Pre-push-Hook
Ein Git-Hook führt `cargo fmt --check`, `cargo clippy -- -D warnings`, und `cargo test` vor jedem Push aus. Aktiviere ihn einmal:
```bash
git config core.hooksPath .githooks
```
### Build-Fehlerbehebung (OpenSSL-Fehler unter Linux)
Wenn du auf einen `openssl-sys`-Build-Fehler stößt, synchronisiere Abhängigkeiten und kompiliere mit dem Lockfile des Repositories neu:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw ist so konfiguriert, dass es `rustls` für HTTP/TLS-Abhängigkeiten verwendet; `--locked` hält den transitiven Graphen in sauberen Umgebungen deterministisch.
Um den Hook zu überspringen, wenn du während der Entwicklung einen schnellen Push benötigst:
```bash
git push --no-verify
```
## Zusammenarbeit & Docs
Beginne mit dem Dokumentations-Hub für eine Aufgaben-basierte Karte:
- Dokumentations-Hub: [`docs/README.md`](docs/README.md)
- Vereinigtes Docs-Inhaltsverzeichnis: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Befehlsreferenz: [`docs/commands-reference.md`](docs/commands-reference.md)
- Konfigurationsreferenz: [`docs/config-reference.md`](docs/config-reference.md)
- Provider-Referenz: [`docs/providers-reference.md`](docs/providers-reference.md)
- Channel-Referenz: [`docs/channels-reference.md`](docs/channels-reference.md)
- Betriebshandbuch: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Fehlerbehebung: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Docs-Inventar/Klassifizierung: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- PR/Issue-Triage-Snapshot (Stand 18. Feb. 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Hauptzusammenarbeitsreferenzen:
- Dokumentations-Hub: [docs/README.md](docs/README.md)
- Dokumentationsvorlage: [docs/doc-template.md](docs/doc-template.md)
- Dokumentationsänderungs-Checkliste: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Channel-Konfigurationsreferenz: [docs/channels-reference.md](docs/channels-reference.md)
- Matrix-verschlüsselte Raum-Operationen: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Beitragsleitfaden: [CONTRIBUTING.md](CONTRIBUTING.md)
- PR-Workflow-Richtlinie: [docs/pr-workflow.md](docs/pr-workflow.md)
- Reviewer-Playbook (Triage + Tiefenreview): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Eigentums- und CI-Triage-Map: [docs/ci-map.md](docs/ci-map.md)
- Sicherheits-Offenlegungsrichtlinie: [SECURITY.md](SECURITY.md)
Für Deployment und Runtime-Betrieb:
- Netzwerk-Deployment-Leitfaden: [docs/network-deployment.md](docs/network-deployment.md)
- Proxy-Agent-Playbook: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## ZeroClaw unterstützen
Wenn ZeroClaw deine Arbeit hilft und du die kontinuierliche Entwicklung unterstützen möchtest, kannst du hier spenden:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Kauf mir einen Kaffee" /></a>
### 🙏 Besonderer Dank
Ein herzliches Dankeschön an die Gemeinschaften und Institutionen, die diese Open-Source-Arbeit inspirieren und unterstützen:
- **Harvard University** — für die Förderung intellektueller Neugier und das Erweitern der Grenzen des Möglichen.
- **MIT** — für das Eintreten für offenes Wissen, Open Source und die Überzeugung, dass Technologie für alle zugänglich sein sollte.
- **Sundai Club** — für die Gemeinschaft, die Energie und den unermüdlichen Willen, Dinge zu bauen, die zählen.
- **Die Welt und Darüber Hinaus** 🌍✨ — an jeden Mitwirkenden, Träumer und Erbauer da draußen, der Open Source zu einer Kraft für das Gute macht. Das ist für dich.
Wir bauen in Open Source, weil die besten Ideen von überall kommen. Wenn du das liest, bist du Teil davon. Willkommen. 🦀❤️
## ⚠️ Offizielles Repository und Fälschungswarnung
**Dies ist das einzige offizielle ZeroClaw-Repository:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Jedes andere Repository, Organisation, Domain oder Paket, das behauptet "ZeroClaw" zu sein oder eine Verbindung zu ZeroClaw Labs zu implizieren, ist **nicht autorisiert und nicht mit diesem Projekt verbunden**. Bekannte nicht autorisierte Forks werden in [TRADEMARK.md](TRADEMARK.md) aufgeführt.
Wenn du auf Fälschung oder Markenmissbrauch stößt, bitte [öffne ein Issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## Lizenz
ZeroClaw ist doppelt lizenziert für maximale Offenheit und Contributorschutz:
| Lizenz | Anwendungsfälle |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Open-Source, Forschung, akademisch, persönliche Nutzung |
| [Apache 2.0](LICENSE-APACHE) | Patentschutz, institutionell, kommerzielles Deployment |
Du kannst eine der beiden Lizenzen wählen. **Contributors gewähren automatisch Rechte unter beiden** — siehe [CLA.md](CLA.md) für die vollständige Contributor-Vereinbarung.
### Marke
Der Name **ZeroClaw** und das Logo sind eingetragene Marken von ZeroClaw Labs. Diese Lizenz gewährt keine Erlaubnis, sie zu verwenden, um Befürwortung oder Verbindung zu implizieren. Siehe [TRADEMARK.md](TRADEMARK.md) für erlaubte und verbotene Verwendungen.
### Contributorschutz
- Du **behältst das Urheberrecht** an deinen Beiträgen
- **Patentgewährung** (Apache 2.0) schützt dich vor Patentansprüchen anderer Contributors
- Deine Beiträge werden **dauerhaft zugeschrieben** in der Commit-Historie und [NOTICE](NOTICE)
- Keine Markenrechte werden durch Beiträge übertragen
## Mitwirken
Siehe [CONTRIBUTING.md](CONTRIBUTING.md) und [CLA.md](CLA.md). Implementiere einen Trait, reiche eine PR ein:
- CI-Workflow-Leitfaden: [docs/ci-map.md](docs/ci-map.md)
- Neuer `Provider``src/providers/`
- Neuer `Channel``src/channels/`
- Neuer `Observer``src/observability/`
- Neues `Tool``src/tools/`
- Neuer `Memory``src/memory/`
- Neuer `Tunnel``src/tunnel/`
- Neuer `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Null Overhead. Null Kompromiss. Deploy überall. Tausche alles. 🦀
## Stern-Historie
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Stern-Historie-Diagramm" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

181
README.el.md Normal file
View File

@ -0,0 +1,181 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Μηδενικό overhead. Μηδενικός συμβιβασμός. 100% Rust. 100% Αγνωστικιστικό.</strong><br>
⚡️ <strong>Εκτελείται σε hardware $10 με <5MB RAM: Αυτό είναι 99% λιγότερη μνήμη από το OpenClaw και 98% φθηνότερο από ένα Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Γλώσσες:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
> **📝 Σημείωση:** Αυτό είναι ένα συνοπτικό README στα ελληνικά. Για πλήρη τεκμηρίωση, ανατρέξτε στο [αγγλικό README](README.md). Οι σύνδεσμοι τεκμηρίωσης παραπέμπουν στην αγγλική τεκμηρίωση.
## Τι είναι το ZeroClaw;
Το ZeroClaw είναι μια ελαφριά, μεταβλητή και επεκτάσιμη υποδομή AI βοηθού χτισμένη σε Rust. Συνδέει διάφορους παρόχους LLM (Anthropic, OpenAI, Google, Ollama, κλπ.) μέσω μιας ενοποιημένης διεπαφής και υποστηρίζει πολλαπλά κανάλια (Telegram, Matrix, CLI, κλπ.).
### Κύρια Χαρακτηριστικά
- **🦀 Γραμμένο σε Rust**: Υψηλή απόδοση, ασφάλεια μνήμης και αφαιρέσεις μηδενικού κόστους
- **🔌 Αγνωστικιστικό προς παρόχους**: Υποστηρίζει OpenAI, Anthropic, Google Gemini, Ollama και άλλους
- **📱 Πολυκάναλο**: Telegram, Matrix (με E2EE), CLI και άλλα
- **🧠 Προσαρμόσιμη μνήμη**: SQLite και Markdown backends
- **🛠️ Επεκτάσιμα εργαλεία**: Προσθέστε εύκολα προσαρμοσμένα εργαλεία
- **🔒 Ασφάλεια πρώτα**: Αντίστροφος proxy, σχεδιασμός προσανατολισμένος στο απόρρητο
---
## Γρήγορη Εκκίνηση
### Απαιτήσεις
- Rust 1.70+
- Ένα κλειδί API παρόχου LLM (Anthropic, OpenAI, κλπ.)
### Εγκατάσταση
```bash
# Κλωνοποιήστε το repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Κατασκευή
cargo build --release
# Εκτέλεση
cargo run --release
```
### Με Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Ρύθμιση
Το ZeroClaw χρησιμοποιεί ένα αρχείο ρύθμισης YAML. Από προεπιλογή, αναζητά το `config.yaml`.
```yaml
# Προεπιλεγμένος πάροχος
provider: anthropic
# Ρύθμιση παρόχων
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Ρύθμιση μνήμης
memory:
backend: sqlite
path: data/memory.db
# Ρύθμιση καναλιών
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Τεκμηρίωση
Για λεπτομερή τεκμηρίωση, δείτε:
- [Κόμβος Τεκμηρίωσης](docs/README.md)
- [Αναφορά Εντολών](docs/commands-reference.md)
- [Αναφορά Παρόχων](docs/providers-reference.md)
- [Αναφορά Καναλιών](docs/channels-reference.md)
- [Αναφορά Ρυθμίσεων](docs/config-reference.md)
---
## Συνεισφορά
Οι συνεισφορές είναι ευπρόσδεκτες! Παρακαλώ διαβάστε τον [Οδηγό Συνεισφοράς](CONTRIBUTING.md).
---
## Άδεια
Αυτό το έργο έχει διπλή άδεια:
- MIT License
- Apache License, έκδοση 2.0
Δείτε τα [LICENSE-APACHE](LICENSE-APACHE) και [LICENSE-MIT](LICENSE-MIT) για λεπτομέρειες.
---
## Κοινότητα
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Χορηγοί
Αν το ZeroClaw είναι χρήσιμο για εσάς, παρακαλώ σκεφτείτε να μας αγοράσετε έναν καφέ:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

914
README.es.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Cero sobrecarga. Cero compromiso. 100% Rust. 100% Agnóstico.</strong><br>
⚡️ <strong>¡Ejecuta en hardware de $10 con <5MB de RAM: ¡Eso es 99% menos memoria que OpenClaw y 98% más barato que un Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Construido por estudiantes y miembros de las comunidades de Harvard, MIT y Sundai.Club.
</p>
<p align="center">
🌐 <strong>Idiomas:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#inicio-rápido">Inicio Rápido</a> |
<a href="bootstrap.sh">Configuración con Un Clic</a> |
<a href="docs/README.md">Hub de Documentación</a> |
<a href="docs/SUMMARY.md">Tabla de Contenidos de Documentación</a>
</p>
<p align="center">
<strong>Accesos rápidos:</strong>
<a href="docs/reference/README.md">Referencia</a> ·
<a href="docs/operations/README.md">Operaciones</a> ·
<a href="docs/troubleshooting.md">Solución de Problemas</a> ·
<a href="docs/security/README.md">Seguridad</a> ·
<a href="docs/hardware/README.md">Hardware</a> ·
<a href="docs/contributing/README.md">Contribuir</a>
</p>
<p align="center">
<strong>Infraestructura de asistente AI rápida, ligera y completamente autónoma</strong><br />
Despliega en cualquier lugar. Intercambia cualquier cosa.
</p>
<p align="center">
ZeroClaw es el <strong>sistema operativo de runtime</strong> para flujos de trabajo de agentes — una infraestructura que abstrae modelos, herramientas, memoria y ejecución para construir agentes una vez y ejecutarlos en cualquier lugar.
</p>
<p align="center"><code>Arquitectura basada en traits · runtime seguro por defecto · proveedor/canal/herramienta intercambiables · todo es conectable</code></p>
### 📢 Anuncios
Usa esta tabla para avisos importantes (cambios de compatibilidad, avisos de seguridad, ventanas de mantenimiento y bloqueos de versión).
| Fecha (UTC) | Nivel | Aviso | Acción |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Crítico_ | **No estamos afiliados** con `openagen/zeroclaw` o `zeroclaw.org`. El dominio `zeroclaw.org` apunta actualmente al fork `openagen/zeroclaw`, y este dominio/repositorio está suplantando nuestro sitio web/proyecto oficial. | No confíes en información, binarios, recaudaciones de fondos o anuncios de estas fuentes. Usa solo [este repositorio](https://github.com/zeroclaw-labs/zeroclaw) y nuestras cuentas sociales verificadas. |
| 2026-02-21 | _Importante_ | Nuestro sitio web oficial ahora está en línea: [zeroclawlabs.ai](https://zeroclawlabs.ai). Gracias por tu paciencia durante la espera. Todavía detectamos intentos de suplantación: no participes en ninguna actividad de inversión/financiamiento en nombre de ZeroClaw si no se publica a través de nuestros canales oficiales. | Usa [este repositorio](https://github.com/zeroclaw-labs/zeroclaw) como la única fuente de verdad. Sigue [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (grupo)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), y [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) para actualizaciones oficiales. |
| 2026-02-19 | _Importante_ | Anthropic actualizó los términos de uso de autenticación y credenciales el 2026-02-19. La autenticación OAuth (Free, Pro, Max) es exclusivamente para Claude Code y Claude.ai; el uso de tokens OAuth de Claude Free/Pro/Max en cualquier otro producto, herramienta o servicio (incluyendo Agent SDK) no está permitido y puede violar los Términos de Uso del Consumidor. | Por favor, evita temporalmente las integraciones OAuth de Claude Code para prevenir cualquier pérdida potencial. Cláusula original: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Características
- 🏎️ **Runtime Ligero por Defecto:** Los flujos de trabajo CLI comunes y comandos de estado se ejecutan dentro de un espacio de memoria de pocos megabytes en builds de producción.
- 💰 **Despliegue Económico:** Diseñado para placas de bajo costo e instancias cloud pequeñas sin dependencias de runtime pesadas.
- ⚡ **Inicios en Frío Rápidos:** El runtime Rust de binario único mantiene el inicio de comandos y demonios casi instantáneo para operaciones diarias.
- 🌍 **Arquitectura Portátil:** Un flujo de trabajo de binario único en ARM, x86 y RISC-V con proveedor/canal/herramienta intercambiables.
### Por qué los equipos eligen ZeroClaw
- **Ligero por defecto:** binario Rust pequeño, inicio rápido, huella de memoria baja.
- **Seguro por diseño:** emparejamiento, sandboxing estricto, listas permitidas explícitas, alcance de workspace.
- **Completamente intercambiable:** los sistemas centrales son traits (proveedores, canales, herramientas, memoria, túneles).
- **Sin lock-in de proveedor:** soporte de proveedor compatible con OpenAI + endpoints personalizados conectables.
## Instantánea de Benchmark (ZeroClaw vs OpenClaw, Reproducible)
Benchmark rápido en máquina local (macOS arm64, feb. 2026) normalizado para hardware edge de 0.8 GHz.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Lenguaje** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Inicio (núcleo 0.8 GHz)** | > 500s | > 30s | < 1s | **< 10ms** |
| **Tamaño Binario** | ~28 MB (dist) | N/A (Scripts) | ~8 MB | **3.4 MB** |
| **Costo** | Mac Mini $599 | Linux SBC ~$50 | Placa Linux $10 | **Cualquier hardware $10** |
> Notas: Los resultados de ZeroClaw se miden en builds de producción usando `/usr/bin/time -l`. OpenClaw requiere el runtime Node.js (típicamente ~390 MB de sobrecarga de memoria adicional), mientras que NanoBot requiere el runtime Python. PicoClaw y ZeroClaw son binarios estáticos. Las cifras de RAM anteriores son memoria de runtime; los requisitos de compilación en tiempo de build son mayores.
<p align="center">
<img src="zero-claw.jpeg" alt="Comparación ZeroClaw vs OpenClaw" width="800" />
</p>
### Medición Local Reproducible
Las afirmaciones de benchmark pueden derivar a medida que el código y las toolchains evolucionan, así que siempre mide tu build actual localmente:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Ejemplo de muestra (macOS arm64, medido el 18 de febrero de 2026):
- Tamaño de binario release: `8.8M`
- `zeroclaw --help`: tiempo real aprox `0.02s`, huella de memoria máxima ~`3.9 MB`
- `zeroclaw status`: tiempo real aprox `0.01s`, huella de memoria máxima ~`4.1 MB`
## Requisitos Previos
<details>
<summary><strong>Windows</strong></summary>
### Windows — Requerido
1. **Visual Studio Build Tools** (proporciona el linker MSVC y el Windows SDK):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Durante la instalación (o a través de Visual Studio Installer), selecciona la carga de trabajo **"Desarrollo de escritorio con C++"**.
2. **Toolchain Rust:**
```powershell
winget install Rustlang.Rustup
```
Después de la instalación, abre una nueva terminal y ejecuta `rustup default stable` para asegurar que la toolchain estable esté activa.
3. **Verifica** que ambos funcionan:
```powershell
rustc --version
cargo --version
```
### Windows — Opcional
- **Docker Desktop** — requerido solo si usas el [runtime sandboxed Docker](#soporte-de-runtime-actual) (`runtime.kind = "docker"`). Instala vía `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Requerido
1. **Herramientas de compilación esenciales:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Instala Xcode Command Line Tools: `xcode-select --install`
2. **Toolchain Rust:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Ver [rustup.rs](https://rustup.rs) para detalles.
3. **Verifica:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — Opcional
- **Docker** — requerido solo si usas el [runtime sandboxed Docker](#soporte-de-runtime-actual) (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** ver [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** ver [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** instala Docker Desktop vía [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## Inicio Rápido
### Opción 1: Configuración automatizada (recomendada)
El script `bootstrap.sh` instala Rust, clona ZeroClaw, lo compila, y configura tu entorno de desarrollo inicial:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
Esto:
1. Instalará Rust (si no está presente)
2. Clonará el repositorio ZeroClaw
3. Compilará ZeroClaw en modo release
4. Instalará `zeroclaw` en `~/.cargo/bin/`
5. Creará la estructura de workspace por defecto en `~/.zeroclaw/workspace/`
6. Generará un archivo de configuración inicial `~/.zeroclaw/workspace/config.toml`
Después del bootstrap, recarga tu shell o ejecuta `source ~/.cargo/env` para usar el comando `zeroclaw` globalmente.
### Opción 2: Instalación manual
<details>
<summary><strong>Clic para ver los pasos de instalación manual</strong></summary>
```bash
# 1. Clona el repositorio
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. Compila en release
cargo build --release --locked
# 3. Instala el binario
cargo install --path . --locked
# 4. Inicializa el workspace
zeroclaw init
# 5. Verifica la instalación
zeroclaw --version
zeroclaw status
```
</details>
### Después de la instalación
Una vez instalado (vía bootstrap o manualmente), deberías ver:
```
~/.zeroclaw/workspace/
├── config.toml # Configuración principal
├── .pairing # Secretos de emparejamiento (generado al primer inicio)
├── logs/ # Logs de daemon/agent
├── skills/ # Habilidades personalizadas
└── memory/ # Almacenamiento de contexto conversacional
```
**Siguientes pasos:**
1. Configura tus proveedores de AI en `~/.zeroclaw/workspace/config.toml`
2. Revisa la [referencia de configuración](docs/config-reference.md) para opciones avanzadas
3. Inicia el agente: `zeroclaw agent start`
4. Prueba vía tu canal preferido (ver [referencia de canales](docs/channels-reference.md))
## Configuración
Edita `~/.zeroclaw/workspace/config.toml` para configurar proveedores, canales y comportamiento del sistema.
### Referencia de Configuración Rápida
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # o "sqlite" o "none"
[runtime]
kind = "native" # o "docker" (requiere Docker)
```
**Documentos de referencia completos:**
- [Referencia de Configuración](docs/config-reference.md) — todos los ajustes, validaciones, valores por defecto
- [Referencia de Proveedores](docs/providers-reference.md) — configuraciones específicas de proveedores de AI
- [Referencia de Canales](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord y más
- [Operaciones](docs/operations-runbook.md) — monitoreo en producción, rotación de secretos, escalado
### Soporte de Runtime (actual)
ZeroClaw soporta dos backends de ejecución de código:
- **`native`** (por defecto) — ejecución de proceso directo, camino más rápido, ideal para entornos de confianza
- **`docker`** — aislamiento completo de contenedor, políticas de seguridad reforzadas, requiere Docker
Usa `runtime.kind = "docker"` si necesitas sandboxing estricto o aislamiento de red. Ver [referencia de configuración](docs/config-reference.md#runtime) para detalles completos.
## Comandos
```bash
# Gestión de workspace
zeroclaw init # Inicializa un nuevo workspace
zeroclaw status # Muestra estado de daemon/agent
zeroclaw config validate # Verifica sintaxis y valores de config.toml
# Gestión de daemon
zeroclaw daemon start # Inicia el daemon en segundo plano
zeroclaw daemon stop # Detiene el daemon en ejecución
zeroclaw daemon restart # Reinicia el daemon (recarga de config)
zeroclaw daemon logs # Muestra logs del daemon
# Gestión de agent
zeroclaw agent start # Inicia el agent (requiere daemon ejecutándose)
zeroclaw agent stop # Detiene el agent
zeroclaw agent restart # Reinicia el agent (recarga de config)
# Operaciones de emparejamiento
zeroclaw pairing init # Genera un nuevo secreto de emparejamiento
zeroclaw pairing rotate # Rota el secreto de emparejamiento existente
# Tunneling (para exposición pública)
zeroclaw tunnel start # Inicia un tunnel hacia el daemon local
zeroclaw tunnel stop # Detiene el tunnel activo
# Diagnóstico
zeroclaw doctor # Ejecuta verificaciones de salud del sistema
zeroclaw version # Muestra versión e información de build
```
Ver [Referencia de Comandos](docs/commands-reference.md) para opciones y ejemplos completos.
## Arquitectura
```
┌─────────────────────────────────────────────────────────────────┐
│ Canales (trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Orquestador Agent │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Ruteo │ │ Contexto │ │ Ejecución │ │
│ │ Mensaje │ │ Memoria │ │ Herramienta│ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Proveedores │ │ Memoria │ │ Herramientas │
│ (trait) │ │ (trait) │ │ (trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Runtime (trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Principios clave:**
- Todo es un **trait** — proveedores, canales, herramientas, memoria, túneles
- Los canales llaman al orquestador; el orquestador llama a proveedores + herramientas
- El sistema de memoria gestiona contexto conversacional (markdown, SQLite, o ninguno)
- El runtime abstrae la ejecución de código (nativo o Docker)
- Sin lock-in de proveedor — intercambia Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama sin cambios de código
Ver [documentación de arquitectura](docs/architecture.svg) para diagramas detallados y detalles de implementación.
## Ejemplos
### Bot de Telegram
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Tu ID de usuario de Telegram
```
Inicia el daemon + agent, luego envía un mensaje a tu bot en Telegram:
```
/start
¡Hola! ¿Podrías ayudarme a escribir un script Python?
```
El bot responde con código generado por AI, ejecuta herramientas si se solicita, y mantiene el contexto de conversación.
### Matrix (cifrado extremo a extremo)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Invita a `@zeroclaw:matrix.org` a una sala cifrada, y el bot responderá con cifrado completo. Ver [Guía Matrix E2EE](docs/matrix-e2ee-guide.md) para configuración de verificación de dispositivo.
### Multi-Proveedor
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Failover en error de proveedor
```
Si Anthropic falla o tiene rate-limit, el orquestador hace failover automáticamente a OpenAI.
### Memoria Personalizada
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # Purga automática después de 90 días
```
O usa Markdown para almacenamiento legible por humanos:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Ver [Referencia de Configuración](docs/config-reference.md#memory) para todas las opciones de memoria.
## Soporte de Proveedor
| Proveedor | Estado | API Key | Modelos de Ejemplo |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Estable | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Estable | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Estable | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Estable | N/A (local) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Estable | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Estable | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Planificado | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Planificado | `COHERE_API_KEY` | TBD |
### Endpoints Personalizados
ZeroClaw soporta endpoints compatibles con OpenAI:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Ejemplo: usa [LiteLLM](https://github.com/BerriAI/litellm) como proxy para acceder a cualquier LLM vía interfaz OpenAI.
Ver [Referencia de Proveedores](docs/providers-reference.md) para detalles de configuración completos.
## Soporte de Canal
| Canal | Estado | Autenticación | Notas |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Estable | Bot Token | Soporte completo incluyendo archivos, imágenes, botones inline |
| **Matrix** | ✅ Estable | Contraseña o Token | Soporte E2EE con verificación de dispositivo |
| **Slack** | 🚧 Planificado | OAuth o Bot Token | Requiere acceso a workspace |
| **Discord** | 🚧 Planificado | Bot Token | Requiere permisos de guild |
| **WhatsApp** | 🚧 Planificado | Twilio o API oficial | Requiere cuenta business |
| **CLI** | ✅ Estable | Ninguno | Interfaz conversacional directa |
| **Web** | 🚧 Planificado | API Key o OAuth | Interfaz de chat basada en navegador |
Ver [Referencia de Canales](docs/channels-reference.md) para instrucciones de configuración completas.
## Soporte de Herramientas
ZeroClaw proporciona herramientas integradas para ejecución de código, acceso al sistema de archivos y recuperación web:
| Herramienta | Descripción | Runtime Requerido |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Ejecuta comandos shell | Nativo o Docker |
| **python** | Ejecuta scripts Python | Python 3.8+ (nativo) o Docker |
| **javascript** | Ejecuta código Node.js | Node.js 18+ (nativo) o Docker |
| **filesystem_read** | Lee archivos | Nativo o Docker |
| **filesystem_write** | Escribe archivos | Nativo o Docker |
| **web_fetch** | Obtiene contenido web | Nativo o Docker |
### Seguridad de Ejecución
- **Runtime Nativo** — se ejecuta como proceso de usuario del daemon, acceso completo al sistema de archivos
- **Runtime Docker** — aislamiento completo de contenedor, sistemas de archivos y redes separados
Configura la política de ejecución en `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Lista permitida explícita
```
Ver [Referencia de Configuración](docs/config-reference.md#runtime) para opciones de seguridad completas.
## Despliegue
### Despliegue Local (Desarrollo)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Despliegue en Servidor (Producción)
Usa systemd para gestionar el daemon y agent como servicios:
```bash
# Instala el binario
cargo install --path . --locked
# Configura el workspace
zeroclaw init
# Crea archivos de servicio systemd
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# Habilita e inicia los servicios
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# Verifica el estado
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Ver [Guía de Despliegue de Red](docs/network-deployment.md) para instrucciones completas de despliegue en producción.
### Docker
```bash
# Compila la imagen
docker build -t zeroclaw:latest .
# Ejecuta el contenedor
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Ver [`Dockerfile`](Dockerfile) para detalles de build y opciones de configuración.
### Hardware Edge
ZeroClaw está diseñado para ejecutarse en hardware de bajo consumo:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, núcleo ARMv8 único, < $5 costo de hardware
- **Raspberry Pi 4/5** — 1 GB+ RAM, multi-núcleo, ideal para workloads concurrentes
- **Orange Pi Zero 2** — ~512 MB RAM, quad-core ARMv8, costo ultra-bajo
- **SBCs x86 (Intel N100)** — 4-8 GB RAM, builds rápidos, soporte Docker nativo
Ver [Guía de Hardware](docs/hardware/README.md) para instrucciones de configuración específicas por dispositivo.
## Tunneling (Exposición Pública)
Expón tu daemon ZeroClaw local a la red pública vía túneles seguros:
```bash
zeroclaw tunnel start --provider cloudflare
```
Proveedores de tunnel soportados:
- **Cloudflare Tunnel** — HTTPS gratis, sin exposición de puertos, soporte multi-dominio
- **Ngrok** — configuración rápida, dominios personalizados (plan de pago)
- **Tailscale** — red mesh privada, sin puerto público
Ver [Referencia de Configuración](docs/config-reference.md#tunnel) para opciones de configuración completas.
## Seguridad
ZeroClaw implementa múltiples capas de seguridad:
### Emparejamiento
El daemon genera un secreto de emparejamiento al primer inicio almacenado en `~/.zeroclaw/workspace/.pairing`. Los clientes (agent, CLI) deben presentar este secreto para conectarse.
```bash
zeroclaw pairing rotate # Genera un nuevo secreto e invalida el anterior
```
### Sandboxing
- **Runtime Docker** — aislamiento completo de contenedor con sistemas de archivos y redes separados
- **Runtime Nativo** — se ejecuta como proceso de usuario, con alcance de workspace por defecto
### Listas Permitidas
Los canales pueden restringir acceso por ID de usuario:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Lista permitida explícita
```
### Cifrado
- **Matrix E2EE** — cifrado extremo a extremo completo con verificación de dispositivo
- **Transporte TLS** — todo el tráfico de API y tunnel usa HTTPS/TLS
Ver [Documentación de Seguridad](docs/security/README.md) para políticas y prácticas completas.
## Observabilidad
ZeroClaw registra logs en `~/.zeroclaw/workspace/logs/` por defecto. Los logs se almacenan por componente:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Logs del daemon (inicio, solicitudes API, errores)
├── agent.log # Logs del agent (ruteo de mensajes, ejecución de herramientas)
├── telegram.log # Logs específicos del canal (si está habilitado)
└── matrix.log # Logs específicos del canal (si está habilitado)
```
### Configuración de Logging
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # Para rotación basada en tamaño
retention_days = 30 # Purga automática después de N días
```
Ver [Referencia de Configuración](docs/config-reference.md#logging) para todas las opciones de logging.
### Métricas (Planificado)
Soporte de métricas Prometheus para monitoreo en producción próximamente. Seguimiento en [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## Habilidades (Skills)
ZeroClaw soporta habilidades personalizadas — módulos reutilizables que extienden las capacidades del sistema.
### Definición de Habilidad
Las habilidades se almacenan en `~/.zeroclaw/workspace/skills/<skill-name>/` con esta estructura:
```
skills/
└── my-skill/
├── skill.toml # Metadatos de habilidad (nombre, descripción, dependencias)
├── prompt.md # Prompt de sistema para la AI
└── tools/ # Herramientas personalizadas opcionales
└── my_tool.py
```
### Ejemplo de Habilidad
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Busca en la web y resume resultados"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
Eres un asistente de investigación. Cuando te pidan buscar algo:
1. Usa web_fetch para obtener el contenido
2. Resume los resultados en un formato fácil de leer
3. Cita las fuentes con URLs
```
### Uso de Habilidades
Las habilidades se cargan automáticamente al inicio del agent. Referéncialas por nombre en conversaciones:
```
Usuario: Usa la habilidad web-research para encontrar las últimas noticias de AI
Bot: [carga la habilidad web-research, ejecuta web_fetch, resume resultados]
```
Ver sección [Habilidades (Skills)](#habilidades-skills) para instrucciones completas de creación de habilidades.
## Open Skills
ZeroClaw soporta [Open Skills](https://github.com/openagents-com/open-skills) — un sistema modular y agnóstico de proveedores para extender capacidades de agentes AI.
### Habilitar Open Skills
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # opcional
```
También puedes sobrescribir en runtime con `ZEROCLAW_OPEN_SKILLS_ENABLED` y `ZEROCLAW_OPEN_SKILLS_DIR`.
## Desarrollo
```bash
cargo build # Build de desarrollo
cargo build --release # Build release (codegen-units=1, funciona en todos los dispositivos incluyendo Raspberry Pi)
cargo build --profile release-fast # Build más rápido (codegen-units=8, requiere 16 GB+ RAM)
cargo test # Ejecuta el suite de pruebas completo
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Formato
# Ejecuta el benchmark de comparación SQLite vs Markdown
cargo test --test memory_comparison -- --nocapture
```
### Hook pre-push
Un hook de git ejecuta `cargo fmt --check`, `cargo clippy -- -D warnings`, y `cargo test` antes de cada push. Actívalo una vez:
```bash
git config core.hooksPath .githooks
```
### Solución de Problemas de Build (errores OpenSSL en Linux)
Si encuentras un error de build `openssl-sys`, sincroniza dependencias y recompila con el lockfile del repositorio:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw está configurado para usar `rustls` para dependencias HTTP/TLS; `--locked` mantiene el grafo transitivo determinista en entornos limpios.
Para saltar el hook cuando necesites un push rápido durante desarrollo:
```bash
git push --no-verify
```
## Colaboración y Docs
Comienza con el hub de documentación para un mapa basado en tareas:
- Hub de Documentación: [`docs/README.md`](docs/README.md)
- Tabla de Contenidos Unificada de Docs: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Referencia de Comandos: [`docs/commands-reference.md`](docs/commands-reference.md)
- Referencia de Configuración: [`docs/config-reference.md`](docs/config-reference.md)
- Referencia de Proveedores: [`docs/providers-reference.md`](docs/providers-reference.md)
- Referencia de Canales: [`docs/channels-reference.md`](docs/channels-reference.md)
- Runbook de Operaciones: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Solución de Problemas: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Inventario/Clasificación de Docs: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- Snapshot de Triage de PR/Issue (al 18 de feb. de 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Referencias principales de colaboración:
- Hub de Documentación: [docs/README.md](docs/README.md)
- Plantilla de Documentación: [docs/doc-template.md](docs/doc-template.md)
- Checklist de Cambio de Documentación: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Referencia de Configuración de Canales: [docs/channels-reference.md](docs/channels-reference.md)
- Operaciones de Salas Cifradas Matrix: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Guía de Contribución: [CONTRIBUTING.md](CONTRIBUTING.md)
- Política de Flujo de Trabajo PR: [docs/pr-workflow.md](docs/pr-workflow.md)
- Playbook del Revisor (triage + revisión profunda): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Mapa de Propiedad y Triage CI: [docs/ci-map.md](docs/ci-map.md)
- Política de Divulgación de Seguridad: [SECURITY.md](SECURITY.md)
Para despliegue y operaciones de runtime:
- Guía de Despliegue de Red: [docs/network-deployment.md](docs/network-deployment.md)
- Playbook de Agent Proxy: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## Apoyar a ZeroClaw
Si ZeroClaw ayuda a tu trabajo y deseas apoyar el desarrollo continuo, puedes donar aquí:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Cómprame un Café" /></a>
### 🙏 Agradecimientos Especiales
Un sincero agradecimiento a las comunidades e instituciones que inspiran y alimentan este trabajo de código abierto:
- **Harvard University** — por fomentar la curiosidad intelectual y empujar los límites de lo posible.
- **MIT** — por defender el conocimiento abierto, el código abierto, y la convicción de que la tecnología debería ser accesible para todos.
- **Sundai Club** — por la comunidad, la energía, y la voluntad incesante de construir cosas que importan.
- **El Mundo y Más Allá** 🌍✨ — a cada contribuyente, soñador, y constructor allá afuera que hace del código abierto una fuerza para el bien. Esto es por ti.
Construimos en código abierto porque las mejores ideas vienen de todas partes. Si estás leyendo esto, eres parte de esto. Bienvenido. 🦀❤️
## ⚠️ Repositorio Oficial y Advertencia de Suplantación
**Este es el único repositorio oficial de ZeroClaw:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Cualquier otro repositorio, organización, dominio o paquete que afirme ser "ZeroClaw" o que implique afiliación con ZeroClaw Labs es **no autorizado y no está afiliado con este proyecto**. Los forks no autorizados conocidos serán listados en [TRADEMARK.md](TRADEMARK.md).
Si encuentras suplantación o uso indebido de marca, por favor [abre un issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## Licencia
ZeroClaw tiene doble licencia para máxima apertura y protección de contribuyentes:
| Licencia | Casos de Uso |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Código abierto, investigación, académico, uso personal |
| [Apache 2.0](LICENSE-APACHE) | Protección de patentes, institucional, despliegue comercial |
Puedes elegir cualquiera de las dos licencias. **Los contribuyentes otorgan automáticamente derechos bajo ambas** — ver [CLA.md](CLA.md) para el acuerdo de contribuyente completo.
### Marca
El nombre **ZeroClaw** y el logo son marcas registradas de ZeroClaw Labs. Esta licencia no otorga permiso para usarlos para implicar aprobación o afiliación. Ver [TRADEMARK.md](TRADEMARK.md) para usos permitidos y prohibidos.
### Protecciones del Contribuyente
- **Mantienes los derechos de autor** de tus contribuciones
- **Concesión de patentes** (Apache 2.0) te protege contra reclamos de patentes por otros contribuyentes
- Tus contribuciones son **atribuidas permanentemente** en el historial de commits y [NOTICE](NOTICE)
- No se transfieren derechos de marca al contribuir
## Contribuir
Ver [CONTRIBUTING.md](CONTRIBUTING.md) y [CLA.md](CLA.md). Implementa un trait, envía una PR:
- Guía de flujo de trabajo CI: [docs/ci-map.md](docs/ci-map.md)
- Nuevo `Provider``src/providers/`
- Nuevo `Channel``src/channels/`
- Nuevo `Observer``src/observability/`
- Nuevo `Tool``src/tools/`
- Nueva `Memory``src/memory/`
- Nuevo `Tunnel``src/tunnel/`
- Nueva `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Cero sobrecarga. Cero compromiso. Despliega en cualquier lugar. Intercambia cualquier cosa. 🦀
## Historial de Estrellas
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Gráfico de Historial de Estrellas" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

179
README.fi.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Noll overhead. Noll kompromissi. 100% Rust. 100% Agnostinen.</strong><br>
⚡️ <strong>Ajaa $10 laitteistolla <5MB RAM:lla: Tämä on 99% vähemmän muistia kuin OpenClaw ja 98% halvempi kuin Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Kielet:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## Mikä on ZeroClaw?
ZeroClaw on kevyt, muokattava ja laajennettava AI-assistentti-infrastruktuuri, joka on rakennettu Rustilla. Se yhdistää eri LLM-palveluntarjoajat (Anthropic, OpenAI, Google, Ollama jne.) yhtenäisen käyttöliittymän kautta ja tukee useita kanavia (Telegram, Matrix, CLI jne.).
### Keskeiset Ominaisuudet
- **🦀 Kirjoitettu Rustilla**: Korkea suorituskyky, muistiturvallisuus ja nollakustannus-abstraktiot
- **🔌 Palveluntarjoaja-agnostinen**: Tukee OpenAI, Anthropic, Google Gemini, Ollama ja muita
- **📱 Monikanavainen**: Telegram, Matrix (E2EE:llä), CLI ja muut
- **🧠 Pluggaava muisti**: SQLite ja Markdown-backendit
- **🛠️ Laajennettavat työkalut**: Lisää mukautettuja työkaluja helposti
- **🔒 Turvallisuus edellä**: Käänteinen proxy, yksityisyys-edellä-suunnittelu
---
## Pika-aloitus
### Vaatimukset
- Rust 1.70+
- LLM-palveluntarjoajan API-avain (Anthropic, OpenAI jne.)
### Asennus
```bash
# Kloonaa repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Rakenna
cargo build --release
# Aja
cargo run --release
```
### Dockerilla
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Konfiguraatio
ZeroClaw käyttää YAML-konfiguraatiotiedostoa. Oletuksena se etsii `config.yaml`.
```yaml
# Oletuspalveluntarjoaja
provider: anthropic
# Palveluntarjoajien konfiguraatio
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Muistin konfiguraatio
memory:
backend: sqlite
path: data/memory.db
# Kanavien konfiguraatio
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Dokumentaatio
Yksityiskohtaista dokumentaatiota varten katso:
- [Dokumentaatiokeskus](docs/README.md)
- [Komentojen Viite](docs/commands-reference.md)
- [Palveluntarjoajien Viite](docs/providers-reference.md)
- [Kanavien Viite](docs/channels-reference.md)
- [Konfiguraation Viite](docs/config-reference.md)
---
## Osallistuminen
Osallistumiset ovat tervetulleita! Lue [Osallistumisopas](CONTRIBUTING.md).
---
## Lisenssi
Tämä projekti on kaksoislisensoitu:
- MIT License
- Apache License, versio 2.0
Katso [LICENSE-APACHE](LICENSE-APACHE) ja [LICENSE-MIT](LICENSE-MIT) yksityiskohdille.
---
## Yhteisö
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Sponsorit
Jos ZeroClaw on hyödyllinen sinulle, harkitse kahvin ostamista meille:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

View File

@ -1,5 +1,5 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
<img src="docs/assets/zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
@ -25,12 +25,43 @@ Construit par des étudiants et membres des communautés Harvard, MIT et Sundai.
</p>
<p align="center">
🌐 <strong>Langues :</strong> <a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.ru.md">Русский</a> · <a href="README.fr.md">Français</a> · <a href="README.vi.md">Tiếng Việt</a>
🌐 <strong>Langues :</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#démarrage-rapide">Démarrage</a> |
<a href="bootstrap.sh">Configuration en un clic</a> |
<a href="install.sh">Configuration en un clic</a> |
<a href="docs/README.md">Hub Documentation</a> |
<a href="docs/SUMMARY.md">Table des matières Documentation</a>
</p>
@ -38,8 +69,8 @@ Construit par des étudiants et membres des communautés Harvard, MIT et Sundai.
<p align="center">
<strong>Accès rapides :</strong>
<a href="docs/reference/README.md">Référence</a> ·
<a href="docs/operations/README.md">Opérations</a> ·
<a href="docs/troubleshooting.md">Dépannage</a> ·
<a href="docs/ops/README.md">Opérations</a> ·
<a href="docs/ops/troubleshooting.md">Dépannage</a> ·
<a href="docs/security/README.md">Sécurité</a> ·
<a href="docs/hardware/README.md">Matériel</a> ·
<a href="docs/contributing/README.md">Contribuer</a>
@ -95,7 +126,7 @@ Benchmark rapide sur machine locale (macOS arm64, fév. 2026) normalisé pour ma
> Notes : Les résultats ZeroClaw sont mesurés sur des builds de production utilisant `/usr/bin/time -l`. OpenClaw nécessite le runtime Node.js (typiquement ~390 Mo de surcharge mémoire supplémentaire), tandis que NanoBot nécessite le runtime Python. PicoClaw et ZeroClaw sont des binaires statiques. Les chiffres RAM ci-dessus sont la mémoire runtime ; les exigences de compilation build-time sont plus élevées.
<p align="center">
<img src="zero-claw.jpeg" alt="Comparaison ZeroClaw vs OpenClaw" width="800" />
<img src="docs/assets/zeroclaw-comparison.jpeg" alt="Comparaison ZeroClaw vs OpenClaw" width="800" />
</p>
### Mesure locale reproductible
@ -188,10 +219,10 @@ Exemple d'échantillon (macOS arm64, mesuré le 18 février 2026) :
### Option 1 : Configuration automatisée (recommandée)
Le script `bootstrap.sh` installe Rust, clone ZeroClaw, le compile, et configure votre environnement de développement initial :
Le script `install.sh` installe Rust, clone ZeroClaw, le compile, et configure votre environnement de développement initial :
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/install.sh | bash
```
Ceci va :
@ -247,9 +278,9 @@ Une fois installé (via bootstrap ou manuellement), vous devriez voir :
**Prochaines étapes :**
1. Configurez vos fournisseurs d'IA dans `~/.zeroclaw/workspace/config.toml`
2. Consultez la [référence de configuration](docs/config-reference.md) pour les options avancées
2. Consultez la [référence de configuration](docs/reference/api/config-reference.md) pour les options avancées
3. Lancez l'agent : `zeroclaw agent start`
4. Testez via votre canal préféré (voir [référence des canaux](docs/channels-reference.md))
4. Testez via votre canal préféré (voir [référence des canaux](docs/reference/api/channels-reference.md))
## Configuration
@ -285,10 +316,10 @@ kind = "native" # ou "docker" (nécessite Docker)
**Documents de référence complets :**
- [Référence de Configuration](docs/config-reference.md) — tous les paramètres, validations, valeurs par défaut
- [Référence des Fournisseurs](docs/providers-reference.md) — configurations spécifiques aux fournisseurs d'IA
- [Référence des Canaux](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord et plus
- [Opérations](docs/operations-runbook.md) — surveillance en production, rotation des secrets, mise à l'échelle
- [Référence de Configuration](docs/reference/api/config-reference.md) — tous les paramètres, validations, valeurs par défaut
- [Référence des Fournisseurs](docs/reference/api/providers-reference.md) — configurations spécifiques aux fournisseurs d'IA
- [Référence des Canaux](docs/reference/api/channels-reference.md) — Telegram, Matrix, Slack, Discord et plus
- [Opérations](docs/ops/operations-runbook.md) — surveillance en production, rotation des secrets, mise à l'échelle
### Support Runtime (actuel)
@ -297,7 +328,7 @@ ZeroClaw prend en charge deux backends d'exécution de code :
- **`native`** (par défaut) — exécution de processus directe, chemin le plus rapide, idéal pour les environnements de confiance
- **`docker`** — isolation complète du conteneur, politiques de sécurité renforcées, nécessite Docker
Utilisez `runtime.kind = "docker"` si vous avez besoin d'un sandboxing strict ou de l'isolation réseau. Voir [référence de configuration](docs/config-reference.md#runtime) pour les détails complets.
Utilisez `runtime.kind = "docker"` si vous avez besoin d'un sandboxing strict ou de l'isolation réseau. Voir [référence de configuration](docs/reference/api/config-reference.md#runtime) pour les détails complets.
## Commandes
@ -331,7 +362,7 @@ zeroclaw doctor # Exécute les vérifications de santé du système
zeroclaw version # Affiche la version et les informations de build
```
Voir [Référence des Commandes](docs/commands-reference.md) pour les options et exemples complets.
Voir [Référence des Commandes](docs/reference/cli/commands-reference.md) pour les options et exemples complets.
## Architecture
@ -378,7 +409,7 @@ Voir [Référence des Commandes](docs/commands-reference.md) pour les options et
- Le runtime abstrait l'exécution de code (natif ou Docker)
- Aucun verrouillage de fournisseur — échangez Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama sans changement de code
Voir [documentation architecture](docs/architecture.svg) pour les diagrammes détaillés et les détails d'implémentation.
Voir [documentation architecture](docs/assets/architecture.svg) pour les diagrammes détaillés et les détails d'implémentation.
## Exemples
@ -412,7 +443,7 @@ device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Invitez `@zeroclaw:matrix.org` dans une salle chiffrée, et le bot répondra avec le chiffrement complet. Voir [Guide Matrix E2EE](docs/matrix-e2ee-guide.md) pour la configuration de vérification de dispositif.
Invitez `@zeroclaw:matrix.org` dans une salle chiffrée, et le bot répondra avec le chiffrement complet. Voir [Guide Matrix E2EE](docs/security/matrix-e2ee-guide.md) pour la configuration de vérification de dispositif.
### Multi-Fournisseur
@ -451,7 +482,7 @@ kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Voir [Référence de Configuration](docs/config-reference.md#memory) pour toutes les options mémoire.
Voir [Référence de Configuration](docs/reference/api/config-reference.md#memory) pour toutes les options mémoire.
## Support de Fournisseur
@ -480,7 +511,7 @@ model = "your-model-name"
Exemple : utilisez [LiteLLM](https://github.com/BerriAI/litellm) comme proxy pour accéder à n'importe quel LLM via l'interface OpenAI.
Voir [Référence des Fournisseurs](docs/providers-reference.md) pour les détails de configuration complets.
Voir [Référence des Fournisseurs](docs/reference/api/providers-reference.md) pour les détails de configuration complets.
## Support de Canal
@ -494,7 +525,7 @@ Voir [Référence des Fournisseurs](docs/providers-reference.md) pour les détai
| **CLI** | ✅ Stable | Aucun | Interface conversationnelle directe |
| **Web** | 🚧 Planifié | Clé API ou OAuth | Interface de chat basée navigateur |
Voir [Référence des Canaux](docs/channels-reference.md) pour les instructions de configuration complètes.
Voir [Référence des Canaux](docs/reference/api/channels-reference.md) pour les instructions de configuration complètes.
## Support d'Outil
@ -522,7 +553,7 @@ kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Liste d'autorisation explicite
```
Voir [Référence de Configuration](docs/config-reference.md#runtime) pour les options de sécurité complètes.
Voir [Référence de Configuration](docs/reference/api/config-reference.md#runtime) pour les options de sécurité complètes.
## Déploiement
@ -557,7 +588,7 @@ sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Voir [Guide de Déploiement Réseau](docs/network-deployment.md) pour les instructions de déploiement en production complètes.
Voir [Guide de Déploiement Réseau](docs/ops/network-deployment.md) pour les instructions de déploiement en production complètes.
### Docker
@ -600,7 +631,7 @@ Fournisseurs de tunnel supportés :
- **Ngrok** — configuration rapide, domaines personnalisés (plan payant)
- **Tailscale** — réseau maillé privé, pas de port public
Voir [Référence de Configuration](docs/config-reference.md#tunnel) pour les options de configuration complètes.
Voir [Référence de Configuration](docs/reference/api/config-reference.md#tunnel) pour les options de configuration complètes.
## Sécurité
@ -659,7 +690,7 @@ max_size_mb = 100 # Pour rotation basée sur la taille
retention_days = 30 # Purge automatique après N jours
```
Voir [Référence de Configuration](docs/config-reference.md#logging) pour toutes les options de journalisation.
Voir [Référence de Configuration](docs/reference/api/config-reference.md#logging) pour toutes les options de journalisation.
### Métriques (Planifié)
@ -776,32 +807,32 @@ Commencez par le hub de documentation pour une carte basée sur les tâches :
- Hub de documentation : [`docs/README.md`](docs/README.md)
- Table des matières unifiée docs : [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Référence des commandes : [`docs/commands-reference.md`](docs/commands-reference.md)
- Référence de configuration : [`docs/config-reference.md`](docs/config-reference.md)
- Référence des fournisseurs : [`docs/providers-reference.md`](docs/providers-reference.md)
- Référence des canaux : [`docs/channels-reference.md`](docs/channels-reference.md)
- Runbook des opérations : [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Dépannage : [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Inventaire/classification docs : [`docs/docs-inventory.md`](docs/docs-inventory.md)
- Instantané triage PR/Issue (au 18 février 2026) : [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
- Référence des commandes : [`docs/reference/cli/commands-reference.md`](docs/reference/cli/commands-reference.md)
- Référence de configuration : [`docs/reference/api/config-reference.md`](docs/reference/api/config-reference.md)
- Référence des fournisseurs : [`docs/reference/api/providers-reference.md`](docs/reference/api/providers-reference.md)
- Référence des canaux : [`docs/reference/api/channels-reference.md`](docs/reference/api/channels-reference.md)
- Runbook des opérations : [`docs/ops/operations-runbook.md`](docs/ops/operations-runbook.md)
- Dépannage : [`docs/ops/troubleshooting.md`](docs/ops/troubleshooting.md)
- Inventaire/classification docs : [`docs/maintainers/docs-inventory.md`](docs/maintainers/docs-inventory.md)
- Instantané triage PR/Issue (au 18 février 2026) : [`docs/maintainers/project-triage-snapshot-2026-02-18.md`](docs/maintainers/project-triage-snapshot-2026-02-18.md)
Références de collaboration principales :
- Hub de documentation : [docs/README.md](docs/README.md)
- Modèle de documentation : [docs/doc-template.md](docs/doc-template.md)
- Modèle de documentation : [docs/contributing/doc-template.md](docs/contributing/doc-template.md)
- Checklist de modification de documentation : [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Référence de configuration des canaux : [docs/channels-reference.md](docs/channels-reference.md)
- Opérations de salles chiffrées Matrix : [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Référence de configuration des canaux : [docs/reference/api/channels-reference.md](docs/reference/api/channels-reference.md)
- Opérations de salles chiffrées Matrix : [docs/security/matrix-e2ee-guide.md](docs/security/matrix-e2ee-guide.md)
- Guide de contribution : [CONTRIBUTING.md](CONTRIBUTING.md)
- Politique de workflow PR : [docs/pr-workflow.md](docs/pr-workflow.md)
- Playbook du relecteur (triage + revue approfondie) : [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Carte de propriété et triage CI : [docs/ci-map.md](docs/ci-map.md)
- Politique de workflow PR : [docs/contributing/pr-workflow.md](docs/contributing/pr-workflow.md)
- Playbook du relecteur (triage + revue approfondie) : [docs/contributing/reviewer-playbook.md](docs/contributing/reviewer-playbook.md)
- Carte de propriété et triage CI : [docs/contributing/ci-map.md](docs/contributing/ci-map.md)
- Politique de divulgation de sécurité : [SECURITY.md](SECURITY.md)
Pour le déploiement et les opérations runtime :
- Guide de déploiement réseau : [docs/network-deployment.md](docs/network-deployment.md)
- Playbook d'agent proxy : [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
- Guide de déploiement réseau : [docs/ops/network-deployment.md](docs/ops/network-deployment.md)
- Playbook d'agent proxy : [docs/ops/proxy-agent-playbook.md](docs/ops/proxy-agent-playbook.md)
## Soutenir ZeroClaw
@ -826,7 +857,7 @@ Nous construisons en open source parce que les meilleures idées viennent de par
> <https://github.com/zeroclaw-labs/zeroclaw>
Tout autre dépôt, organisation, domaine ou package prétendant être "ZeroClaw" ou impliquant une affiliation avec ZeroClaw Labs est **non autorisé et non affilié à ce projet**. Les forks non autorisés connus seront listés dans [TRADEMARK.md](TRADEMARK.md).
Tout autre dépôt, organisation, domaine ou package prétendant être "ZeroClaw" ou impliquant une affiliation avec ZeroClaw Labs est **non autorisé et non affilié à ce projet**. Les forks non autorisés connus seront listés dans [TRADEMARK.md](docs/maintainers/trademark.md).
Si vous rencontrez une usurpation d'identité ou une utilisation abusive de marque, veuillez [ouvrir une issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
@ -841,11 +872,11 @@ ZeroClaw est sous double licence pour une ouverture maximale et la protection de
| [MIT](LICENSE-MIT) | Open-source, recherche, académique, usage personnel |
| [Apache 2.0](LICENSE-APACHE) | Protection de brevet, institutionnel, déploiement commercial |
Vous pouvez choisir l'une ou l'autre licence. **Les contributeurs accordent automatiquement des droits sous les deux** — voir [CLA.md](CLA.md) pour l'accord de contributeur complet.
Vous pouvez choisir l'une ou l'autre licence. **Les contributeurs accordent automatiquement des droits sous les deux** — voir [CLA.md](docs/contributing/cla.md) pour l'accord de contributeur complet.
### Marque
Le nom **ZeroClaw** et le logo sont des marques déposées de ZeroClaw Labs. Cette licence n'accorde pas la permission de les utiliser pour impliquer une approbation ou une affiliation. Voir [TRADEMARK.md](TRADEMARK.md) pour les utilisations permises et interdites.
Le nom **ZeroClaw** et le logo sont des marques déposées de ZeroClaw Labs. Cette licence n'accorde pas la permission de les utiliser pour impliquer une approbation ou une affiliation. Voir [TRADEMARK.md](docs/maintainers/trademark.md) pour les utilisations permises et interdites.
### Protections des Contributeurs
@ -856,9 +887,9 @@ Le nom **ZeroClaw** et le logo sont des marques déposées de ZeroClaw Labs. Cet
## Contribuer
Voir [CONTRIBUTING.md](CONTRIBUTING.md) et [CLA.md](CLA.md). Implémentez un trait, soumettez une PR :
Voir [CONTRIBUTING.md](CONTRIBUTING.md) et [CLA.md](docs/contributing/cla.md). Implémentez un trait, soumettez une PR :
- Guide de workflow CI : [docs/ci-map.md](docs/ci-map.md)
- Guide de workflow CI : [docs/contributing/ci-map.md](docs/contributing/ci-map.md)
- Nouveau `Provider``src/providers/`
- Nouveau `Channel``src/channels/`
- Nouveau `Observer``src/observability/`

197
README.he.md Normal file
View File

@ -0,0 +1,197 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center" dir="rtl">
<strong>תקורת אפס. אין פשרות. 100% Rust. 100% אגנוסטי.</strong><br>
⚡️ <strong>פועל על חומרה ב-$10 עם <5MB זיכרון: זה 99% פחות זיכרון מ-OpenClaw ו-98% זול יותר מ-Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center" dir="rtl">
🌐 <strong>שפות:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## מה זה ZeroClaw?
<p align="center" dir="rtl">
ZeroClaw הוא תשתית עוזר AI קלת משקל, מוטטבילית וניתנת להרחבה שנבנתה ב-Rust. היא מחברת ספקי LLM שונים (Anthropic, OpenAI, Google, Ollama, וכו') דרך ממשק מאוחד ותומכת בערוצים מרובים (Telegram, Matrix, CLI, וכו').
</p>
### תכונות עיקריות
<p align="center" dir="rtl">
- **🦀 נכתב ב-Rust**: ביצועים גבוהים, אבטחת זיכרון, ואבסטרקציות ללא עלות
- **🔌 אגנוסטי לספקים**: תמיכה ב-OpenAI, Anthropic, Google Gemini, Ollama, ואחרים
- **📱 ערוצים מרובים**: Telegram, Matrix (עם E2EE), CLI, ואחרים
- **🧠 זיכרון ניתן להחלפה**: Backend של SQLite ו-Markdown
- **🛠️ כלים ניתנים להרחבה**: הוסף כלים מותאמים אישית בקלות
- **🔒 אבטחה תחילה**: פרוקסי הפוך, עיצוב מותחל על פרטיות
</p>
---
## התחלה מהירה
### דרישות מוקדמות
<p align="center" dir="rtl">
- Rust 1.70+
- מפתח API של ספק LLM (Anthropic, OpenAI, וכו')
</p>
### התקנה
```bash
# שכפל את המאגר
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# בנה
cargo build --release
# הפעל
cargo run --release
```
### עם Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## קונפיגורציה
<p align="center" dir="rtl">
ZeroClaw משתמש בקובץ קונפיגורציה YAML. כברירת מחדל, הוא מחפש `config.yaml`.
</p>
```yaml
# ספק ברירת מחדל
provider: anthropic
# קונפיגורציית ספקים
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# קונפיגורציית זיכרון
memory:
backend: sqlite
path: data/memory.db
# קונפיגורציית ערוצים
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## תיעוד
<p align="center" dir="rtl">
לתיעוד מפורט, ראה:
</p>
- [מרכז התיעוד](docs/README.md)
- [הפניה לפקודות](docs/commands-reference.md)
- [הפניה לספקים](docs/providers-reference.md)
- [הפניה לערוצים](docs/channels-reference.md)
- [הפניה לקונפיגורציה](docs/config-reference.md)
---
## תרומות
<p align="center" dir="rtl">
תרומות מוזמנות! אנא קרא את [מדריך התרומות](CONTRIBUTING.md).
</p>
---
## רישיון
<p align="center" dir="rtl">
פרויקט זה מורשה ברישיון כפול:
</p>
- MIT License
- Apache License, גרסה 2.0
<p align="center" dir="rtl">
ראה [LICENSE-APACHE](LICENSE-APACHE) ו-[LICENSE-MIT](LICENSE-MIT) לפרטים.
</p>
---
## קהילה
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## נותני חסות
<p align="center" dir="rtl">
אם ZeroClaw שימושי עבורך, אנא שקול לקנות לנו קפה:
</p>
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

179
README.hi.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>शून्य ओवरहेड। शून्य समझौता। 100% रस्ट। 100% अज्ञेयवादी।</strong><br>
⚡️ <strong>$10 हार्डवेयर पर <5MB RAM के चलत है: यह OpenClaw से 99% कम मेम और Mac mini से 98% सस्त है!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>भाषाएँ:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## ZeroClaw क्या है?
ZeroClaw एक हल्का, म्यूटेबल और एक्स्टेंसिबल AI असिस्टेंट इन्फ्रास्ट्रक्चर है जो रस्ट में बनाया गया है। यह विभिन्न LLM प्रदाताओं (Anthropic, OpenAI, Google, Ollama, आदि) को एक एकीकृत इंटरफेस के माध्यम से कनेक्ट करता है और कई चैनलों (Telegram, Matrix, CLI, आदि) का समर्थन करता है।
### मुख्य विशेषताएं
- **🦀 रस्ट में लिखा गया**: उच्च प्रदर्शन, मेमोरी सुरक्षा, और शून्य-लागत एब्सट्रैक्शन
- **🔌 प्रदाता-अज्ञेयवादी**: OpenAI, Anthropic, Google Gemini, Ollama, और अन्य का समर्थन
- **📱 बहु-चैनल**: Telegram, Matrix (E2EE के साथ), CLI, और अन्य
- **🧠 प्लगेबल मेमोरी**: SQLite और Markdown बैकएंड
- **🛠️ विस्तार योग्य टूल**: आसानी से कस्टम टूल जोड़ें
- **🔒 सुरक्षा-पहले**: रिवर्स-प्रॉक्सी, गोपनीयता-पहले डिज़ाइन
---
## त्वरित शुरुआत
### आवश्यकताएं
- रस्ट 1.70+
- एक LLM प्रदाता API कुंजी (Anthropic, OpenAI, आदि)
### इंस्टॉलेशन
```bash
# रिपॉजिटरी क्लोन करें
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# बिल्ड करें
cargo build --release
# चलाएं
cargo run --release
```
### Docker के साथ
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## कॉन्फ़िगरेशन
ZeroClaw एक YAML कॉन्फ़िगरेशन फ़ाइल का उपयोग करता है। डिफ़ॉल्ट रूप से, यह `config.yaml` देखता है।
```yaml
# डिफ़ॉल्ट प्रदाता
provider: anthropic
# प्रदाता कॉन्फ़िगरेशन
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# मेमोरी कॉन्फ़िगरेशन
memory:
backend: sqlite
path: data/memory.db
# चैनल कॉन्फ़िगरेशन
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## दस्तावेज़ीकरण
विस्तृत दस्तावेज़ीकरण के लिए, देखें:
- [दस्तावेज़ीकरण हब](docs/README.md)
- [कमांड संदर्भ](docs/commands-reference.md)
- [प्रदाता संदर्भ](docs/providers-reference.md)
- [चैनल संदर्भ](docs/channels-reference.md)
- [कॉन्फ़िगरेशन संदर्भ](docs/config-reference.md)
---
## योगदान
योगदान का स्वागत है! कृपया [योगदान गाइड](CONTRIBUTING.md) पढ़ें।
---
## लाइसेंस
यह प्रोजेक्ट दोहरे लाइसेंस प्राप्त है:
- MIT लाइसेंस
- Apache लाइसेंस, संस्करण 2.0
विवरण के लिए [LICENSE-APACHE](LICENSE-APACHE) और [LICENSE-MIT](LICENSE-MIT) देखें।
---
## समुदाय
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## प्रायोजक
यदि ZeroClaw आपके लिए उपयोगी है, तो कृपया हमें एक कॉफी खरीदने पर विचार करें:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

179
README.hu.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Nulla többletköltség. Nulla kompromisszum. 100% Rust. 100% Agnosztikus.</strong><br>
⚡️ <strong>$10-es hardveren fut <5MB RAM-mal: Ez 99%-kal kevesebb memória, mint az OpenClaw és 98%-kal olcsóbb, mint egy Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Nyelvek:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## Mi az a ZeroClaw?
A ZeroClaw egy könnyűsúlyú, változtatható és bővíthető AI asszisztens infrastruktúra, amely Rust nyelven készült. Különböző LLM szolgáltatókat (Anthropic, OpenAI, Google, Ollama stb.) köt össze egy egységes felületen keresztül, és több csatornát támogat (Telegram, Matrix, CLI stb.).
### Fő jellemzők
- **🦀 Rust nyelven írva**: Magas teljesítmény, memória biztonság és null költségű absztrakciók
- **🔌 Szolgáltató-agnosztikus**: OpenAI, Anthropic, Google Gemini, Ollama és mások támogatása
- **📱 Többcsatornás**: Telegram, Matrix (E2EE-vel), CLI és mások
- **🧠 Cserélhető memória**: SQLite és Markdown backendek
- **🛠️ Bővíthető eszközök**: Egyszerűen adjon hozzá egyedi eszközöket
- **🔒 Biztonság először**: Fordított proxy, adatvédelem-elsődleges tervezés
---
## Gyors Kezdés
### Követelmények
- Rust 1.70+
- Egy LLM szolgáltató API kulcs (Anthropic, OpenAI stb.)
### Telepítés
```bash
# Klónozza a repositoryt
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Építés
cargo build --release
# Futtatás
cargo run --release
```
### Docker-rel
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Konfiguráció
A ZeroClaw egy YAML konfigurációs fájlt használ. Alapértelmezés szerint a `config.yaml` fájlt keresi.
```yaml
# Alapértelmezett szolgáltató
provider: anthropic
# Szolgáltató konfiguráció
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Memória konfiguráció
memory:
backend: sqlite
path: data/memory.db
# Csatorna konfiguráció
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Dokumentáció
Részletes dokumentációért lásd:
- [Dokumentációs Központ](docs/README.md)
- [Parancs Referencia](docs/commands-reference.md)
- [Szolgáltató Referencia](docs/providers-reference.md)
- [Csatorna Referencia](docs/channels-reference.md)
- [Konfigurációs Referencia](docs/config-reference.md)
---
## Hozzájárulás
A hozzájárulások várják! Kérjük, olvassa el a [Hozzájárulási Útmutatót](CONTRIBUTING.md).
---
## Licenc
Ez a projekt kettős licencelt:
- MIT License
- Apache License, 2.0 verzió
Részletekért lásd a [LICENSE-APACHE](LICENSE-APACHE) és [LICENSE-MIT](LICENSE-MIT) fájlokat.
---
## Közösség
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Szponzorok
Ha a ZeroClaw hasznos az Ön számára, kérjük, fontolja meg, hogy vesz nekünk egy kávét:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

179
README.id.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Nol overhead. Nol kompromi. 100% Rust. 100% Agnostik.</strong><br>
⚡️ <strong>Jalan di perangkat $10 dengan <5MB RAM: Itu 99% lebih sedikit memori dari OpenClaw dan 98% lebih murah dari Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Bahasa:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## Apa itu ZeroClaw?
ZeroClaw adalah infrastruktur asisten AI yang ringan, dapat diubah, dan dapat diperluas yang dibangun dengan Rust. Ini menghubungkan berbagai penyedia LLM (Anthropic, OpenAI, Google, Ollama, dll.) melalui antarmuka terpadu dan mendukung banyak saluran (Telegram, Matrix, CLI, dll.).
### Fitur Utama
- **🦀 Ditulis dalam Rust**: Kinerja tinggi, keamanan memori, dan abstraksi tanpa biaya
- **🔌 Agnostik penyedia**: Mendukung OpenAI, Anthropic, Google Gemini, Ollama, dan lainnya
- **📱 Multi-saluran**: Telegram, Matrix (dengan E2EE), CLI, dan lainnya
- **🧠 Memori yang dapat dipasang**: Backend SQLite dan Markdown
- **🛠️ Alat yang dapat diperluas**: Tambahkan alat kustom dengan mudah
- **🔒 Keamanan pertama**: Proxy terbalik, desain yang mengutamakan privasi
---
## Mulai Cepat
### Persyaratan
- Rust 1.70+
- Kunci API penyedia LLM (Anthropic, OpenAI, dll.)
### Instalasi
```bash
# Klon repositori
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Bangun
cargo build --release
# Jalankan
cargo run --release
```
### Dengan Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Konfigurasi
ZeroClaw menggunakan file konfigurasi YAML. Secara default, ini mencari `config.yaml`.
```yaml
# Penyedia default
provider: anthropic
# Konfigurasi penyedia
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Konfigurasi memori
memory:
backend: sqlite
path: data/memory.db
# Konfigurasi saluran
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Dokumentasi
Untuk dokumentasi terperinci, lihat:
- [Hub Dokumentasi](docs/README.md)
- [Referensi Perintah](docs/commands-reference.md)
- [Referensi Penyedia](docs/providers-reference.md)
- [Referensi Saluran](docs/channels-reference.md)
- [Referensi Konfigurasi](docs/config-reference.md)
---
## Berkontribusi
Kontribusi diterima! Silakan baca [Panduan Kontribusi](CONTRIBUTING.md).
---
## Lisensi
Proyek ini dilisensikan ganda:
- MIT License
- Apache License, versi 2.0
Lihat [LICENSE-APACHE](LICENSE-APACHE) dan [LICENSE-MIT](LICENSE-MIT) untuk detailnya.
---
## Komunitas
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Sponsor
Jika ZeroClaw berguna bagi Anda, mohon pertimbangkan untuk membelikan kami kopi:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

914
README.it.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Zero overhead. Zero compromesso. 100% Rust. 100% Agnostico.</strong><br>
⚡️ <strong>Gira su hardware da $10 con <5MB di RAM: È il 99% di memoria in meno di OpenClaw e il 98% più economico di un Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Costruito da studenti e membri delle comunità Harvard, MIT e Sundai.Club.
</p>
<p align="center">
🌐 <strong>Lingue:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#avvio-rapido">Avvio Rapido</a> |
<a href="bootstrap.sh">Configurazione con Un Clic</a> |
<a href="docs/README.md">Hub Documentazione</a> |
<a href="docs/SUMMARY.md">Indice Documentazione</a>
</p>
<p align="center">
<strong>Accessi rapidi:</strong>
<a href="docs/reference/README.md">Riferimento</a> ·
<a href="docs/operations/README.md">Operazioni</a> ·
<a href="docs/troubleshooting.md">Risoluzione Problemi</a> ·
<a href="docs/security/README.md">Sicurezza</a> ·
<a href="docs/hardware/README.md">Hardware</a> ·
<a href="docs/contributing/README.md">Contribuire</a>
</p>
<p align="center">
<strong>Infrastruttura assistente AI veloce, leggera e completamente autonoma</strong><br />
Distribuisci ovunque. Scambia qualsiasi cosa.
</p>
<p align="center">
ZeroClaw è il <strong>sistema operativo runtime</strong> per i workflow degli agenti — un'infrastruttura che astrae modelli, strumenti, memoria ed esecuzione per costruire agenti una volta e eseguirli ovunque.
</p>
<p align="center"><code>Architettura basata su trait · runtime sicuro di default · provider/canale/strumento intercambiabili · tutto è collegabile</code></p>
### 📢 Annunci
Usa questa tabella per avvisi importanti (cambiamenti di compatibilità, avvisi di sicurezza, finestre di manutenzione e blocchi di versione).
| Data (UTC) | Livello | Avviso | Azione |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Critico_ | **Non siamo affiliati** con `openagen/zeroclaw` o `zeroclaw.org`. Il dominio `zeroclaw.org` punta attualmente al fork `openagen/zeroclaw`, e questo dominio/repository sta contraffacendo il nostro sito web/progetto ufficiale. | Non fidarti di informazioni, binari, raccolte fondi o annunci da queste fonti. Usa solo [questo repository](https://github.com/zeroclaw-labs/zeroclaw) e i nostri account social verificati. |
| 2026-02-21 | _Importante_ | Il nostro sito ufficiale è ora online: [zeroclawlabs.ai](https://zeroclawlabs.ai). Grazie per la pazienza durante l'attesa. Rileviamo ancora tentativi di contraffazione: non partecipare ad alcuna attività di investimento/finanziamento a nome di ZeroClaw se non pubblicata tramite i nostri canali ufficiali. | Usa [questo repository](https://github.com/zeroclaw-labs/zeroclaw) come unica fonte di verità. Segui [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (gruppo)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), e [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) per aggiornamenti ufficiali. |
| 2026-02-19 | _Importante_ | Anthropic ha aggiornato i termini di utilizzo di autenticazione e credenziali il 2026-02-19. L'autenticazione OAuth (Free, Pro, Max) è esclusivamente per Claude Code e Claude.ai; l'uso di token OAuth di Claude Free/Pro/Max in qualsiasi altro prodotto, strumento o servizio (incluso Agent SDK) non è consentito e può violare i Termini di Utilizzo del Consumatore. | Si prega di evitare temporaneamente le integrazioni OAuth di Claude Code per prevenire qualsiasi potenziale perdita. Clausola originale: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Funzionalità
- 🏎️ **Runtime Leggero di Default:** I workflow CLI comuni e i comandi di stato girano all'interno di uno spazio di memoria di pochi megabyte nelle build di produzione.
- 💰 **Distribuzione Economica:** Progettato per schede a basso costo e piccole istanze cloud senza dipendenze runtime pesanti.
- ⚡ **Avvii a Freddo Rapidi:** Il runtime Rust a binario singolo mantiene l'avvio di comandi e demoni quasi istantaneo per le operazioni quotidiane.
- 🌍 **Architettura Portabile:** Un workflow a binario singolo su ARM, x86 e RISC-V con provider/canale/strumento intercambiabili.
### Perché i team scelgono ZeroClaw
- **Leggero di default:** binario Rust piccolo, avvio rapido, basso impatto di memoria.
- **Sicuro per design:** pairing, sandboxing rigoroso, liste di autorizzazione esplicite, scope del workspace.
- **Completamente intercambiabile:** i sistemi centrali sono trait (provider, canali, strumenti, memoria, tunnel).
- **Nessun lock-in del provider:** supporto provider compatibile OpenAI + endpoint personalizzati collegabili.
## Snapshot Benchmark (ZeroClaw vs OpenClaw, Riproducibile)
Benchmark rapido su macchina locale (macOS arm64, feb. 2026) normalizzato per hardware edge a 0.8 GHz.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Linguaggio** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Avvio (core 0.8 GHz)** | > 500s | > 30s | < 1s | **< 10ms** |
| **Dimensione Binario** | ~28 MB (dist) | N/A (Scripts) | ~8 MB | **3.4 MB** |
| **Costo** | Mac Mini $599 | Linux SBC ~$50 | Scheda Linux $10 | **Qualsiasi hardware $10** |
> Note: I risultati di ZeroClaw sono misurati su build di produzione usando `/usr/bin/time -l`. OpenClaw richiede il runtime Node.js (tipicamente ~390 MB di overhead memoria aggiuntivo), mentre NanoBot richiede il runtime Python. PicoClaw e ZeroClaw sono binari statici. Le cifre RAM sopra sono memoria runtime; i requisiti di compilazione in build-time sono maggiori.
<p align="center">
<img src="zero-claw.jpeg" alt="Confronto ZeroClaw vs OpenClaw" width="800" />
</p>
### Misurazione Locale Riproducibile
Le affermazioni di benchmark possono derivare man mano che il codice e le toolchain evolvono, quindi misura sempre la tua build attuale localmente:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Esempio di campione (macOS arm64, misurato il 18 febbraio 2026):
- Dimensione binario release: `8.8M`
- `zeroclaw --help`: tempo reale circa `0.02s`, impatto memoria massimo ~`3.9 MB`
- `zeroclaw status`: tempo reale circa `0.01s`, impatto memoria massimo ~`4.1 MB`
## Prerequisiti
<details>
<summary><strong>Windows</strong></summary>
### Windows — Richiesto
1. **Visual Studio Build Tools** (fornisce il linker MSVC e il Windows SDK):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Durante l'installazione (o via Visual Studio Installer), seleziona il carico di lavoro **"Sviluppo desktop con C++"**.
2. **Toolchain Rust:**
```powershell
winget install Rustlang.Rustup
```
Dopo l'installazione, apri un nuovo terminale ed esegui `rustup default stable` per assicurarti che la toolchain stabile sia attiva.
3. **Verifica** che entrambi funzionano:
```powershell
rustc --version
cargo --version
```
### Windows — Opzionale
- **Docker Desktop** — richiesto solo se usi il [runtime Docker sandboxed](#supporto-runtime-attuale) (`runtime.kind = "docker"`). Installa via `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Richiesto
1. **Strumenti di build essenziali:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Installa Xcode Command Line Tools: `xcode-select --install`
2. **Toolchain Rust:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Vedi [rustup.rs](https://rustup.rs) per dettagli.
3. **Verifica:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — Opzionale
- **Docker** — richiesto solo se usi il [runtime Docker sandboxed](#supporto-runtime-attuale) (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** vedi [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** vedi [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** installa Docker Desktop via [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## Avvio Rapido
### Opzione 1: Configurazione automatizzata (consigliata)
Lo script `bootstrap.sh` installa Rust, clona ZeroClaw, lo compila, e configura il tuo ambiente di sviluppo iniziale:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
Questo:
1. Installerà Rust (se non presente)
2. Clonerà il repository ZeroClaw
3. Compilerà ZeroClaw in modalità release
4. Installerà `zeroclaw` in `~/.cargo/bin/`
5. Creerà la struttura del workspace di default in `~/.zeroclaw/workspace/`
6. Genererà un file di configurazione iniziale `~/.zeroclaw/workspace/config.toml`
Dopo il bootstrap, ricarica la tua shell o esegui `source ~/.cargo/env` per usare il comando `zeroclaw` globalmente.
### Opzione 2: Installazione manuale
<details>
<summary><strong>Clicca per vedere i passaggi di installazione manuale</strong></summary>
```bash
# 1. Clona il repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. Compila in release
cargo build --release --locked
# 3. Installa il binario
cargo install --path . --locked
# 4. Inizializza il workspace
zeroclaw init
# 5. Verifica l'installazione
zeroclaw --version
zeroclaw status
```
</details>
### Dopo l'installazione
Una volta installato (via bootstrap o manualmente), dovresti vedere:
```
~/.zeroclaw/workspace/
├── config.toml # Configurazione principale
├── .pairing # Segreti di pairing (generati al primo avvio)
├── logs/ # Log di daemon/agent
├── skills/ # Competenze personalizzate
└── memory/ # Archiviazione contesto conversazionale
```
**Prossimi passi:**
1. Configura i tuoi provider AI in `~/.zeroclaw/workspace/config.toml`
2. Controlla la [riferimento configurazione](docs/config-reference.md) per opzioni avanzate
3. Avvia l'agente: `zeroclaw agent start`
4. Testa tramite il tuo canale preferito (vedi [riferimento canali](docs/channels-reference.md))
## Configurazione
Modifica `~/.zeroclaw/workspace/config.toml` per configurare provider, canali e comportamento del sistema.
### Riferimento Configurazione Rapida
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # o "sqlite" o "none"
[runtime]
kind = "native" # o "docker" (richiede Docker)
```
**Documenti di riferimento completi:**
- [Riferimento Configurazione](docs/config-reference.md) — tutte le impostazioni, validazioni, valori di default
- [Riferimento Provider](docs/providers-reference.md) — configurazioni specifiche per provider AI
- [Riferimento Canali](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord e altro
- [Operazioni](docs/operations-runbook.md) — monitoraggio in produzione, rotazione segreti, scaling
### Supporto Runtime (attuale)
ZeroClaw supporta due backend di esecuzione del codice:
- **`native`** (default) — esecuzione processo diretta, percorso più veloce, ideale per ambienti fidati
- **`docker`** — isolamento container completo, politiche di sicurezza potenziate, richiede Docker
Usa `runtime.kind = "docker"` se hai bisogno di sandboxing rigoroso o isolamento rete. Vedi [riferimento configurazione](docs/config-reference.md#runtime) per dettagli completi.
## Comandi
```bash
# Gestione workspace
zeroclaw init # Inizializza un nuovo workspace
zeroclaw status # Mostra stato daemon/agent
zeroclaw config validate # Verifica sintassi e valori di config.toml
# Gestione daemon
zeroclaw daemon start # Avvia il daemon in background
zeroclaw daemon stop # Ferma il daemon in esecuzione
zeroclaw daemon restart # Riavvia il daemon (ricaricamento config)
zeroclaw daemon logs # Mostra log del daemon
# Gestione agent
zeroclaw agent start # Avvia l'agent (richiede daemon in esecuzione)
zeroclaw agent stop # Ferma l'agent
zeroclaw agent restart # Riavvia l'agent (ricaricamento config)
# Operazioni di pairing
zeroclaw pairing init # Genera un nuovo segreto di pairing
zeroclaw pairing rotate # Ruota il segreto di pairing esistente
# Tunneling (per esposizione pubblica)
zeroclaw tunnel start # Avvia un tunnel verso il daemon locale
zeroclaw tunnel stop # Ferma il tunnel attivo
# Diagnostica
zeroclaw doctor # Esegue controlli di salute del sistema
zeroclaw version # Mostra versione e informazioni di build
```
Vedi [Riferimento Comandi](docs/commands-reference.md) per opzioni ed esempi completi.
## Architettura
```
┌─────────────────────────────────────────────────────────────────┐
│ Canali (trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Agente Orchestratore │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Routing │ │ Contesto │ │ Esecuzione │ │
│ │ Messaggio │ │ Memoria │ │ Strumento │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Provider │ │ Memoria │ │ Strumenti │
│ (trait) │ │ (trait) │ │ (trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Runtime (trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Principi chiave:**
- Tutto è un **trait** — provider, canali, strumenti, memoria, tunnel
- I canali chiamano l'orchestratore; l'orchestratore chiama provider + strumenti
- Il sistema memoria gestisce il contesto conversazionale (markdown, SQLite, o nessuno)
- Il runtime astrae l'esecuzione del codice (nativo o Docker)
- Nessun lock-in del provider — scambia Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama senza modifiche al codice
Vedi [documentazione architettura](docs/architecture.svg) per diagrammi dettagliati e dettagli di implementazione.
## Esempi
### Bot Telegram
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Il tuo ID utente Telegram
```
Avvia il daemon + agent, poi invia un messaggio al tuo bot su Telegram:
```
/start
Ciao! Potresti aiutarmi a scrivere uno script Python?
```
Il bot risponde con codice generato dall'AI, esegue strumenti se richiesto, e mantiene il contesto della conversazione.
### Matrix (crittografia end-to-end)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Invita `@zeroclaw:matrix.org` in una stanza crittografata, e il bot risponderà con crittografia completa. Vedi [Guida Matrix E2EE](docs/matrix-e2ee-guide.md) per la configurazione della verifica dispositivo.
### Multi-Provider
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Failover su errore del provider
```
Se Anthropic fallisce o va in rate-limit, l'orchestratore passa automaticamente a OpenAI.
### Memoria Personalizzata
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # Eliminazione automatica dopo 90 giorni
```
O usa Markdown per un archiviazione leggibile dall'uomo:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Vedi [Riferimento Configurazione](docs/config-reference.md#memory) per tutte le opzioni memoria.
## Supporto Provider
| Provider | Stato | API Key | Modelli di Esempio |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Stabile | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Stabile | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Stabile | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Stabile | N/A (locale) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Stabile | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Stabile | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Pianificato | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Pianificato | `COHERE_API_KEY` | TBD |
### Endpoint Personalizzati
ZeroClaw supporta endpoint compatibili con OpenAI:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Esempio: usa [LiteLLM](https://github.com/BerriAI/litellm) come proxy per accedere a qualsiasi LLM tramite l'interfaccia OpenAI.
Vedi [Riferimento Provider](docs/providers-reference.md) per dettagli di configurazione completi.
## Supporto Canali
| Canale | Stato | Autenticazione | Note |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Stabile | Bot Token | Supporto completo inclusi file, immagini, pulsanti inline |
| **Matrix** | ✅ Stabile | Password o Token | Supporto E2EE con verifica dispositivo |
| **Slack** | 🚧 Pianificato | OAuth o Bot Token | Richiede accesso workspace |
| **Discord** | 🚧 Pianificato | Bot Token | Richiede permessi guild |
| **WhatsApp** | 🚧 Pianificato | Twilio o API ufficiale | Richiede account business |
| **CLI** | ✅ Stabile | Nessuno | Interfaccia conversazionale diretta |
| **Web** | 🚧 Pianificato | API Key o OAuth | Interfaccia chat basata su browser |
Vedi [Riferimento Canali](docs/channels-reference.md) per istruzioni di configurazione complete.
## Supporto Strumenti
ZeroClaw fornisce strumenti integrati per l'esecuzione del codice, l'accesso al filesystem e il recupero web:
| Strumento | Descrizione | Runtime Richiesto |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Esegue comandi shell | Nativo o Docker |
| **python** | Esegue script Python | Python 3.8+ (nativo) o Docker |
| **javascript** | Esegue codice Node.js | Node.js 18+ (nativo) o Docker |
| **filesystem_read** | Legge file | Nativo o Docker |
| **filesystem_write** | Scrive file | Nativo o Docker |
| **web_fetch** | Recupera contenuti web | Nativo o Docker |
### Sicurezza dell'Esecuzione
- **Runtime Nativo** — gira come processo utente del daemon, accesso completo al filesystem
- **Runtime Docker** — isolamento container completo, filesystem e reti separati
Configura la politica di esecuzione in `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Lista di autorizzazione esplicita
```
Vedi [Riferimento Configurazione](docs/config-reference.md#runtime) per opzioni di sicurezza complete.
## Distribuzione
### Distribuzione Locale (Sviluppo)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Distribuzione Server (Produzione)
Usa systemd per gestire daemon e agent come servizi:
```bash
# Installa il binario
cargo install --path . --locked
# Configura il workspace
zeroclaw init
# Crea i file di servizio systemd
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# Abilita e avvia i servizi
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# Verifica lo stato
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Vedi [Guida Distribuzione di Rete](docs/network-deployment.md) per istruzioni complete di distribuzione in produzione.
### Docker
```bash
# Compila l'immagine
docker build -t zeroclaw:latest .
# Esegui il container
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Vedi [`Dockerfile`](Dockerfile) per dettagli di build e opzioni di configurazione.
### Hardware Edge
ZeroClaw è progettato per girare su hardware a basso consumo:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, singolo core ARMv8, < $5 costo hardware
- **Raspberry Pi 4/5** — 1 GB+ RAM, multi-core, ideale per workload concorrenti
- **Orange Pi Zero 2** — ~512 MB RAM, quad-core ARMv8, costo ultra-basso
- **SBC x86 (Intel N100)** — 4-8 GB RAM, build veloci, supporto Docker nativo
Vedi [Guida Hardware](docs/hardware/README.md) per istruzioni di configurazione specifiche per dispositivo.
## Tunneling (Esposizione Pubblica)
Espone il tuo daemon ZeroClaw locale alla rete pubblica tramite tunnel sicuri:
```bash
zeroclaw tunnel start --provider cloudflare
```
Provider di tunnel supportati:
- **Cloudflare Tunnel** — HTTPS gratuito, nessuna esposizione di porte, supporto multi-dominio
- **Ngrok** — configurazione rapida, domini personalizzati (piano a pagamento)
- **Tailscale** — rete mesh privata, nessuna porta pubblica
Vedi [Riferimento Configurazione](docs/config-reference.md#tunnel) per opzioni di configurazione complete.
## Sicurezza
ZeroClaw implementa molteplici livelli di sicurezza:
### Pairing
Il daemon genera un segreto di pairing al primo avvio memorizzato in `~/.zeroclaw/workspace/.pairing`. I client (agent, CLI) devono presentare questo segreto per connettersi.
```bash
zeroclaw pairing rotate # Genera un nuovo segreto e invalida quello precedente
```
### Sandboxing
- **Runtime Docker** — isolamento container completo con filesystem e reti separati
- **Runtime Nativo** — gira come processo utente, con scope del workspace di default
### Liste di Autorizzazione
I canali possono limitare l'accesso per ID utente:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Lista di autorizzazione esplicita
```
### Crittografia
- **Matrix E2EE** — crittografia end-to-end completa con verifica dispositivo
- **Trasporto TLS** — tutto il traffico API e tunnel usa HTTPS/TLS
Vedi [Documentazione Sicurezza](docs/security/README.md) per politiche e pratiche complete.
## Osservabilità
ZeroClaw registra i log in `~/.zeroclaw/workspace/logs/` di default. I log sono memorizzati per componente:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Log del daemon (avvio, richieste API, errori)
├── agent.log # Log dell'agent (routing messaggi, esecuzione strumenti)
├── telegram.log # Log specifici del canale (se abilitato)
└── matrix.log # Log specifici del canale (se abilitato)
```
### Configurazione Logging
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # Per rotazione basata sulla dimensione
retention_days = 30 # Eliminazione automatica dopo N giorni
```
Vedi [Riferimento Configurazione](docs/config-reference.md#logging) per tutte le opzioni di logging.
### Metriche (Pianificato)
Supporto metriche Prometheus per il monitoraggio in produzione in arrivo. Tracciamento in [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## Competenze (Skills)
ZeroClaw supporta competenze personalizzate — moduli riutilizzabili che estendono le capacità del sistema.
### Definizione Competenza
Le competenze sono memorizzate in `~/.zeroclaw/workspace/skills/<skill-name>/` con questa struttura:
```
skills/
└── my-skill/
├── skill.toml # Metadati competenza (nome, descrizione, dipendenze)
├── prompt.md # Prompt di sistema per l'AI
└── tools/ # Strumenti personalizzati opzionali
└── my_tool.py
```
### Esempio Competenza
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Cerca sul web e riassume i risultati"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
Sei un assistente di ricerca. Quando ti viene chiesto di cercare qualcosa:
1. Usa web_fetch per recuperare il contenuto
2. Riassume i risultati in un formato facile da leggere
3. Cita le fonti con gli URL
```
### Uso delle Competenze
Le competenze sono caricate automaticamente all'avvio dell'agent. Fai riferimento ad esse per nome nelle conversazioni:
```
Utente: Usa la competenza web-research per trovare le ultime notizie AI
Bot: [carica la competenza web-research, esegue web_fetch, riassume i risultati]
```
Vedi sezione [Competenze (Skills)](#competenze-skills) per istruzioni complete sulla creazione di competenze.
## Open Skills
ZeroClaw supporta [Open Skills](https://github.com/openagents-com/open-skills) — un sistema modulare e agnostico del provider per estendere le capacità degli agent AI.
### Abilita Open Skills
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # opzionale
```
Puoi anche sovrascrivere a runtime con `ZEROCLAW_OPEN_SKILLS_ENABLED` e `ZEROCLAW_OPEN_SKILLS_DIR`.
## Sviluppo
```bash
cargo build # Build di sviluppo
cargo build --release # Build release (codegen-units=1, funziona su tutti i dispositivi incluso Raspberry Pi)
cargo build --profile release-fast # Build più veloce (codegen-units=8, richiede 16 GB+ RAM)
cargo test # Esegue la suite di test completa
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Formattazione
# Esegue il benchmark di confronto SQLite vs Markdown
cargo test --test memory_comparison -- --nocapture
```
### Hook pre-push
Un hook git esegue `cargo fmt --check`, `cargo clippy -- -D warnings`, e `cargo test` prima di ogni push. Attivalo una volta:
```bash
git config core.hooksPath .githooks
```
### Risoluzione Problemi di Build (errori OpenSSL su Linux)
Se incontri un errore di build `openssl-sys`, sincronizza le dipendenze e ricompila con il lockfile del repository:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw è configurato per usare `rustls` per le dipendenze HTTP/TLS; `--locked` mantiene il grafo transitivo deterministico in ambienti puliti.
Per saltare l'hook quando hai bisogno di un push veloce durante lo sviluppo:
```bash
git push --no-verify
```
## Collaborazione e Docs
Inizia con l'hub della documentazione per una mappa basata sui task:
- Hub Documentazione: [`docs/README.md`](docs/README.md)
- Indice Unificato Docs: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Riferimento Comandi: [`docs/commands-reference.md`](docs/commands-reference.md)
- Riferimento Configurazione: [`docs/config-reference.md`](docs/config-reference.md)
- Riferimento Provider: [`docs/providers-reference.md`](docs/providers-reference.md)
- Riferimento Canali: [`docs/channels-reference.md`](docs/channels-reference.md)
- Runbook Operazioni: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Risoluzione Problemi: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Inventario/Classificazione Docs: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- Snapshot Triage PR/Issue (al 18 feb. 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Riferimenti principali di collaborazione:
- Hub Documentazione: [docs/README.md](docs/README.md)
- Modello Documentazione: [docs/doc-template.md](docs/doc-template.md)
- Checklist Cambio Documentazione: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Riferimento Configurazione Canali: [docs/channels-reference.md](docs/channels-reference.md)
- Operazioni Stanze Crittografate Matrix: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Guida Contribuzione: [CONTRIBUTING.md](CONTRIBUTING.md)
- Politica Workflow PR: [docs/pr-workflow.md](docs/pr-workflow.md)
- Playbook Revisore (triage + revisione profonda): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Mappa Proprietà e Triage CI: [docs/ci-map.md](docs/ci-map.md)
- Politica Divulgazione Sicurezza: [SECURITY.md](SECURITY.md)
Per distribuzione e operazioni runtime:
- Guida Distribuzione di Rete: [docs/network-deployment.md](docs/network-deployment.md)
- Playbook Agent Proxy: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## Supportare ZeroClaw
Se ZeroClaw aiuta il tuo lavoro e desideri supportare lo sviluppo continuo, puoi donare qui:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Offrimi un Caffè" /></a>
### 🙏 Ringraziamenti Speciali
Un sincero ringraziamento alle comunità e istituzioni che ispirano e alimentano questo lavoro open-source:
- **Harvard University** — per favorire la curiosità intellettuale e spingere i confini del possibile.
- **MIT** — per difendere la conoscenza aperta, l'open source, e la convinzione che la tecnologia dovrebbe essere accessibile a tutti.
- **Sundai Club** — per la comunità, l'energia, e la volontà incessante di costruire cose che contano.
- **Il Mondo e Oltre** 🌍✨ — a ogni contributore, sognatore, e costruttore là fuori che rende l'open source una forza per il bene. Questo è per te.
Costruiamo in open source perché le migliori idee vengono da ovunque. Se stai leggendo questo, ne fai parte. Benvenuto. 🦀❤️
## ⚠️ Repository Ufficiale e Avviso di Contraffazione
**Questo è l'unico repository ufficiale di ZeroClaw:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Qualsiasi altro repository, organizzazione, dominio o pacchetto che afferma di essere "ZeroClaw" o che implica affiliazione con ZeroClaw Labs è **non autorizzato e non affiliato a questo progetto**. I fork non autorizzati noti saranno elencati in [TRADEMARK.md](TRADEMARK.md).
Se incontri contraffazione o uso improprio del marchio, per favore [apri una issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## Licenza
ZeroClaw è doppia licenza per massima apertura e protezione dei contributori:
| Licenza | Casi d'Uso |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Open-source, ricerca, accademico, uso personale |
| [Apache 2.0](LICENSE-APACHE) | Protezione brevetti, istituzionale, distribuzione commerciale |
Puoi scegliere una delle due licenze. **I contributori concedono automaticamente diritti sotto entrambe** — vedi [CLA.md](CLA.md) per l'accordo completo dei contributori.
### Marchio
Il nome **ZeroClaw** e il logo sono marchi registrati di ZeroClaw Labs. Questa licenza non concede il permesso di usarli per implicare approvazione o affiliazione. Vedi [TRADEMARK.md](TRADEMARK.md) per usi permessi e proibiti.
### Protezioni dei Contributori
- **Mantieni i diritti d'autore** dei tuoi contributi
- **Concessione brevetti** (Apache 2.0) ti protegge da reclami di brevetti da parte di altri contributori
- I tuoi contributi sono **attribuiti permanentemente** nella cronologia dei commit e [NOTICE](NOTICE)
- Nessun diritto di marchio viene trasferito contribuendo
## Contribuire
Vedi [CONTRIBUTING.md](CONTRIBUTING.md) e [CLA.md](CLA.md). Implementa un trait, invia una PR:
- Guida workflow CI: [docs/ci-map.md](docs/ci-map.md)
- Nuovo `Provider``src/providers/`
- Nuovo `Channel``src/channels/`
- Nuovo `Observer``src/observability/`
- Nuovo `Tool``src/tools/`
- Nuova `Memory``src/memory/`
- Nuovo `Tunnel``src/tunnel/`
- Nuova `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Zero overhead. Zero compromesso. Distribuisci ovunque. Scambia qualsiasi cosa. 🦀
## Storico Stelle
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Grafico Storico Stelle" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

View File

@ -1,5 +1,5 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
<img src="docs/assets/zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀(日本語)</h1>
@ -21,12 +21,43 @@
</p>
<p align="center">
🌐 言語: <a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.ru.md">Русский</a> · <a href="README.fr.md">Français</a> · <a href="README.vi.md">Tiếng Việt</a>
🌐 言語:
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="bootstrap.sh">ワンクリック導入</a> |
<a href="docs/getting-started/README.md">導入ガイド</a> |
<a href="install.sh">ワンクリック導入</a> |
<a href="docs/setup-guides/README.md">導入ガイド</a> |
<a href="docs/README.ja.md">ドキュメントハブ</a> |
<a href="docs/SUMMARY.md">Docs TOC</a>
</p>
@ -34,8 +65,8 @@
<p align="center">
<strong>クイック分流:</strong>
<a href="docs/reference/README.md">参照</a> ·
<a href="docs/operations/README.md">運用</a> ·
<a href="docs/troubleshooting.md">障害対応</a> ·
<a href="docs/ops/README.md">運用</a> ·
<a href="docs/ops/troubleshooting.md">障害対応</a> ·
<a href="docs/security/README.md">セキュリティ</a> ·
<a href="docs/hardware/README.md">ハードウェア</a> ·
<a href="docs/contributing/README.md">貢献・CI</a>
@ -87,7 +118,7 @@ ZeroClaw は、高速・省リソース・高拡張性を重視した自律エ
> 注記: ZeroClaw の結果は release ビルドを `/usr/bin/time -l` で計測したものです。OpenClaw は Node.js ランタイムが必要で、ランタイム由来だけで通常は約390MBの追加メモリを要します。NanoBot は Python ランタイムが必要です。PicoClaw と ZeroClaw は静的バイナリです。
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw Comparison" width="800" />
<img src="docs/assets/zeroclaw-comparison.jpeg" alt="ZeroClaw vs OpenClaw Comparison" width="800" />
</p>
### ローカルで再現可能な測定
@ -113,12 +144,12 @@ README のサンプル値macOS arm64, 2026-02-18:
```bash
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
./bootstrap.sh
./install.sh
```
環境ごと初期化する場合: `./bootstrap.sh --install-system-deps --install-rust`(システムパッケージで `sudo` が必要な場合があります)。
環境ごと初期化する場合: `./install.sh --install-system-deps --install-rust`(システムパッケージで `sudo` が必要な場合があります)。
詳細は [`docs/one-click-bootstrap.md`](docs/one-click-bootstrap.md) を参照してください。
詳細は [`docs/setup-guides/one-click-bootstrap.md`](docs/setup-guides/one-click-bootstrap.md) を参照してください。
## クイックスタート
@ -195,7 +226,7 @@ zeroclaw agent --provider anthropic -m "hello"
すべてのサブシステムは **Trait** — 設定変更だけで実装を差し替え可能、コード変更不要。
<p align="center">
<img src="docs/architecture.svg" alt="ZeroClaw アーキテクチャ" width="900" />
<img src="docs/assets/architecture.svg" alt="ZeroClaw アーキテクチャ" width="900" />
</p>
| サブシステム | Trait | 内蔵実装 | 拡張方法 |
@ -279,20 +310,20 @@ allow_public_bind = false
- ドキュメントハブ(英語): [`docs/README.md`](docs/README.md)
- 統合 TOC: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- ドキュメントハブ(日本語): [`docs/README.ja.md`](docs/README.ja.md)
- コマンドリファレンス: [`docs/commands-reference.md`](docs/commands-reference.md)
- 設定リファレンス: [`docs/config-reference.md`](docs/config-reference.md)
- Provider リファレンス: [`docs/providers-reference.md`](docs/providers-reference.md)
- Channel リファレンス: [`docs/channels-reference.md`](docs/channels-reference.md)
- 運用ガイドRunbook: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- トラブルシューティング: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- ドキュメント一覧 / 分類: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- プロジェクト triage スナップショット: [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
- コマンドリファレンス: [`docs/reference/cli/commands-reference.md`](docs/reference/cli/commands-reference.md)
- 設定リファレンス: [`docs/reference/api/config-reference.md`](docs/reference/api/config-reference.md)
- Provider リファレンス: [`docs/reference/api/providers-reference.md`](docs/reference/api/providers-reference.md)
- Channel リファレンス: [`docs/reference/api/channels-reference.md`](docs/reference/api/channels-reference.md)
- 運用ガイドRunbook: [`docs/ops/operations-runbook.md`](docs/ops/operations-runbook.md)
- トラブルシューティング: [`docs/ops/troubleshooting.md`](docs/ops/troubleshooting.md)
- ドキュメント一覧 / 分類: [`docs/maintainers/docs-inventory.md`](docs/maintainers/docs-inventory.md)
- プロジェクト triage スナップショット: [`docs/maintainers/project-triage-snapshot-2026-02-18.md`](docs/maintainers/project-triage-snapshot-2026-02-18.md)
## コントリビュート / ライセンス
- Contributing: [`CONTRIBUTING.md`](CONTRIBUTING.md)
- PR Workflow: [`docs/pr-workflow.md`](docs/pr-workflow.md)
- Reviewer Playbook: [`docs/reviewer-playbook.md`](docs/reviewer-playbook.md)
- PR Workflow: [`docs/contributing/pr-workflow.md`](docs/contributing/pr-workflow.md)
- Reviewer Playbook: [`docs/contributing/reviewer-playbook.md`](docs/contributing/reviewer-playbook.md)
- License: MIT or Apache 2.0[`LICENSE-MIT`](LICENSE-MIT), [`LICENSE-APACHE`](LICENSE-APACHE), [`NOTICE`](NOTICE)
---

914
README.ko.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>오버헤드 없음. 타협 없음. 100% Rust. 100% 독립적.</strong><br>
⚡️ <strong>$10 하드웨어에서 <5MB RAM으로 실행: OpenClaw보다 99% 적은 메모리, Mac mini보다 98% 저렴!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Harvard, MIT, 그리고 Sundai.Club 커뮤니티의 학생들과 멤버들이 만들었습니다.
</p>
<p align="center">
🌐 <strong>언어:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#빠른-시작">빠른 시작</a> |
<a href="bootstrap.sh">원클릭 설정</a> |
<a href="docs/README.md">문서 허브</a> |
<a href="docs/SUMMARY.md">문서 목차</a>
</p>
<p align="center">
<strong>빠른 접근:</strong>
<a href="docs/reference/README.md">참조</a> ·
<a href="docs/operations/README.md">운영</a> ·
<a href="docs/troubleshooting.md">문제 해결</a> ·
<a href="docs/security/README.md">보안</a> ·
<a href="docs/hardware/README.md">하드웨어</a> ·
<a href="docs/contributing/README.md">기여하기</a>
</p>
<p align="center">
<strong>빠르고 가벼우며 완전히 자율적인 AI 어시스턴트 인프라</strong><br />
어디서나 배포. 무엇이든 교체.
</p>
<p align="center">
ZeroClaw는 에이전트 워크플로우를 위한 <strong>런타임 운영체제</strong>입니다 — 모델, 도구, 메모리, 실행을 추상화하여 한 번 구축하고 어디서나 실행할 수 있는 인프라입니다.
</p>
<p align="center"><code>트레이트 기반 아키텍처 · 기본 보안 런타임 · 교체 가능한 제공자/채널/도구 · 모든 것이 플러그 가능</code></p>
### 📢 공지사항
이 표를 사용하여 중요한 공지사항(호환성 변경, 보안 공지, 유지보수 기간, 버전 차단)을 확인하세요.
| 날짜 (UTC) | 수준 | 공지 | 조치 |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _중요_ | 우리는 `openagen/zeroclaw` 또는 `zeroclaw.org`**관련이 없습니다**. `zeroclaw.org` 도메인은 현재 `openagen/zeroclaw` 포크를 가리키고 있으며, 이 도메인/저장소는 우리의 공식 웹사이트/프로젝트를 사칭하고 있습니다. | 이 소스의 정보, 바이너리, 펀딩, 공지를 신뢰하지 마세요. [이 저장소](https://github.com/zeroclaw-labs/zeroclaw)와 우리의 확인된 소셜 계정만 사용하세요. |
| 2026-02-21 | _중요_ | 우리의 공식 웹사이트가 이제 온라인입니다: [zeroclawlabs.ai](https://zeroclawlabs.ai). 기다려주셔서 감사합니다. 여전히 사칭 시도가 감지되고 있습니다: 공식 채널을 통해 게시되지 않은 ZeroClaw 이름의 모든 투자/펀딩 활동에 참여하지 마세요. | [이 저장소](https://github.com/zeroclaw-labs/zeroclaw)를 유일한 진실의 원천으로 사용하세요. [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (그룹)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), 그리고 [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search)를 팔로우하여 공식 업데이트를 받으세요. |
| 2026-02-19 | _중요_ | Anthropic이 2026-02-19에 인증 및 자격증명 사용 약관을 업데이트했습니다. OAuth 인증(Free, Pro, Max)은 Claude Code 및 Claude.ai 전용입니다. 다른 제품, 도구 또는 서비스(Agent SDK 포함)에서 Claude Free/Pro/Max OAuth 토큰을 사용하는 것은 허용되지 않으며 소비자 이용약관을 위반할 수 있습니다. | 잠재적인 손실을 방지하기 위해 일시적으로 Claude Code OAuth 통합을 피하세요. 원본 조항: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ 기능
- 🏎️ **기본 경량 런타임:** 일반적인 CLI 워크플로우와 상태 명령이 프로덕션 빌드에서 몇 메가바이트의 메모리 공간 내에서 실행됩니다.
- 💰 **비용 효율적인 배포:** 무거운 런타임 의존성 없이 저비용 보드 및 소규모 클라우드 인스턴스를 위해 설계되었습니다.
- ⚡ **빠른 콜드 스타트:** 단일 Rust 바이너리 런타임이 일상적인 운영을 위해 거의 즉각적인 명령 및 데몬 시작을 유지합니다.
- 🌍 **이식 가능한 아키텍처:** 교체 가능한 제공자/채널/도구로 ARM, x86, RISC-V에서 단일 바이너리 워크플로우.
### 왜 팀들이 ZeroClaw를 선택하나요
- **기본 경량:** 작은 Rust 바이너리, 빠른 시작, 낮은 메모리 공간.
- **기본 보안:** 페어링, 엄격한 샌드박싱, 명시적 허용 목록, 작업공간 범위.
- **완전히 교체 가능:** 핵심 시스템이 트레이트입니다(제공자, 채널, 도구, 메모리, 터널).
- **벤더 락인 없음:** OpenAI 호환 제공자 지원 + 플러그 가능한 사용자 정의 엔드포인트.
## 벤치마크 스냅샷 (ZeroClaw vs OpenClaw, 재현 가능)
로컬 머신에서 빠른 벤치마크(macOS arm64, 2026년 2월) 0.8 GHz 엣지 하드웨어로 정규화됨.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **언어** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **시작 (0.8 GHz 코어)** | > 500s | > 30s | < 1s | **< 10ms** |
| **바이너리 크기** | ~28 MB (dist) | N/A (Scripts) | ~8 MB | **3.4 MB** |
| **비용** | Mac Mini $599 | Linux SBC ~$50 | Linux 보드 $10 | **모든 하드웨어 $10** |
> 참고: ZeroClaw 결과는 `/usr/bin/time -l`을 사용한 프로덕션 빌드에서 측정되었습니다. OpenClaw는 Node.js 런타임이 필요하며(일반적으로 ~390MB 추가 메모리 오버헤드), NanoBot은 Python 런타임이 필요합니다. PicoClaw와 ZeroClaw는 정적 바이너리입니다. 위 RAM 수치는 런타임 메모리이며, 빌드 시간 컴파일 요구사항은 더 높습니다.
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw 비교" width="800" />
</p>
### 재현 가능한 로컬 측정
벤치마크 주장은 코드와 툴체인의 발전에 따라 달라질 수 있으므로 항상 현재 빌드를 로컬에서 측정하세요:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
샘플 예시(macOS arm64, 2026년 2월 18일 측정):
- 릴리스 바이너리 크기: `8.8M`
- `zeroclaw --help`: 실제 시간 약 `0.02s`, 최대 메모리 공간 ~`3.9 MB`
- `zeroclaw status`: 실제 시간 약 `0.01s`, 최대 메모리 공간 ~`4.1 MB`
## 사전 요구사항
<details>
<summary><strong>Windows</strong></summary>
### Windows — 필수
1. **Visual Studio Build Tools**(MSVC 링커 및 Windows SDK 제공):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
설치 중(또는 Visual Studio Installer를 통해) **"C++를 사용한 데스크톱 개발"** 워크로드를 선택하세요.
2. **Rust 툴체인:**
```powershell
winget install Rustlang.Rustup
```
설치 후, 새 터미널을 열고 `rustup default stable`을 실행하여 안정적인 툴체인이 활성화되어 있는지 확인하세요.
3. **확인:** 둘 다 작동하는지 확인:
```powershell
rustc --version
cargo --version
```
### Windows — 선택사항
- **Docker Desktop** — [Docker 샌드박스 런타임](#현재-런타임-지원)을 사용하는 경우에만 필요(`runtime.kind = "docker"`). `winget install Docker.DockerDesktop`을 통해 설치.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — 필수
1. **필수 빌드 도구:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Xcode Command Line Tools 설치: `xcode-select --install`
2. **Rust 툴체인:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
자세한 내용은 [rustup.rs](https://rustup.rs)를 참조하세요.
3. **확인:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — 선택사항
- **Docker** — [Docker 샌드박스 런타임](#현재-런타임-지원)을 사용하는 경우에만 필요(`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/) 참조
- **Linux (Fedora/RHEL):** [docs.docker.com](https://docs.docker.com/engine/install/fedora/) 참조
- **macOS:** [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)에서 Docker Desktop 설치
</details>
## 빠른 시작
### 옵션 1: 자동 설정 (권장)
`bootstrap.sh` 스크립트는 Rust를 설치하고, ZeroClaw를 클론하고, 컴파일하고, 초기 개발 환경을 설정합니다:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
이 작업은 다음을 수행합니다:
1. Rust 설치 (없는 경우)
2. ZeroClaw 저장소 클론
3. ZeroClaw를 릴리스 모드로 컴파일
4. `~/.cargo/bin/``zeroclaw` 설치
5. `~/.zeroclaw/workspace/`에 기본 작업공간 구조 생성
6. 시작용 `~/.zeroclaw/workspace/config.toml` 구성 파일 생성
부트스트랩 후, 셸을 다시 로드하거나 `source ~/.cargo/env`를 실행하여 `zeroclaw` 명령을 전역으로 사용하세요.
### 옵션 2: 수동 설치
<details>
<summary><strong>클릭하여 수동 설치 단계 보기</strong></summary>
```bash
# 1. 저장소 클론
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. 릴리스로 컴파일
cargo build --release --locked
# 3. 바이너리 설치
cargo install --path . --locked
# 4. 작업공간 초기화
zeroclaw init
# 5. 설치 확인
zeroclaw --version
zeroclaw status
```
</details>
### 설치 후
설치 후(부트스트랩 또는 수동), 다음이 표시되어야 합니다:
```
~/.zeroclaw/workspace/
├── config.toml # 메인 구성
├── .pairing # 페어링 시크릿 (첫 실행 시 생성)
├── logs/ # 데몬/에이전트 로그
├── skills/ # 사용자 정의 스킬
└── memory/ # 대화 컨텍스트 저장소
```
**다음 단계:**
1. `~/.zeroclaw/workspace/config.toml`에서 AI 제공자 구성
2. 고급 옵션은 [구성 참조](docs/config-reference.md) 확인
3. 에이전트 시작: `zeroclaw agent start`
4. 선호하는 채널을 통해 테스트 ([채널 참조](docs/channels-reference.md) 참조)
## 구성
제공자, 채널 및 시스템 동작을 구성하려면 `~/.zeroclaw/workspace/config.toml`을 편집하세요.
### 빠른 구성 참조
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # 또는 "sqlite" 또는 "none"
[runtime]
kind = "native" # 또는 "docker" (Docker 필요)
```
**전체 참조 문서:**
- [구성 참조](docs/config-reference.md) — 모든 설정, 검증, 기본값
- [제공자 참조](docs/providers-reference.md) — AI 제공자별 구성
- [채널 참조](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord 등
- [운영](docs/operations-runbook.md) — 프로덕션 모니터링, 시크릿 교체, 스케일링
### 현재 런타임 지원
ZeroClaw는 두 가지 코드 실행 백엔드를 지원합니다:
- **`native`**(기본값) — 직접 프로세스 실행, 가장 빠른 경로, 신뢰할 수 있는 환경에 이상적
- **`docker`** — 전체 컨테이너 격리, 강화된 보안 정책, Docker 필요
엄격한 샌드박싱이나 네트워크 격리가 필요한 경우 `runtime.kind = "docker"`를 사용하세요. 자세한 내용은 [구성 참조](docs/config-reference.md#runtime)를 참조하세요.
## 명령어
```bash
# 작업공간 관리
zeroclaw init # 새 작업공간 초기화
zeroclaw status # 데몬/에이전트 상태 표시
zeroclaw config validate # config.toml 구문 및 값 확인
# 데몬 관리
zeroclaw daemon start # 백그라운드에서 데몬 시작
zeroclaw daemon stop # 실행 중인 데몬 중지
zeroclaw daemon restart # 데몬 재시작 (구성 다시 로드)
zeroclaw daemon logs # 데몬 로그 표시
# 에이전트 관리
zeroclaw agent start # 에이전트 시작 (데몬 실행 중 필요)
zeroclaw agent stop # 에이전트 중지
zeroclaw agent restart # 에이전트 재시작 (구성 다시 로드)
# 페어링 작업
zeroclaw pairing init # 새 페어링 시크릿 생성
zeroclaw pairing rotate # 기존 페어링 시크릿 교체
# 터널링 (공개 노출용)
zeroclaw tunnel start # 로컬 데몬으로 터널 시작
zeroclaw tunnel stop # 활성 터널 중지
# 진단
zeroclaw doctor # 시스템 상태 검사 실행
zeroclaw version # 버전 및 빌드 정보 표시
```
전체 옵션 및 예제는 [명령어 참조](docs/commands-reference.md)를 참조하세요.
## 아키텍처
```
┌─────────────────────────────────────────────────────────────────┐
│ 채널 (트레이트) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 에이전트 오케스트레이터 │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 메시지 │ │ 컨텍스트 │ │ 도구 │ │
│ │ 라우팅 │ │ 메모리 │ │ 실행 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ 제공자 │ │ 메모리 │ │ 도구 │
│ (트레이트) │ │ (트레이트) │ │ (트레이트) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 런타임 (트레이트) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**핵심 원칙:**
- 모든 것이 **트레이트**입니다 — 제공자, 채널, 도구, 메모리, 터널
- 채널이 오케스트레이터를 호출; 오케스트레이터가 제공자 + 도구를 호출
- 메모리 시스템이 대화 컨텍스트 관리(markdown, SQLite, 또는 없음)
- 런타임이 코드 실행 추상화(네이티브 또는 Docker)
- 제공자 락인 없음 — 코드 변경 없이 Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama 교체
자세한 다이어그램과 구현 세부 정보는 [아키텍처 문서](docs/architecture.svg)를 참조하세요.
## 예제
### 텔레그램 봇
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # 당신의 텔레그램 사용자 ID
```
데몬 + 에이전트를 시작한 다음 텔레그램에서 봇에 메시지를 보내세요:
```
/start
안녕하세요! Python 스크립트 작성을 도와주실 수 있나요?
```
봇이 AI가 생성한 코드로 응답하고, 요청 시 도구를 실행하며, 대화 컨텍스트를 유지합니다.
### Matrix (종단 간 암호화)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
암호화된 방에 `@zeroclaw:matrix.org`를 초대하면 봇이 완전한 암호화로 응답합니다. 장치 확인 설정은 [Matrix E2EE 가이드](docs/matrix-e2ee-guide.md)를 참조하세요.
### 다중 제공자
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # 제공자 오류 시 장애 조치
```
Anthropic이 실패하거나 속도 제한이 걸리면 오케스트레이터가 자동으로 OpenAI로 장애 조치합니다.
### 사용자 정의 메모리
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # 90일 후 자동 삭제
```
또는 사람이 읽을 수 있는 저장소를 위해 Markdown을 사용하세요:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
모든 메모리 옵션은 [구성 참조](docs/config-reference.md#memory)를 참조하세요.
## 제공자 지원
| 제공자 | 상태 | API 키 | 예제 모델 |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ 안정 | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ 안정 | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ 안정 | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ 안정 | N/A (로컬) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ 안정 | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ 안정 | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 계획 중 | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 계획 중 | `COHERE_API_KEY` | TBD |
### 사용자 정의 엔드포인트
ZeroClaw는 OpenAI 호환 엔드포인트를 지원합니다:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
예: [LiteLLM](https://github.com/BerriAI/litellm)을 프록시로 사용하여 OpenAI 인터페이스를 통해 모든 LLM에 액세스.
전체 구성 세부 정보는 [제공자 참조](docs/providers-reference.md)를 참조하세요.
## 채널 지원
| 채널 | 상태 | 인증 | 참고 |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ 안정 | 봇 토큰 | 파일, 이미지, 인라인 버튼 포함 전체 지원 |
| **Matrix** | ✅ 안정 | 비밀번호 또는 토큰 | 장치 확인과 함께 E2EE 지원 |
| **Slack** | 🚧 계획 중 | OAuth 또는 봇 토큰 | 작업공간 액세스 필요 |
| **Discord** | 🚧 계획 중 | 봇 토큰 | 길드 권한 필요 |
| **WhatsApp** | 🚧 계획 중 | Twilio 또는 공식 API | 비즈니스 계정 필요 |
| **CLI** | ✅ 안정 | 없음 | 직접 대화형 인터페이스 |
| **Web** | 🚧 계획 중 | API 키 또는 OAuth | 브라우저 기반 채팅 인터페이스 |
전체 구성 지침은 [채널 참조](docs/channels-reference.md)를 참조하세요.
## 도구 지원
ZeroClaw는 코드 실행, 파일 시스템 액세스 및 웹 검색을 위한 기본 제공 도구를 제공합니다:
| 도구 | 설명 | 필수 런타임 |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | 셸 명령 실행 | 네이티브 또는 Docker |
| **python** | Python 스크립트 실행 | Python 3.8+ (네이티브) 또는 Docker |
| **javascript** | Node.js 코드 실행 | Node.js 18+ (네이티브) 또는 Docker |
| **filesystem_read** | 파일 읽기 | 네이티브 또는 Docker |
| **filesystem_write** | 파일 쓰기 | 네이티브 또는 Docker |
| **web_fetch** | 웹 콘텐츠 가져오기 | 네이티브 또는 Docker |
### 실행 보안
- **네이티브 런타임** — 데몬의 사용자 프로세스로 실행, 파일 시스템에 전체 액세스
- **Docker 런타임** — 전체 컨테이너 격리, 별도의 파일 시스템 및 네트워크
`config.toml`에서 실행 정책을 구성하세요:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # 명시적 허용 목록
```
전체 보안 옵션은 [구성 참조](docs/config-reference.md#runtime)를 참조하세요.
## 배포
### 로컬 배포 (개발)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### 서버 배포 (프로덕션)
systemd를 사용하여 데몬과 에이전트를 서비스로 관리하세요:
```bash
# 바이너리 설치
cargo install --path . --locked
# 작업공간 구성
zeroclaw init
# systemd 서비스 파일 생성
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# 서비스 활성화 및 시작
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# 상태 확인
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
전체 프로덕션 배포 지침은 [네트워크 배포 가이드](docs/network-deployment.md)를 참조하세요.
### Docker
```bash
# 이미지 빌드
docker build -t zeroclaw:latest .
# 컨테이너 실행
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
빌드 세부 정보 및 구성 옵션은 [`Dockerfile`](Dockerfile)을 참조하세요.
### 엣지 하드웨어
ZeroClaw는 저전력 하드웨어에서 실행되도록 설계되었습니다:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, 단일 ARMv8 코어, < $5 하드웨어 비용
- **Raspberry Pi 4/5** — 1 GB+ RAM, 멀티코어, 동시 워크로드에 이상적
- **Orange Pi Zero 2** — ~512 MB RAM, 쿼드코어 ARMv8, 초저비용
- **x86 SBCs (Intel N100)** — 4-8 GB RAM, 빠른 빌드, 네이티브 Docker 지원
장치별 설정 지침은 [하드웨어 가이드](docs/hardware/README.md)를 참조하세요.
## 터널링 (공개 노출)
보안 터널을 통해 로컬 ZeroClaw 데몬을 공개 네트워크에 노출하세요:
```bash
zeroclaw tunnel start --provider cloudflare
```
지원되는 터널 제공자:
- **Cloudflare Tunnel** — 무료 HTTPS, 포트 노출 없음, 멀티 도메인 지원
- **Ngrok** — 빠른 설정, 사용자 정의 도메인 (유료 플랜)
- **Tailscale** — 프라이빗 메시 네트워크, 공개 포트 없음
전체 구성 옵션은 [구성 참조](docs/config-reference.md#tunnel)를 참조하세요.
## 보안
ZeroClaw는 여러 보안 계층을 구현합니다:
### 페어링
데몬은 첫 실행 시 `~/.zeroclaw/workspace/.pairing`에 저장된 페어링 시크릿을 생성합니다. 클라이언트(에이전트, CLI)는 연결하기 위해 이 시크릿을 제시해야 합니다.
```bash
zeroclaw pairing rotate # 새 시크릿 생성 및 이전 것 무효화
```
### 샌드박싱
- **Docker 런타임** — 별도의 파일 시스템 및 네트워크로 전체 컨테이너 격리
- **네이티브 런타임** — 사용자 프로세스로 실행, 기본적으로 작업공간으로 범위 지정
### 허용 목록
채널은 사용자 ID로 액세스를 제한할 수 있습니다:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # 명시적 허용 목록
```
### 암호화
- **Matrix E2EE** — 장치 확인과 함께 완전한 종단 간 암호화
- **TLS 전송** — 모든 API 및 터널 트래픽이 HTTPS/TLS 사용
전체 정책 및 관행은 [보안 문서](docs/security/README.md)를 참조하세요.
## 관찰 가능성
ZeroClaw는 기본적으로 `~/.zeroclaw/workspace/logs/`에 로그를 기록합니다. 로그는 구성 요소별로 저장됩니다:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # 데몬 로그 (시작, API 요청, 오류)
├── agent.log # 에이전트 로그 (메시지 라우팅, 도구 실행)
├── telegram.log # 채널별 로그 (활성화된 경우)
└── matrix.log # 채널별 로그 (활성화된 경우)
```
### 로깅 구성
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # 크기 기반 회전용
retention_days = 30 # N일 후 자동 삭제
```
모든 로깅 옵션은 [구성 참조](docs/config-reference.md#logging)를 참조하세요.
### 메트릭 (계획 중)
프로덕션 모니터링을 위한 Prometheus 메트릭 지원이 곧 제공됩니다. [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234)에서 추적 중.
## 스킬 (Skills)
ZeroClaw는 시스템 기능을 확장하는 재사용 가능한 모듈인 사용자 정의 스킬을 지원합니다.
### 스킬 정의
스킬은 다음 구조로 `~/.zeroclaw/workspace/skills/<skill-name>/`에 저장됩니다:
```
skills/
└── my-skill/
├── skill.toml # 스킬 메타데이터 (이름, 설명, 의존성)
├── prompt.md # AI용 시스템 프롬프트
└── tools/ # 선택적 사용자 정의 도구
└── my_tool.py
```
### 스킬 예제
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "웹 검색 및 결과 요약"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
당신은 연구 어시스턴트입니다. 무언가를 검색하라는 요청을 받으면:
1. web_fetch를 사용하여 콘텐츠 가져오기
2. 읽기 쉬운 형식으로 결과 요약
3. URL로 출처 인용
```
### 스킬 사용
스킬은 에이전트 시작 시 자동으로 로드됩니다. 대화에서 이름으로 참조하세요:
```
사용자: 웹 연구 스킬을 사용하여 최신 AI 뉴스 찾기
봇: [웹 연구 스킬 로드, web_fetch 실행, 결과 요약]
```
전체 스킬 생성 지침은 [스킬 (Skills)](#스킬-skills) 섹션을 참조하세요.
## Open Skills
ZeroClaw는 [Open Skills](https://github.com/openagents-com/open-skills)를 지원합니다 — AI 에이전트 기능을 확장하기 위한 모듈형 및 제공자 독립적인 시스템.
### Open Skills 활성화
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # 선택사항
```
런타임에 `ZEROCLAW_OPEN_SKILLS_ENABLED``ZEROCLAW_OPEN_SKILLS_DIR`로 재정의할 수도 있습니다.
## 개발
```bash
cargo build # 개발 빌드
cargo build --release # 릴리스 빌드 (codegen-units=1, Raspberry Pi 포함 모든 장치에서 작동)
cargo build --profile release-fast # 더 빠른 빌드 (codegen-units=8, 16 GB+ RAM 필요)
cargo test # 전체 테스트 스위트 실행
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # 포맷
# SQLite vs Markdown 비교 벤치마크 실행
cargo test --test memory_comparison -- --nocapture
```
### pre-push 훅
git 훅이 각 푸시 전에 `cargo fmt --check`, `cargo clippy -- -D warnings`, 그리고 `cargo test`를 실행합니다. 한 번 활성화하세요:
```bash
git config core.hooksPath .githooks
```
### 빌드 문제 해결 (Linux에서 OpenSSL 오류)
`openssl-sys` 빌드 오류가 발생하면 종속성을 동기화하고 저장소의 lockfile로 다시 빌드하세요:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw는 HTTP/TLS 종속성에 대해 `rustls`를 사용하도록 구성되어 있습니다; `--locked`는 깨끗한 환경에서 전이적 그래프를 결정적으로 유지합니다.
개발 중 빠른 푸시가 필요할 때 훅을 건너뛰려면:
```bash
git push --no-verify
```
## 협업 및 문서
작업 기반 맵을 위해 문서 허브로 시작하세요:
- 문서 허브: [`docs/README.md`](docs/README.md)
- 통합 문서 목차: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- 명령어 참조: [`docs/commands-reference.md`](docs/commands-reference.md)
- 구성 참조: [`docs/config-reference.md`](docs/config-reference.md)
- 제공자 참조: [`docs/providers-reference.md`](docs/providers-reference.md)
- 채널 참조: [`docs/channels-reference.md`](docs/channels-reference.md)
- 운영 런북: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- 문제 해결: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- 문서 인벤토리/분류: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- PR/이슈 트리아지 스냅샷 (2026년 2월 18일 기준): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
주요 협업 참조:
- 문서 허브: [docs/README.md](docs/README.md)
- 문서 템플릿: [docs/doc-template.md](docs/doc-template.md)
- 문서 변경 체크리스트: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- 채널 구성 참조: [docs/channels-reference.md](docs/channels-reference.md)
- Matrix 암호화 방 운영: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- 기여 가이드: [CONTRIBUTING.md](CONTRIBUTING.md)
- PR 워크플로 정책: [docs/pr-workflow.md](docs/pr-workflow.md)
- 리뷰어 플레이북 (트리아지 + 심층 리뷰): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- 소유권 및 CI 트리아지 맵: [docs/ci-map.md](docs/ci-map.md)
- 보안 공개 정책: [SECURITY.md](SECURITY.md)
배포 및 런타임 운영용:
- 네트워크 배포 가이드: [docs/network-deployment.md](docs/network-deployment.md)
- 프록시 에이전트 플레이북: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## ZeroClaw 지원하기
ZeroClaw가 당신의 작업에 도움이 되었고 지속적인 개발을 지원하고 싶다면 여기에서 기부할 수 있습니다:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="커피 한 잔 사주기" /></a>
### 🙏 특별 감사
이 오픈소스 작업에 영감을 주고 지원하는 커뮤니티와 기관에 진심으로 감사드립니다:
- **Harvard University** — 지적 호기심을 키우고 가능성의 한계를 넓혀줌.
- **MIT** — 열린 지식, 오픈소스, 기술이 모두에게 접근 가능해야 한다는 신념을 옹호함.
- **Sundai Club** — 커뮤니티, 에너지, 그리고 의미 있는 것을 만들고자 하는 끊임없는 의지.
- **세계 그리고 그 너머** 🌍✨ — 오픈소스를 선한 힘으로 만드는 모든 기여자, 꿈꾸는 자, 그리고 빌더에게. 이것은 여러분을 위한 것입니다.
우리는 최고의 아이디어가 모든 곳에서 나오기 때문에 오픈소스로 구축합니다. 이것을 읽고 있다면 여러분도 그 일부입니다. 환영합니다. 🦀❤️
## ⚠️ 공식 저장소 및 사칭 경고
**이것이 유일한 공식 ZeroClaw 저장소입니다:**
> <https://github.com/zeroclaw-labs/zeroclaw>
"ZeroClaw"라고 주장하거나 ZeroClaw Labs와의 제휴를 암시하는 다른 저장소, 조직, 도메인 또는 패키지는 **승인되지 않았으며 이 프로젝트와 관련이 없습니다**. 알려진 승인되지 않은 포크는 [TRADEMARK.md](TRADEMARK.md)에 나열됩니다.
사칭 또는 상표 오용을 발견하면 [이슈를 열어](https://github.com/zeroclaw-labs/zeroclaw/issues) 신고해 주세요.
---
## 라이선스
ZeroClaw는 최대한의 개방성과 기여자 보호를 위해 듀얼 라이선스가 적용됩니다:
| 라이선스 | 사용 사례 |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | 오픈소스, 연구, 학술, 개인 사용 |
| [Apache 2.0](LICENSE-APACHE) | 특허 보호, 기관, 상업 배포 |
두 라이선스 중 하나를 선택할 수 있습니다. **기여자는 자동으로 두 가지 모두에 대한 권한을 부여합니다** — 전체 기여자 계약은 [CLA.md](CLA.md)를 참조하세요.
### 상표
**ZeroClaw** 이름과 로고는 ZeroClaw Labs의 등록 상표입니다. 이 라이선스는 승인 또는 제휴를 암시하기 위해 사용할 수 있는 권한을 부여하지 않습니다. 허용 및 금지된 사용은 [TRADEMARK.md](TRADEMARK.md)를 참조하세요.
### 기여자 보호
- 기여의 **저작권을 유지**합니다
- **특허 부여** (Apache 2.0)가 다른 기여자의 특허 청구로부터 보호합니다
- 기여는 커밋 기록과 [NOTICE](NOTICE)에 **영구적으로 귀속**됩니다
- 기여함으로써 상표권이 이전되지 않습니다
## 기여하기
[CONTRIBUTING.md](CONTRIBUTING.md)와 [CLA.md](CLA.md)를 참조하세요. 트레이트를 구현하고 PR을 제출하세요:
- CI 워크플로 가이드: [docs/ci-map.md](docs/ci-map.md)
- 새 `Provider``src/providers/`
- 새 `Channel``src/channels/`
- 새 `Observer``src/observability/`
- 새 `Tool``src/tools/`
- 새 `Memory``src/memory/`
- 새 `Tunnel``src/tunnel/`
- 새 `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — 오버헤드 없음. 타협 없음. 어디서나 배포. 무엇이든 교체. 🦀
## 스타 히스토리
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="스타 히스토리 그래프" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

119
README.md
View File

@ -1,5 +1,5 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
<img src="docs/assets/zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
@ -25,12 +25,43 @@ Built by students and members of the Harvard, MIT, and Sundai.Club communities.
</p>
<p align="center">
🌐 <strong>Languages:</strong> <a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.ru.md">Русский</a> · <a href="README.fr.md">Français</a> · <a href="README.vi.md">Tiếng Việt</a>
🌐 <strong>Languages:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#quick-start">Getting Started</a> |
<a href="bootstrap.sh">One-Click Setup</a> |
<a href="install.sh">One-Click Setup</a> |
<a href="docs/README.md">Docs Hub</a> |
<a href="docs/SUMMARY.md">Docs TOC</a>
</p>
@ -38,8 +69,8 @@ Built by students and members of the Harvard, MIT, and Sundai.Club communities.
<p align="center">
<strong>Quick Routes:</strong>
<a href="docs/reference/README.md">Reference</a> ·
<a href="docs/operations/README.md">Operations</a> ·
<a href="docs/troubleshooting.md">Troubleshoot</a> ·
<a href="docs/ops/README.md">Operations</a> ·
<a href="docs/ops/troubleshooting.md">Troubleshoot</a> ·
<a href="docs/security/README.md">Security</a> ·
<a href="docs/hardware/README.md">Hardware</a> ·
<a href="docs/contributing/README.md">Contribute</a>
@ -95,7 +126,7 @@ Local machine quick benchmark (macOS arm64, Feb 2026) normalized for 0.8GHz edge
> Notes: ZeroClaw results are measured on release builds using `/usr/bin/time -l`. OpenClaw requires Node.js runtime (typically ~390MB additional memory overhead), while NanoBot requires Python runtime. PicoClaw and ZeroClaw are static binaries. The RAM figures above are runtime memory; build-time compilation requirements are higher.
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw Comparison" width="800" />
<img src="docs/assets/zeroclaw-comparison.jpeg" alt="ZeroClaw vs OpenClaw Comparison" width="800" />
</p>
### Reproducible local measurement
@ -180,7 +211,7 @@ Example sample (macOS arm64, measured on February 18, 2026):
Or skip the steps above and install everything (system deps, Rust, ZeroClaw) in a single command:
```bash
curl -LsSf https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/scripts/install.sh | bash
curl -LsSf https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/install.sh | bash
```
#### Compilation resource requirements
@ -195,13 +226,13 @@ Building from source needs more resources than running the resulting binary:
If your host is below the minimum, use pre-built binaries:
```bash
./bootstrap.sh --prefer-prebuilt
./install.sh --prefer-prebuilt
```
To require binary-only install with no source fallback:
```bash
./bootstrap.sh --prebuilt-only
./install.sh --prebuilt-only
```
#### Optional
@ -226,37 +257,37 @@ brew install zeroclaw
# Recommended: clone then run local bootstrap script
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
./bootstrap.sh
./install.sh
# Optional: bootstrap dependencies + Rust on fresh machines
./bootstrap.sh --install-system-deps --install-rust
./install.sh --install-system-deps --install-rust
# Optional: pre-built binary first (recommended on low-RAM/low-disk hosts)
./bootstrap.sh --prefer-prebuilt
./install.sh --prefer-prebuilt
# Optional: binary-only install (no source build fallback)
./bootstrap.sh --prebuilt-only
./install.sh --prebuilt-only
# Optional: run onboarding in the same flow
./bootstrap.sh --onboard --api-key "sk-..." --provider openrouter [--model "openrouter/auto"]
./install.sh --onboard --api-key "sk-..." --provider openrouter [--model "openrouter/auto"]
# Optional: run bootstrap + onboarding fully in Docker-compatible mode
./bootstrap.sh --docker
./install.sh --docker
# Optional: force Podman as container CLI
ZEROCLAW_CONTAINER_CLI=podman ./bootstrap.sh --docker
ZEROCLAW_CONTAINER_CLI=podman ./install.sh --docker
# Optional: in --docker mode, skip local image build and use local tag or pull fallback image
./bootstrap.sh --docker --skip-build
./install.sh --docker --skip-build
```
Remote one-liner (review first in security-sensitive environments):
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/scripts/bootstrap.sh | bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/install.sh | bash
```
Details: [`docs/one-click-bootstrap.md`](docs/one-click-bootstrap.md) (toolchain mode may request `sudo` for system packages).
Details: [`docs/setup-guides/one-click-bootstrap.md`](docs/setup-guides/one-click-bootstrap.md) (toolchain mode may request `sudo` for system packages).
### Pre-built binaries
@ -398,7 +429,7 @@ zeroclaw agent --provider anthropic -m "hello"
Every subsystem is a **trait** — swap implementations with a config change, zero code changes.
<p align="center">
<img src="docs/architecture.svg" alt="ZeroClaw Architecture" width="900" />
<img src="docs/assets/architecture.svg" alt="ZeroClaw Architecture" width="900" />
</p>
| Subsystem | Trait | Ships with | Extend |
@ -497,7 +528,7 @@ Inbound sender policy is now consistent:
This keeps accidental exposure low by default.
Full channel configuration reference: [docs/channels-reference.md](docs/channels-reference.md).
Full channel configuration reference: [docs/reference/api/channels-reference.md](docs/reference/api/channels-reference.md).
Recommended low-friction setup (secure + fast):
@ -816,7 +847,7 @@ default_model = "qwen3-30b-a3b-8bit"
### Custom Provider Endpoints
For detailed configuration of custom OpenAI-compatible and Anthropic-compatible endpoints, see [docs/custom-providers.md](docs/custom-providers.md).
For detailed configuration of custom OpenAI-compatible and Anthropic-compatible endpoints, see [docs/contributing/custom-providers.md](docs/contributing/custom-providers.md).
## Python Companion Package (`zeroclaw-tools`)
@ -980,7 +1011,7 @@ See [aieos.org](https://aieos.org) for the full schema and live examples.
| `hardware` | USB discover/introspect/info commands |
| `peripheral` | Manage and flash hardware peripherals |
For a task-oriented command guide, see [`docs/commands-reference.md`](docs/commands-reference.md).
For a task-oriented command guide, see [`docs/reference/cli/commands-reference.md`](docs/reference/cli/commands-reference.md).
### Service Management
@ -1004,7 +1035,7 @@ sudo rc-update add zeroclaw default
sudo rc-service zeroclaw start
```
For full OpenRC setup instructions, see [docs/network-deployment.md](docs/network-deployment.md#7-openrc-alpine-linux-service).
For full OpenRC setup instructions, see [docs/ops/network-deployment.md](docs/ops/network-deployment.md#7-openrc-alpine-linux-service).
### Open-Skills Opt-In
@ -1061,31 +1092,31 @@ Start from the docs hub for a task-oriented map:
- Documentation hub: [`docs/README.md`](docs/README.md)
- Unified docs TOC: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Commands reference: [`docs/commands-reference.md`](docs/commands-reference.md)
- Config reference: [`docs/config-reference.md`](docs/config-reference.md)
- Providers reference: [`docs/providers-reference.md`](docs/providers-reference.md)
- Channels reference: [`docs/channels-reference.md`](docs/channels-reference.md)
- Operations runbook: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Troubleshooting: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Docs inventory/classification: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- PR/Issue triage snapshot (as of February 18, 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
- Commands reference: [`docs/reference/cli/commands-reference.md`](docs/reference/cli/commands-reference.md)
- Config reference: [`docs/reference/api/config-reference.md`](docs/reference/api/config-reference.md)
- Providers reference: [`docs/reference/api/providers-reference.md`](docs/reference/api/providers-reference.md)
- Channels reference: [`docs/reference/api/channels-reference.md`](docs/reference/api/channels-reference.md)
- Operations runbook: [`docs/ops/operations-runbook.md`](docs/ops/operations-runbook.md)
- Troubleshooting: [`docs/ops/troubleshooting.md`](docs/ops/troubleshooting.md)
- Docs inventory/classification: [`docs/maintainers/docs-inventory.md`](docs/maintainers/docs-inventory.md)
- PR/Issue triage snapshot (as of February 18, 2026): [`docs/maintainers/project-triage-snapshot-2026-02-18.md`](docs/maintainers/project-triage-snapshot-2026-02-18.md)
Core collaboration references:
- Documentation hub: [docs/README.md](docs/README.md)
- Documentation template: [docs/doc-template.md](docs/doc-template.md)
- Documentation template: [docs/contributing/doc-template.md](docs/contributing/doc-template.md)
- Documentation change checklist: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Channel configuration reference: [docs/channels-reference.md](docs/channels-reference.md)
- Matrix encrypted-room operations: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Channel configuration reference: [docs/reference/api/channels-reference.md](docs/reference/api/channels-reference.md)
- Matrix encrypted-room operations: [docs/security/matrix-e2ee-guide.md](docs/security/matrix-e2ee-guide.md)
- Contribution guide: [CONTRIBUTING.md](CONTRIBUTING.md)
- PR workflow policy: [docs/pr-workflow.md](docs/pr-workflow.md)
- Reviewer playbook (triage + deep review): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- PR workflow policy: [docs/contributing/pr-workflow.md](docs/contributing/pr-workflow.md)
- Reviewer playbook (triage + deep review): [docs/contributing/reviewer-playbook.md](docs/contributing/reviewer-playbook.md)
- Security disclosure policy: [SECURITY.md](SECURITY.md)
For deployment and runtime operations:
- Network deployment guide: [docs/network-deployment.md](docs/network-deployment.md)
- Proxy agent playbook: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
- Network deployment guide: [docs/ops/network-deployment.md](docs/ops/network-deployment.md)
- Proxy agent playbook: [docs/ops/proxy-agent-playbook.md](docs/ops/proxy-agent-playbook.md)
## Support ZeroClaw
@ -1110,7 +1141,7 @@ We're building in the open because the best ideas come from everywhere. If you'r
> https://github.com/zeroclaw-labs/zeroclaw
Any other repository, organization, domain, or package claiming to be "ZeroClaw" or implying affiliation with ZeroClaw Labs is **unauthorized and not affiliated with this project**. Known unauthorized forks will be listed in [TRADEMARK.md](TRADEMARK.md).
Any other repository, organization, domain, or package claiming to be "ZeroClaw" or implying affiliation with ZeroClaw Labs is **unauthorized and not affiliated with this project**. Known unauthorized forks will be listed in [TRADEMARK.md](docs/maintainers/trademark.md).
If you encounter impersonation or trademark misuse, please [open an issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
@ -1125,11 +1156,11 @@ ZeroClaw is dual-licensed for maximum openness and contributor protection:
| [MIT](LICENSE-MIT) | Open-source, research, academic, personal use |
| [Apache 2.0](LICENSE-APACHE) | Patent protection, institutional, commercial deployment |
You may choose either license. **Contributors automatically grant rights under both** — see [CLA.md](CLA.md) for the full contributor agreement.
You may choose either license. **Contributors automatically grant rights under both** — see [CLA.md](docs/contributing/cla.md) for the full contributor agreement.
### Trademark
The **ZeroClaw** name and logo are trademarks of ZeroClaw Labs. This license does not grant permission to use them to imply endorsement or affiliation. See [TRADEMARK.md](TRADEMARK.md) for permitted and prohibited uses.
The **ZeroClaw** name and logo are trademarks of ZeroClaw Labs. This license does not grant permission to use them to imply endorsement or affiliation. See [TRADEMARK.md](docs/maintainers/trademark.md) for permitted and prohibited uses.
### Contributor Protections
@ -1142,9 +1173,9 @@ The **ZeroClaw** name and logo are trademarks of ZeroClaw Labs. This license doe
New to ZeroClaw? Look for issues labeled [`good first issue`](https://github.com/zeroclaw-labs/zeroclaw/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) — see our [Contributing Guide](CONTRIBUTING.md#first-time-contributors) for how to get started.
See [CONTRIBUTING.md](CONTRIBUTING.md) and [CLA.md](CLA.md). Implement a trait, submit a PR:
See [CONTRIBUTING.md](CONTRIBUTING.md) and [CLA.md](docs/contributing/cla.md). Implement a trait, submit a PR:
- CI workflow guide: [docs/ci-map.md](docs/ci-map.md)
- CI workflow guide: [docs/contributing/ci-map.md](docs/contributing/ci-map.md)
- New `Provider``src/providers/`
- New `Channel``src/channels/`
- New `Observer``src/observability/`

179
README.nb.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Null overhead. Null kompromiss. 100% Rust. 100% Agnostisk.</strong><br>
⚡️ <strong>Kjører på $10 maskinvare med <5MB RAM: Det er 99% mindre minne enn OpenClaw og 98% billigere enn en Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Språk:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## Hva er ZeroClaw?
ZeroClaw er en lettvektig, foranderlig og utvidbar AI-assistent-infrastruktur bygget i Rust. Den kobler sammen ulike LLM-leverandører (Anthropic, OpenAI, Google, Ollama osv.) via et samlet grensesnitt og støtter flere kanaler (Telegram, Matrix, CLI osv.).
### Hovedfunksjoner
- **🦀 Skrevet i Rust**: Høy ytelse, minnesikkerhet og nullkostnads-abstraksjoner
- **🔌 Leverandør-agnostisk**: Støtter OpenAI, Anthropic, Google Gemini, Ollama og andre
- **📱 Multi-kanal**: Telegram, Matrix (med E2EE), CLI og andre
- **🧠 Pluggbart minne**: SQLite og Markdown-backends
- **🛠️ Utvidbare verktøy**: Legg til tilpassede verktøy enkelt
- **🔒 Sikkerhet først**: Omvendt proxy, personvern-først design
---
## Rask Start
### Krav
- Rust 1.70+
- En LLM-leverandør API-nøkkel (Anthropic, OpenAI osv.)
### Installasjon
```bash
# Klon repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Bygg
cargo build --release
# Kjør
cargo run --release
```
### Med Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Konfigurasjon
ZeroClaw bruker en YAML-konfigurasjonsfil. Som standard ser den etter `config.yaml`.
```yaml
# Standardleverandør
provider: anthropic
# Leverandørkonfigurasjon
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Minnekonfigurasjon
memory:
backend: sqlite
path: data/memory.db
# Kanalkonfigurasjon
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Dokumentasjon
For detaljert dokumentasjon, se:
- [Dokumentasjonshub](docs/README.md)
- [Kommandoreferanse](docs/commands-reference.md)
- [Leverandørreferanse](docs/providers-reference.md)
- [Kanalreferanse](docs/channels-reference.md)
- [Konfigurasjonsreferanse](docs/config-reference.md)
---
## Bidrag
Bidrag er velkomne! Vennligst les [Bidragsguiden](CONTRIBUTING.md).
---
## Lisens
Dette prosjektet er dobbelt-lisensiert:
- MIT License
- Apache License, versjon 2.0
Se [LICENSE-APACHE](LICENSE-APACHE) og [LICENSE-MIT](LICENSE-MIT) for detaljer.
---
## Fellesskap
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Sponsorer
Hvis ZeroClaw er nyttig for deg, vennligst vurder å kjøpe oss en kaffe:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

914
README.nl.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Nul overhead. Nul compromis. 100% Rust. 100% Agnostisch.</strong><br>
⚡️ <strong>Draait op $10 hardware met <5MB RAM: Dat is 99% minder geheugen dan OpenClaw en 98% goedkoper dan een Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Gebouwd door studenten en leden van de Harvard, MIT en Sundai.Club gemeenschappen.
</p>
<p align="center">
🌐 <strong>Talen:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#snelle-start">Snelle Start</a> |
<a href="bootstrap.sh">One-Click Setup</a> |
<a href="docs/README.md">Documentatie Hub</a> |
<a href="docs/SUMMARY.md">Documentatie Inhoudsopgave</a>
</p>
<p align="center">
<strong>Snelle toegang:</strong>
<a href="docs/reference/README.md">Referentie</a> ·
<a href="docs/operations/README.md">Operations</a> ·
<a href="docs/troubleshooting.md">Probleemoplossing</a> ·
<a href="docs/security/README.md">Beveiliging</a> ·
<a href="docs/hardware/README.md">Hardware</a> ·
<a href="docs/contributing/README.md">Bijdragen</a>
</p>
<p align="center">
<strong>Snelle, lichtgewicht en volledig autonome AI-assistent infrastructuur</strong><br />
Implementeer overal. Wissel alles.
</p>
<p align="center">
ZeroClaw is het <strong>runtime besturingssysteem</strong> voor agent workflows — een infrastructuur die modellen, tools, geheugen en uitvoering abstraheert om agenten één keer te bouwen en overal uit te voeren.
</p>
<p align="center"><code>Trait-gedreven architectuur · veilige runtime standaard · verwisselbare provider/kanaal/tool · alles is plugbaar</code></p>
### 📢 Aankondigingen
Gebruik deze tabel voor belangrijke aankondigingen (compatibiliteitswijzigingen, beveiligingsberichten, onderhoudsvensters en versieblokkades).
| Datum (UTC) | Niveau | Aankondiging | Actie |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Kritiek_ | **We zijn niet gelieerd** met `openagen/zeroclaw` of `zeroclaw.org`. Het domein `zeroclaw.org` wijst momenteel naar de fork `openagen/zeroclaw`, en dit domein/repository imiteert onze officiële website/project. | Vertrouw geen informatie, binaire bestanden, fondsenwerving of aankondigingen van deze bronnen. Gebruik alleen [deze repository](https://github.com/zeroclaw-labs/zeroclaw) en onze geverifieerde sociale media accounts. |
| 2026-02-21 | _Belangrijk_ | Onze officiële website is nu online: [zeroclawlabs.ai](https://zeroclawlabs.ai). Bedankt voor je geduld tijdens het wachten. We detecteren nog steeds imitatiepogingen: neem niet deel aan enige investering/fondsenwerving activiteit in naam van ZeroClaw als deze niet via onze officiële kanalen wordt gepubliceerd. | Gebruik [deze repository](https://github.com/zeroclaw-labs/zeroclaw) als de enige bron van waarheid. Volg [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (groep)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), en [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) voor officiële updates. |
| 2026-02-19 | _Belangrijk_ | Anthropic heeft de gebruiksvoorwaarden voor authenticatie en inloggegevens bijgewerkt op 2026-02-19. OAuth authenticatie (Free, Pro, Max) is exclusief voor Claude Code en Claude.ai; het gebruik van Claude Free/Pro/Max OAuth tokens in enig ander product, tool of service (inclusief Agent SDK) is niet toegestaan en kan in strijd zijn met de Consumenten Gebruiksvoorwaarden. | Vermijd tijdelijk Claude Code OAuth integraties om potentiële verliezen te voorkomen. Originele clausule: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Functies
- 🏎️ **Lichtgewicht Runtime Standaard:** Veelvoorkomende CLI workflows en statuscommando's draaien binnen een geheugenruimte van enkele megabytes in productie builds.
- 💰 **Kosteneffectieve Implementatie:** Ontworpen voor goedkope boards en kleine cloud instanties zonder zware runtime afhankelijkheden.
- ⚡ **Snelle Koude Starts:** De single-binary Rust runtime houdt commando en daemon starts bijna direct voor dagelijkse operaties.
- 🌍 **Draagbare Architectuur:** Een single-binary workflow op ARM, x86 en RISC-V met verwisselbare provider/kanaal/tool.
### Waarom teams kiezen voor ZeroClaw
- **Lichtgewicht standaard:** kleine Rust binary, snelle start, laag geheugengebruik.
- **Veilig door design:** pairing, strikte sandboxing, expliciete allowlists, workspace scope.
- **Volledig verwisselbaar:** kernsystemen zijn traits (providers, kanalen, tools, geheugen, tunnels).
- **Geen vendor lock-in:** OpenAI-compatibele provider ondersteuning + plugbare custom endpoints.
## Benchmark Snapshot (ZeroClaw vs OpenClaw, Reproduceerbaar)
Snelle benchmark op lokale machine (macOS arm64, feb. 2026) genormaliseerd voor 0.8 GHz edge hardware.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Taal** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Start (0.8 GHz core)** | > 500s | > 30s | < 1s | **< 10ms** |
| **Binary Grootte** | ~28 MB (dist) | N/A (Scripts) | ~8 MB | **3.4 MB** |
| **Kosten** | Mac Mini $599 | Linux SBC ~$50 | Linux board $10 | **Elke hardware $10** |
> Opmerkingen: ZeroClaw resultaten worden gemeten op productie builds met `/usr/bin/time -l`. OpenClaw vereist de Node.js runtime (typisch ~390 MB extra geheugen overhead), terwijl NanoBot de Python runtime vereist. PicoClaw en ZeroClaw zijn statische binaries. De bovenstaande RAM cijfers zijn runtime geheugen; build-time compilatievereisten zijn hoger.
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw Vergelijking" width="800" />
</p>
### Reproduceerbare Lokale Meting
Benchmark beweringen kunnen afwijken naarmate code en toolchains evolueren, dus meet altijd je huidige build lokaal:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Voorbeeld monster (macOS arm64, gemeten op 18 februari 2026):
- Release binary grootte: `8.8M`
- `zeroclaw --help`: werkelijke tijd ongeveer `0.02s`, piek geheugengebruik ~`3.9 MB`
- `zeroclaw status`: werkelijke tijd ongeveer `0.01s`, piek geheugengebruik ~`4.1 MB`
## Vereisten
<details>
<summary><strong>Windows</strong></summary>
### Windows — Vereist
1. **Visual Studio Build Tools** (levert MSVC linker en Windows SDK):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Selecteer tijdens de installatie (of via Visual Studio Installer) de **"Desktop development with C++"** workload.
2. **Rust Toolchain:**
```powershell
winget install Rustlang.Rustup
```
Na installatie, open een nieuwe terminal en voer `rustup default stable` uit om ervoor te zorgen dat de stabiele toolchain actief is.
3. **Verifieer** dat beide werken:
```powershell
rustc --version
cargo --version
```
### Windows — Optioneel
- **Docker Desktop** — alleen vereist als je de [Docker sandboxed runtime](#huidige-runtime-ondersteuning) gebruikt (`runtime.kind = "docker"`). Installeer via `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Vereist
1. **Essentiële build tools:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Installeer Xcode Command Line Tools: `xcode-select --install`
2. **Rust Toolchain:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Zie [rustup.rs](https://rustup.rs) voor details.
3. **Verifieer:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — Optioneel
- **Docker** — alleen vereist als je de [Docker sandboxed runtime](#huidige-runtime-ondersteuning) gebruikt (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** zie [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** zie [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** installeer Docker Desktop via [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## Snelle Start
### Optie 1: Geautomatiseerde setup (aanbevolen)
Het `bootstrap.sh` script installeert Rust, kloont ZeroClaw, compileert het, en stelt je initiële ontwikkelomgeving in:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
Dit zal:
1. Rust installeren (indien afwezig)
2. De ZeroClaw repository klonen
3. ZeroClaw compileren in release modus
4. `zeroclaw` installeren in `~/.cargo/bin/`
5. De standaard workspace structuur maken in `~/.zeroclaw/workspace/`
6. Een initiële configuratie `~/.zeroclaw/workspace/config.toml` genereren
Na de bootstrap, herlaad je shell of voer `source ~/.cargo/env` uit om het `zeroclaw` commando globaal te gebruiken.
### Optie 2: Handmatige installatie
<details>
<summary><strong>Klik om handmatige installatiestappen te zien</strong></summary>
```bash
# 1. Kloon de repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. Compileer in release
cargo build --release --locked
# 3. Installeer de binary
cargo install --path . --locked
# 4. Initialiseer de workspace
zeroclaw init
# 5. Verifieer de installatie
zeroclaw --version
zeroclaw status
```
</details>
### Na Installatie
Eenmaal geïnstalleerd (via bootstrap of handmatig), zou je moeten zien:
```
~/.zeroclaw/workspace/
├── config.toml # Hoofdconfiguratie
├── .pairing # Pairing geheimen (gegenereerd bij eerste lancering)
├── logs/ # Daemon/agent logs
├── skills/ # Aangepaste vaardigheden
└── memory/ # Gesprekscontext opslag
```
**Volgende stappen:**
1. Configureer je AI providers in `~/.zeroclaw/workspace/config.toml`
2. Bekijk de [configuratie referentie](docs/config-reference.md) voor geavanceerde opties
3. Start de agent: `zeroclaw agent start`
4. Test via je voorkeurskanaal (zie [kanalen referentie](docs/channels-reference.md))
## Configuratie
Bewerk `~/.zeroclaw/workspace/config.toml` om providers, kanalen en systeemgedrag te configureren.
### Snelle Configuratie Referentie
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # of "sqlite" of "none"
[runtime]
kind = "native" # of "docker" (vereist Docker)
```
**Volledige referentie documenten:**
- [Configuratie Referentie](docs/config-reference.md) — alle instellingen, validaties, standaardwaarden
- [Providers Referentie](docs/providers-reference.md) — AI provider-specifieke configuraties
- [Kanalen Referentie](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord en meer
- [Operations](docs/operations-runbook.md) — productie monitoring, geheim rotatie, schaling
### Huidige Runtime Ondersteuning
ZeroClaw ondersteunt twee code uitvoeringsbackends:
- **`native`** (standaard) — directe procesuitvoering, snelste pad, ideaal voor vertrouwde omgevingen
- **`docker`** — volledige container isolatie, versterkt beveiligingsbeleid, vereist Docker
Gebruik `runtime.kind = "docker"` als je strikte sandboxing of netwerkisolatie nodig hebt. Zie [configuratie referentie](docs/config-reference.md#runtime) voor volledige details.
## Commando's
```bash
# Workspace beheer
zeroclaw init # Initialiseert een nieuwe workspace
zeroclaw status # Toont daemon/agent status
zeroclaw config validate # Verifieert config.toml syntax en waarden
# Daemon beheer
zeroclaw daemon start # Start de daemon in de achtergrond
zeroclaw daemon stop # Stopt de draaiende daemon
zeroclaw daemon restart # Herstart de daemon (config herladen)
zeroclaw daemon logs # Toont daemon logs
# Agent beheer
zeroclaw agent start # Start de agent (vereist draaiende daemon)
zeroclaw agent stop # Stopt de agent
zeroclaw agent restart # Herstart de agent (config herladen)
# Pairing operaties
zeroclaw pairing init # Genereert een nieuw pairing geheim
zeroclaw pairing rotate # Roteert het bestaande pairing geheim
# Tunneling (voor publieke blootstelling)
zeroclaw tunnel start # Start een tunnel naar de lokale daemon
zeroclaw tunnel stop # Stopt de actieve tunnel
# Diagnostiek
zeroclaw doctor # Voert systeem gezondheidscontroles uit
zeroclaw version # Toont versie en build informatie
```
Zie [Commando's Referentie](docs/commands-reference.md) voor volledige opties en voorbeelden.
## Architectuur
```
┌─────────────────────────────────────────────────────────────────┐
│ Kanalen (trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Agent Orchestrator │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Bericht │ │ Context │ │ Tool │ │
│ │ Routing │ │ Geheugen │ │ Uitvoering │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Providers │ │ Geheugen │ │ Tools │
│ (trait) │ │ (trait) │ │ (trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Runtime (trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Belangrijkste principes:**
- Alles is een **trait** — providers, kanalen, tools, geheugen, tunnels
- Kanalen roepen de orchestrator aan; de orchestrator roept providers + tools aan
- Het geheugensysteem beheert gesprekscontext (markdown, SQLite, of geen)
- De runtime abstraheert code-uitvoering (native of Docker)
- Geen provider lock-in — wissel Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama zonder codewijzigingen
Zie [architectuur documentatie](docs/architecture.svg) voor gedetailleerde diagrammen en implementatiedetails.
## Voorbeelden
### Telegram Bot
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Je Telegram user ID
```
Start de daemon + agent, stuur dan een bericht naar je bot op Telegram:
```
/start
Hallo! Zou je me kunnen helpen met het schrijven van een Python script?
```
De bot reageert met AI-gegenereerde code, voert tools uit indien gevraagd, en behoudt gesprekscontext.
### Matrix (end-to-end encryptie)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Nodig `@zeroclaw:matrix.org` uit in een versleutelde kamer, en de bot zal reageren met volledige encryptie. Zie [Matrix E2EE Gids](docs/matrix-e2ee-guide.md) voor apparaatverificatie setup.
### Multi-Provider
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Failover bij provider fout
```
Als Anthropic faalt of rate-limit heeft, schakelt de orchestrator automatisch over naar OpenAI.
### Aangepast Geheugen
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # Automatische opruiming na 90 dagen
```
Of gebruik Markdown voor mens-leesbare opslag:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Zie [Configuratie Referentie](docs/config-reference.md#memory) voor alle geheugenopties.
## Provider Ondersteuning
| Provider | Status | API Sleutel | Voorbeeld Modellen |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Stabiel | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Stabiel | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Stabiel | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Stabiel | N/A (lokaal) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Stabiel | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Stabiel | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Gepland | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Gepland | `COHERE_API_KEY` | TBD |
### Aangepaste Endpoints
ZeroClaw ondersteunt OpenAI-compatibele endpoints:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Voorbeeld: gebruik [LiteLLM](https://github.com/BerriAI/litellm) als proxy om toegang te krijgen tot elke LLM via de OpenAI interface.
Zie [Providers Referentie](docs/providers-reference.md) voor volledige configuratiedetails.
## Kanaal Ondersteuning
| Kanaal | Status | Authenticatie | Opmerkingen |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Stabiel | Bot Token | Volledige ondersteuning inclusief bestanden, afbeeldingen, inline knoppen |
| **Matrix** | ✅ Stabiel | Wachtwoord of Token | E2EE ondersteuning met apparaatverificatie |
| **Slack** | 🚧 Gepland | OAuth of Bot Token | Vereist workspace toegang |
| **Discord** | 🚧 Gepland | Bot Token | Vereist guild permissies |
| **WhatsApp** | 🚧 Gepland | Twilio of officiële API | Vereist business account |
| **CLI** | ✅ Stabiel | Geen | Directe conversationele interface |
| **Web** | 🚧 Gepland | API Sleutel of OAuth | Browser-gebaseerde chat interface |
Zie [Kanalen Referentie](docs/channels-reference.md) voor volledige configuratie-instructies.
## Tool Ondersteuning
ZeroClaw biedt ingebouwde tools voor code-uitvoering, bestandssysteem toegang en web retrieval:
| Tool | Beschrijving | Vereiste Runtime |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Voert shell commando's uit | Native of Docker |
| **python** | Voert Python scripts uit | Python 3.8+ (native) of Docker |
| **javascript** | Voert Node.js code uit | Node.js 18+ (native) of Docker |
| **filesystem_read** | Leest bestanden | Native of Docker |
| **filesystem_write** | Schrijft bestanden | Native of Docker |
| **web_fetch** | Haalt web inhoud op | Native of Docker |
### Uitvoeringsbeveiliging
- **Native Runtime** — draait als gebruikersproces van de daemon, volledige bestandssysteem toegang
- **Docker Runtime** — volledige container isolatie, gescheiden bestandssystemen en netwerken
Configureer het uitvoeringsbeleid in `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Expliciete allowlist
```
Zie [Configuratie Referentie](docs/config-reference.md#runtime) voor volledige beveiligingsopties.
## Implementatie
### Lokale Implementatie (Ontwikkeling)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Server Implementatie (Productie)
Gebruik systemd om daemon en agent als services te beheren:
```bash
# Installeer de binary
cargo install --path . --locked
# Configureer de workspace
zeroclaw init
# Maak systemd service bestanden
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# Schakel in en start de services
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# Verifieer de status
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Zie [Netwerk Implementatie Gids](docs/network-deployment.md) voor volledige productie-implementatie instructies.
### Docker
```bash
# Bouw de image
docker build -t zeroclaw:latest .
# Draai de container
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Zie [`Dockerfile`](Dockerfile) voor bouw-details en configuratie-opties.
### Edge Hardware
ZeroClaw is ontworpen om te draaien op laagvermogen hardware:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, enkele ARMv8 core, < $5 hardware kosten
- **Raspberry Pi 4/5** — 1 GB+ RAM, multi-core, ideaal voor gelijktijdige workloads
- **Orange Pi Zero 2** — ~512 MB RAM, quad-core ARMv8, ultra-lage kosten
- **x86 SBCs (Intel N100)** — 4-8 GB RAM, snelle builds, native Docker ondersteuning
Zie [Hardware Gids](docs/hardware/README.md) voor apparaat-specifieke setup instructies.
## Tunneling (Publieke Blootstelling)
Stel je lokale ZeroClaw daemon bloot aan het publieke netwerk via beveiligde tunnels:
```bash
zeroclaw tunnel start --provider cloudflare
```
Ondersteunde tunnel providers:
- **Cloudflare Tunnel** — gratis HTTPS, geen poort blootstelling, multi-domein ondersteuning
- **Ngrok** — snelle setup, aangepaste domeinen (betaald plan)
- **Tailscale** — privé mesh netwerk, geen publieke poort
Zie [Configuratie Referentie](docs/config-reference.md#tunnel) voor volledige configuratie-opties.
## Beveiliging
ZeroClaw implementeert meerdere beveiligingslagen:
### Pairing
De daemon genereert een pairing geheim bij de eerste lancering opgeslagen in `~/.zeroclaw/workspace/.pairing`. Clients (agent, CLI) moeten dit geheim presenteren om verbinding te maken.
```bash
zeroclaw pairing rotate # Genereert een nieuw geheim en invalideert het oude
```
### Sandboxing
- **Docker Runtime** — volledige container isolatie met gescheiden bestandssystemen en netwerken
- **Native Runtime** — draait als gebruikersproces, standaard scoped naar workspace
### Allowlists
Kanalen kunnen toegang beperken per user ID:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Expliciete allowlist
```
### Encryptie
- **Matrix E2EE** — volledige end-to-end encryptie met apparaatverificatie
- **TLS Transport** — alle API en tunnel verkeer gebruikt HTTPS/TLS
Zie [Beveiligingsdocumentatie](docs/security/README.md) voor volledig beleid en praktijken.
## Observeerbaarheid
ZeroClaw logt naar `~/.zeroclaw/workspace/logs/` standaard. Logs worden per component opgeslagen:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Daemon logs (startup, API verzoeken, fouten)
├── agent.log # Agent logs (bericht routing, tool uitvoering)
├── telegram.log # Kanaal-specifieke logs (indien ingeschakeld)
└── matrix.log # Kanaal-specifieke logs (indien ingeschakeld)
```
### Logging Configuratie
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # Voor grootte-gebaseerde rotatie
retention_days = 30 # Automatische opruiming na N dagen
```
Zie [Configuratie Referentie](docs/config-reference.md#logging) voor alle logging-opties.
### Metrieken (Gepland)
Prometheus metrieken ondersteuning voor productie monitoring komt binnenkort. Tracking in [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## Vaardigheden
ZeroClaw ondersteunt aangepaste vaardigheden — herbruikbare modules die systeemmogelijkheden uitbreiden.
### Vaardigheidsdefinitie
Vaardigheden worden opgeslagen in `~/.zeroclaw/workspace/skills/<skill-name>/` met deze structuur:
```
skills/
└── my-skill/
├── skill.toml # Vaardigheidsmetadata (naam, beschrijving, afhankelijkheden)
├── prompt.md # Systeem prompt voor de AI
└── tools/ # Optionele aangepaste tools
└── my_tool.py
```
### Vaardigheidsvoorbeeld
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Zoekt op het web en vat resultaten samen"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
Je bent een onderzoeksassistent. Wanneer gevraagd wordt om iets te onderzoeken:
1. Gebruik web_fetch om inhoud op te halen
2. Vat resultaten samen in een gemakkelijk leesbaar formaat
3. Citeer bronnen met URL's
```
### Vaardigheidsgebruik
Vaardigheden worden automatisch geladen bij agent startup. Referentie ze bij naam in gesprekken:
```
Gebruiker: Gebruik de web-research vaardigheid om het laatste AI nieuws te vinden
Bot: [laadt web-research vaardigheid, voert web_fetch uit, vat resultaten samen]
```
Zie [Vaardigheden](#vaardigheden) sectie voor volledige vaardigheidscreatie-instructies.
## Open Skills
ZeroClaw ondersteunt [Open Skills](https://github.com/openagents-com/open-skills) — een modulair en provider-agnostisch systeem voor het uitbreiden van AI-agent mogelijkheden.
### Open Skills Inschakelen
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # optioneel
```
Je kunt ook tijdens runtime overschrijven met `ZEROCLAW_OPEN_SKILLS_ENABLED` en `ZEROCLAW_OPEN_SKILLS_DIR`.
## Ontwikkeling
```bash
cargo build # Dev build
cargo build --release # Release build (codegen-units=1, werkt op alle apparaten inclusief Raspberry Pi)
cargo build --profile release-fast # Snellere build (codegen-units=8, vereist 16 GB+ RAM)
cargo test # Voer volledige test suite uit
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Formaat
# Voer SQLite vs Markdown vergelijkingsbenchmark uit
cargo test --test memory_comparison -- --nocapture
```
### Pre-push hook
Een git hook voert `cargo fmt --check`, `cargo clippy -- -D warnings`, en `cargo test` uit voor elke push. Schakel het één keer in:
```bash
git config core.hooksPath .githooks
```
### Build Probleemoplossing (OpenSSL fouten op Linux)
Als je een `openssl-sys` build fout tegenkomt, synchroniseer afhankelijkheden en compileer opnieuw met de repository's lockfile:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw is geconfigureerd om `rustls` te gebruiken voor HTTP/TLS afhankelijkheden; `--locked` houdt de transitieve grafiek deterministisch in schone omgevingen.
Om de hook over te slaan wanneer je een snelle push nodig hebt tijdens ontwikkeling:
```bash
git push --no-verify
```
## Samenwerking & Docs
Begin met de documentatie hub voor een taak-gebaseerde kaart:
- Documentatie Hub: [`docs/README.md`](docs/README.md)
- Geünificeerde Docs TOC: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Commando's Referentie: [`docs/commands-reference.md`](docs/commands-reference.md)
- Configuratie Referentie: [`docs/config-reference.md`](docs/config-reference.md)
- Providers Referentie: [`docs/providers-reference.md`](docs/providers-reference.md)
- Kanalen Referentie: [`docs/channels-reference.md`](docs/channels-reference.md)
- Operations Runbook: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Probleemoplossing: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Docs Inventaris/Classificatie: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- PR/Issue Triage Snapshot (vanaf 18 feb. 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Belangrijkste samenwerkingsreferenties:
- Documentatie Hub: [docs/README.md](docs/README.md)
- Documentatie Sjabloon: [docs/doc-template.md](docs/doc-template.md)
- Documentatiewijziging Checklist: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Kanaal Configuratie Referentie: [docs/channels-reference.md](docs/channels-reference.md)
- Matrix Versleutelde Kamer Operations: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Bijdrage Gids: [CONTRIBUTING.md](CONTRIBUTING.md)
- PR Workflow Beleid: [docs/pr-workflow.md](docs/pr-workflow.md)
- Reviewer Playbook (triage + diepgaande review): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Eigendom en CI Triage Kaart: [docs/ci-map.md](docs/ci-map.md)
- Beveiligingsopenbaarmaking Beleid: [SECURITY.md](SECURITY.md)
Voor implementatie en runtime operaties:
- Netwerk Implementatie Gids: [docs/network-deployment.md](docs/network-deployment.md)
- Proxy Agent Playbook: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## ZeroClaw Ondersteunen
Als ZeroClaw je werk helpt en je de doorlopende ontwikkeling wilt ondersteunen, kun je hier doneren:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Koop Een Koffie Voor Mij" /></a>
### 🙏 Speciale Dank
Een oprechte dankjewel aan de gemeenschappen en instellingen die dit open-source werk inspireren en voeden:
- **Harvard University** — voor het bevorderen van intellectuele nieuwsgierigheid en het verleggen van de grenzen van wat mogelijk is.
- **MIT** — voor het verdedigen van open kennis, open source, en de overtuiging dat technologie toegankelijk moet zijn voor iedereen.
- **Sundai Club** — voor de gemeenschap, energie, en de onophoudelijke wil om dingen te bouwen die ertoe doen.
- **De Wereld en Verder** 🌍✨ — aan elke bijdrager, dromer, en bouwer daarbuiten die open source tot een kracht voor goed maakt. Dit is voor jou.
We bouwen in open source omdat de beste ideeën van overal komen. Als je dit leest, ben je er deel van. Welkom. 🦀❤️
## ⚠️ Officiële Repository en Waarschuwing voor Imitatie
**Dit is de enige officiële ZeroClaw repository:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Elke andere repository, organisatie, domein of pakket dat beweert "ZeroClaw" te zijn of affiniteit met ZeroClaw Labs suggereert is **niet-geautoriseerd en niet gelieerd aan dit project**. Bekende niet-geautoriseerde forks worden vermeld in [TRADEMARK.md](TRADEMARK.md).
Als je imitatie of handelsmerk misbruik tegenkomt, [open dan een issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## Licentie
ZeroClaw is dubbel gelicentieerd voor maximale openheid en bijdrager bescherming:
| Licentie | Gebruiksscenario's |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Open-source, onderzoek, academisch, persoonlijk gebruik |
| [Apache 2.0](LICENSE-APACHE) | Patent bescherming, institutioneel, commerciële implementatie |
Je kunt een van beide licenties kiezen. **Bijdragers verlenen automatisch rechten onder beide** — zie [CLA.md](CLA.md) voor de volledige bijdrager overeenkomst.
### Handelsmerk
De naam **ZeroClaw** en het logo zijn geregistreerde handelsmerken van ZeroClaw Labs. Deze licentie verleent geen toestemming om ze te gebruiken om goedkeuring of affiniteit te impliceren. Zie [TRADEMARK.md](TRADEMARK.md) voor toegestane en verboden gebruiksmogelijkheden.
### Bijdrager Beschermingen
- **Je behoudt auteursrechten** op je bijdragen
- **Patent verlening** (Apache 2.0) beschermt je tegen patent claims door andere bijdragers
- Je bijdragen worden **permanent toegeschreven** in de commit geschiedenis en [NOTICE](NOTICE)
- Geen handelsmerk rechten worden overgedragen door bij te dragen
## Bijdragen
Zie [CONTRIBUTING.md](CONTRIBUTING.md) en [CLA.md](CLA.md). Implementeer een trait, dien een PR in:
- CI workflow gids: [docs/ci-map.md](docs/ci-map.md)
- Nieuwe `Provider``src/providers/`
- Nieuw `Channel``src/channels/`
- Nieuwe `Observer``src/observability/`
- Nieuwe `Tool``src/tools/`
- Nieuwe `Memory``src/memory/`
- Nieuwe `Tunnel``src/tunnel/`
- Nieuwe `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Nul overhead. Nul compromis. Implementeer overal. Wissel alles. 🦀
## Sterren Geschiedenis
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Sterren Geschiedenis Grafiek" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

914
README.pl.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Zero narzutu. Zero kompromisów. 100% Rust. 100% Agnostyczny.</strong><br>
⚡️ <strong>Działa na sprzęcie za $10 z <5MB RAM: To 99% mniej pamięci niż OpenClaw i 98% taniej niż Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Zbudowany przez studentów i członków społeczności Harvard, MIT i Sundai.Club.
</p>
<p align="center">
🌐 <strong>Języki:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#szybki-start">Szybki Start</a> |
<a href="bootstrap.sh">Konfiguracja Jednym Kliknięciem</a> |
<a href="docs/README.md">Centrum Dokumentacji</a> |
<a href="docs/SUMMARY.md">Spis Treści Dokumentacji</a>
</p>
<p align="center">
<strong>Szybki dostęp:</strong>
<a href="docs/reference/README.md">Referencje</a> ·
<a href="docs/operations/README.md">Operacje</a> ·
<a href="docs/troubleshooting.md">Rozwiązywanie Problemów</a> ·
<a href="docs/security/README.md">Bezpieczeństwo</a> ·
<a href="docs/hardware/README.md">Sprzęt</a> ·
<a href="docs/contributing/README.md">Wkład</a>
</p>
<p align="center">
<strong>Szybka, lekka i w pełni autonomiczna infrastruktura asystenta AI</strong><br />
Wdrażaj wszędzie. Zamieniaj cokolwiek.
</p>
<p align="center">
ZeroClaw to <strong>system operacyjny runtime</strong> dla workflow agentów — infrastruktura abstrahująca modele, narzędzia, pamięć i wykonanie do budowania agentów raz i uruchamiania ich wszędzie.
</p>
<p align="center"><code>Architektura oparta na traitach · bezpieczny runtime domyślnie · wymienny dostawca/kanał/narzędzie · wszystko jest podłączalne</code></p>
### 📢 Ogłoszenia
Użyj tej tabeli dla ważnych ogłoszeń (zmiany kompatybilności, powiadomienia bezpieczeństwa, okna serwisowe i blokady wersji).
| Data (UTC) | Poziom | Ogłoszenie | Działanie |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Krytyczny_ | **Nie jesteśmy powiązani** z `openagen/zeroclaw` lub `zeroclaw.org`. Domena `zeroclaw.org` obecnie wskazuje na fork `openagen/zeroclaw`, i ta domena/repozytorium podszywa się pod naszą oficjalną stronę/projekt. | Nie ufaj informacjom, plikom binarnym, zbiórkom funduszy lub ogłoszeniom z tych źródeł. Używaj tylko [tego repozytorium](https://github.com/zeroclaw-labs/zeroclaw) i naszych zweryfikowanych kont społecznościowych. |
| 2026-02-21 | _Ważne_ | Nasza oficjalna strona jest teraz online: [zeroclawlabs.ai](https://zeroclawlabs.ai). Dziękujemy za cierpliwość podczas oczekiwania. Nadal wykrywamy próby podszywania się: nie uczestnicz w żadnej działalności inwestycyjnej/finansowej w imieniu ZeroClaw jeśli nie jest opublikowana przez nasze oficjalne kanały. | Używaj [tego repozytorium](https://github.com/zeroclaw-labs/zeroclaw) jako jedynego źródła prawdy. Śledź [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (grupa)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), i [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) dla oficjalnych aktualizacji. |
| 2026-02-19 | _Ważne_ | Anthropic zaktualizował warunki używania uwierzytelniania i poświadczeń 2026-02-19. Uwierzytelnianie OAuth (Free, Pro, Max) jest wyłącznie dla Claude Code i Claude.ai; używanie tokenów OAuth Claude Free/Pro/Max w jakimkolwiek innym produkcie, narzędziu lub usłudze (w tym Agent SDK) nie jest dozwolone i może naruszać Warunki Użytkowania Konsumenta. | Prosimy tymczasowo unikać integracji OAuth Claude Code aby zapobiec potencjalnym stratom. Oryginalna klauzula: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Funkcje
- 🏎️ **Lekki Runtime Domyślnie:** Typowe workflow CLI i komendy statusu działają w przestrzeni pamięci kilku megabajtów w buildach produkcyjnych.
- 💰 **Ekonomiczne Wdrażanie:** Zaprojektowane dla tanich płytek i małych instancji chmurowych bez ciężkich zależności runtime.
- ⚡ **Szybkie Zimne Starty:** Runtime Rust pojedynczego binarium utrzymuje start komend i daemonów niemal natychmiastowy dla codziennych operacji.
- 🌍 **Przenośna Architektura:** Pojedynczy workflow binarium na ARM, x86 i RISC-V z wymiennym dostawcą/kanałem/narzędziem.
### Dlaczego zespoły wybierają ZeroClaw
- **Lekki domyślnie:** mały binarium Rust, szybki start, niski ślad pamięci.
- **Bezpieczny przez design:** parowanie, ścisłe sandboxowanie, jawne listy dozwolone, zakres workspace.
- **Całkowicie wymienny:** systemy rdzenne to trait-y (dostawcy, kanały, narzędzia, pamięć, tunele).
- **Brak blokady dostawcy:** wsparcie dostawcy kompatybilnego z OpenAI + podłączalne własne endpointy.
## Snapshot Benchmark (ZeroClaw vs OpenClaw, Reprodukowalne)
Szybki benchmark na maszynie lokalnej (macOS arm64, luty 2026) znormalizowany dla sprzętu edge 0.8 GHz.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Język** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Start (rdzeń 0.8 GHz)** | > 500s | > 30s | < 1s | **< 10ms** |
| **Rozmiar Binarny** | ~28 MB (dist) | N/A (Skrypty) | ~8 MB | **3.4 MB** |
| **Koszt** | Mac Mini $599 | Linux SBC ~$50 | Płytka Linux $10 | **Dowolny sprzęt $10** |
> Uwagi: Wyniki ZeroClaw są mierzone na buildach produkcyjnych używając `/usr/bin/time -l`. OpenClaw wymaga runtime Node.js (typowo ~390 MB dodatkowego narzutu pamięci), podczas gdy NanoBot wymaga runtime Python. PicoClaw i ZeroClaw to statyczne binaria. Powyższe liczby RAM to pamięć runtime; wymagania kompilacji w czasie build są wyższe.
<p align="center">
<img src="zero-claw.jpeg" alt="Porównanie ZeroClaw vs OpenClaw" width="800" />
</p>
### Reprodukowalny Pomiar Lokalny
Twierdzenia benchmark mogą się zmieniać wraz z ewolucją kodu i toolchainów, więc zawsze mierz swój aktualny build lokalnie:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Przykładowa próbka (macOS arm64, zmierzone 18 lutego 2026):
- Rozmiar binarium release: `8.8M`
- `zeroclaw --help`: czas rzeczywisty ok. `0.02s`, szczytowy ślad pamięci ~`3.9 MB`
- `zeroclaw status`: czas rzeczywisty ok. `0.01s`, szczytowy ślad pamięci ~`4.1 MB`
## Wymagania Wstępne
<details>
<summary><strong>Windows</strong></summary>
### Windows — Wymagane
1. **Visual Studio Build Tools** (dostarcza linker MSVC i Windows SDK):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Podczas instalacji (lub przez Visual Studio Installer), wybierz obciążenie **"Desktop development with C++"**.
2. **Toolchain Rust:**
```powershell
winget install Rustlang.Rustup
```
Po instalacji, otwórz nowy terminal i uruchom `rustup default stable` aby upewnić się, że stabilny toolchain jest aktywny.
3. **Zweryfikuj** że oba działają:
```powershell
rustc --version
cargo --version
```
### Windows — Opcjonalne
- **Docker Desktop** — wymagany tylko jeśli używasz [Docker sandboxed runtime](#aktualne-wsparcie-runtime) (`runtime.kind = "docker"`). Zainstaluj przez `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Wymagane
1. **Niezbędne narzędzia build:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Zainstaluj Xcode Command Line Tools: `xcode-select --install`
2. **Toolchain Rust:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Zobacz [rustup.rs](https://rustup.rs) dla szczegółów.
3. **Zweryfikuj:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — Opcjonalne
- **Docker** — wymagany tylko jeśli używasz [Docker sandboxed runtime](#aktualne-wsparcie-runtime) (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** zobacz [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** zobacz [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** zainstaluj Docker Desktop przez [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## Szybki Start
### Opcja 1: Automatyczna konfiguracja (zalecana)
Skrypt `bootstrap.sh` instaluje Rust, klonuje ZeroClaw, kompiluje go i konfiguruje twoje początkowe środowisko deweloperskie:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
To:
1. Zainstaluje Rust (jeśli nieobecny)
2. Sklonuje repozytorium ZeroClaw
3. Skompiluje ZeroClaw w trybie release
4. Zainstaluje `zeroclaw` w `~/.cargo/bin/`
5. Utworzy domyślną strukturę workspace w `~/.zeroclaw/workspace/`
6. Wygeneruje początkowy plik konfiguracyjny `~/.zeroclaw/workspace/config.toml`
Po bootstrap, przeładuj swój shell lub uruchom `source ~/.cargo/env` aby używać komendy `zeroclaw` globalnie.
### Opcja 2: Ręczna instalacja
<details>
<summary><strong>Kliknij aby zobaczyć kroki ręcznej instalacji</strong></summary>
```bash
# 1. Sklonuj repozytorium
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. Skompiluj w release
cargo build --release --locked
# 3. Zainstaluj binarium
cargo install --path . --locked
# 4. Zinicjuj workspace
zeroclaw init
# 5. Zweryfikuj instalację
zeroclaw --version
zeroclaw status
```
</details>
### Po Instalacji
Po zainstalowaniu (przez bootstrap lub ręcznie), powinieneś widzieć:
```
~/.zeroclaw/workspace/
├── config.toml # Główna konfiguracja
├── .pairing # Sekrety parowania (generowane przy pierwszym uruchomieniu)
├── logs/ # Logi daemon/agent
├── skills/ # Własne umiejętności
└── memory/ # Przechowywanie kontekstu konwersacji
```
**Następne kroki:**
1. Skonfiguruj swoich dostawców AI w `~/.zeroclaw/workspace/config.toml`
2. Sprawdź [referencje konfiguracji](docs/config-reference.md) dla opcji zaawansowanych
3. Uruchom agenta: `zeroclaw agent start`
4. Testuj przez preferowany kanał (zobacz [referencje kanałów](docs/channels-reference.md))
## Konfiguracja
Edytuj `~/.zeroclaw/workspace/config.toml` aby skonfigurować dostawców, kanały i zachowanie systemu.
### Szybka Referencja Konfiguracji
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # lub "sqlite" lub "none"
[runtime]
kind = "native" # lub "docker" (wymaga Docker)
```
**Pełne dokumenty referencyjne:**
- [Referencje Konfiguracji](docs/config-reference.md) — wszystkie ustawienia, walidacje, wartości domyślne
- [Referencje Dostawców](docs/providers-reference.md) — konfiguracje specyficzne dla dostawców AI
- [Referencje Kanałów](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord i więcej
- [Operacje](docs/operations-runbook.md) — monitoring produkcyjny, rotacja sekretów, skalowanie
### Aktualne Wsparcie Runtime
ZeroClaw wspiera dwa backendy wykonania kodu:
- **`native`** (domyślnie) — bezpośrednie wykonanie procesu, najszybsza ścieżka, idealna dla zaufanych środowisk
- **`docker`** — pełna izolacja kontenera, wzmocnione polityki bezpieczeństwa, wymaga Docker
Użyj `runtime.kind = "docker"` jeśli potrzebujesz ścisłego sandboxowania lub izolacji sieciowej. Zobacz [referencje konfiguracji](docs/config-reference.md#runtime) dla pełnych szczegółów.
## Komendy
```bash
# Zarządzanie workspace
zeroclaw init # Inicjuje nowy workspace
zeroclaw status # Pokazuje status daemon/agent
zeroclaw config validate # Weryfikuje składnię i wartości config.toml
# Zarządzanie daemon
zeroclaw daemon start # Uruchamia daemon w tle
zeroclaw daemon stop # Zatrzymuje działający daemon
zeroclaw daemon restart # Restartuje daemon (przeładowanie config)
zeroclaw daemon logs # Pokazuje logi daemon
# Zarządzanie agent
zeroclaw agent start # Uruchamia agenta (wymaga działającego daemon)
zeroclaw agent stop # Zatrzymuje agenta
zeroclaw agent restart # Restartuje agenta (przeładowanie config)
# Operacje parowania
zeroclaw pairing init # Generuje nowy sekret parowania
zeroclaw pairing rotate # Rotuje istniejący sekret parowania
# Tunneling (dla publicznej ekspozycji)
zeroclaw tunnel start # Uruchamia tunnel do lokalnego daemon
zeroclaw tunnel stop # Zatrzymuje aktywny tunnel
# Diagnostyka
zeroclaw doctor # Uruchamia sprawdzenia zdrowia systemu
zeroclaw version # Pokazuje wersję i informacje o build
```
Zobacz [Referencje Komend](docs/commands-reference.md) dla pełnych opcji i przykładów.
## Architektura
```
┌─────────────────────────────────────────────────────────────────┐
│ Kanały (trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Orchestrator Agent │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Routing │ │ Kontekst │ │ Wykonanie │ │
│ │ Wiadomość │ │ Pamięć │ │ Narzędzie │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Dostawcy │ │ Pamięć │ │ Narzędzia │
│ (trait) │ │ (trait) │ │ (trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Runtime (trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Kluczowe zasady:**
- Wszystko jest **trait** — dostawcy, kanały, narzędzia, pamięć, tunele
- Kanały wywołują orchestrator; orchestrator wywołuje dostawców + narzędzia
- System pamięci zarządza kontekstem konwersacji (markdown, SQLite, lub brak)
- Runtime abstrahuje wykonanie kodu (natywny lub Docker)
- Brak blokady dostawcy — zamieniaj Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama bez zmian kodu
Zobacz [dokumentację architektury](docs/architecture.svg) dla szczegółowych diagramów i szczegółów implementacji.
## Przykłady
### Bot Telegram
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Twój Telegram user ID
```
Uruchom daemon + agent, a następnie wyślij wiadomość do swojego bota na Telegram:
```
/start
Cześć! Czy mógłbyś pomóc mi napisać skrypt Python?
```
Bot odpowiada kodem wygenerowanym przez AI, wykonuje narzędzia jeśli wymagane i utrzymuje kontekst konwersacji.
### Matrix (szyfrowanie end-to-end)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Zaproś `@zeroclaw:matrix.org` do zaszyfrowanego pokoju, a bot odpowie z pełnym szyfrowaniem. Zobacz [Przewodnik Matrix E2EE](docs/matrix-e2ee-guide.md) dla konfiguracji weryfikacji urządzenia.
### Multi-Dostawca
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Failover przy błędzie dostawcy
```
Jeśli Anthropic zawiedzie lub ma rate-limit, orchestrator automatycznie przełącza się na OpenAI.
### Własna Pamięć
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # Automatyczne czyszczenie po 90 dniach
```
Lub użyj Markdown dla przechowywania czytelnego dla ludzi:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Zobacz [Referencje Konfiguracji](docs/config-reference.md#memory) dla wszystkich opcji pamięci.
## Wsparcie Dostawców
| Dostawca | Status | API Key | Przykładowe Modele |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Stabilny | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Stabilny | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Stabilny | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Stabilny | N/A (lokalny) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Stabilny | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Stabilny | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Planowany | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Planowany | `COHERE_API_KEY` | TBD |
### Własne Endpointy
ZeroClaw wspiera endpointy kompatybilne z OpenAI:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Przykład: użyj [LiteLLM](https://github.com/BerriAI/litellm) jako proxy aby uzyskać dostęp do każdego LLM przez interfejs OpenAI.
Zobacz [Referencje Dostawców](docs/providers-reference.md) dla pełnych szczegółów konfiguracji.
## Wsparcie Kanałów
| Kanał | Status | Uwierzytelnianie | Uwagi |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Stabilny | Bot Token | Pełne wsparcie w tym pliki, obrazy, przyciski inline |
| **Matrix** | ✅ Stabilny | Hasło lub Token | Wsparcie E2EE z weryfikacją urządzenia |
| **Slack** | 🚧 Planowany | OAuth lub Bot Token | Wymaga dostępu do workspace |
| **Discord** | 🚧 Planowany | Bot Token | Wymaga uprawnień guild |
| **WhatsApp** | 🚧 Planowany | Twilio lub oficjalne API | Wymaga konta business |
| **CLI** | ✅ Stabilny | Brak | Bezpośredni interfejs konwersacyjny |
| **Web** | 🚧 Planowany | API Key lub OAuth | Interfejs czatu oparty na przeglądarce |
Zobacz [Referencje Kanałów](docs/channels-reference.md) dla pełnych instrukcji konfiguracji.
## Wsparcie Narzędzi
ZeroClaw dostarcza wbudowane narzędzia do wykonania kodu, dostępu do systemu plików i pobierania web:
| Narzędzie | Opis | Wymagany Runtime |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Wykonuje komendy shell | Natywny lub Docker |
| **python** | Wykonuje skrypty Python | Python 3.8+ (natywny) lub Docker |
| **javascript** | Wykonuje kod Node.js | Node.js 18+ (natywny) lub Docker |
| **filesystem_read** | Odczytuje pliki | Natywny lub Docker |
| **filesystem_write** | Zapisuje pliki | Natywny lub Docker |
| **web_fetch** | Pobiera treści web | Natywny lub Docker |
### Bezpieczeństwo Wykonania
- **Natywny Runtime** — działa jako proces użytkownika daemon, pełny dostęp do systemu plików
- **Docker Runtime** — pełna izolacja kontenera, oddzielne systemy plików i sieci
Skonfiguruj politykę wykonania w `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Jawna lista dozwolona
```
Zobacz [Referencje Konfiguracji](docs/config-reference.md#runtime) dla pełnych opcji bezpieczeństwa.
## Wdrażanie
### Lokalne Wdrażanie (Rozwój)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Serwerowe Wdrażanie (Produkcja)
Użyj systemd do zarządzania daemon i agent jako usługi:
```bash
# Zainstaluj binarium
cargo install --path . --locked
# Skonfiguruj workspace
zeroclaw init
# Utwórz pliki usług systemd
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# Włącz i uruchom usługi
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# Zweryfikuj status
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Zobacz [Przewodnik Wdrażania Sieciowego](docs/network-deployment.md) dla pełnych instrukcji wdrażania produkcyjnego.
### Docker
```bash
# Zbuduj obraz
docker build -t zeroclaw:latest .
# Uruchom kontener
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Zobacz [`Dockerfile`](Dockerfile) dla szczegółów budowania i opcji konfiguracji.
### Sprzęt Edge
ZeroClaw jest zaprojektowany do działania na sprzęcie niskiego poboru mocy:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, pojedynczy rdzeń ARMv8, < $5 koszt sprzętu
- **Raspberry Pi 4/5** — 1 GB+ RAM, wielordzeniowy, idealny dla równoczesnych obciążeń
- **Orange Pi Zero 2** — ~512 MB RAM, czterordzeniowy ARMv8, ultra-niski koszt
- **SBC x86 (Intel N100)** — 4-8 GB RAM, szybkie buildy, natywne wsparcie Docker
Zobacz [Przewodnik Sprzętowy](docs/hardware/README.md) dla instrukcji konfiguracji specyficznych dla urządzenia.
## Tunneling (Publiczna Ekspozycja)
Exponuj swoj lokalny daemon ZeroClaw do sieci publicznej przez bezpieczne tunele:
```bash
zeroclaw tunnel start --provider cloudflare
```
Wspierani dostawcy tunnel:
- **Cloudflare Tunnel** — darmowy HTTPS, brak ekspozycji portów, wsparcie multi-domenowe
- **Ngrok** — szybka konfiguracja, własne domeny (plan płatny)
- **Tailscale** — prywatna sieć mesh, brak publicznego portu
Zobacz [Referencje Konfiguracji](docs/config-reference.md#tunnel) dla pełnych opcji konfiguracji.
## Bezpieczeństwo
ZeroClaw implementuje wiele warstw bezpieczeństwa:
### Parowanie
Daemon generuje sekret parowania przy pierwszym uruchomieniu przechowywany w `~/.zeroclaw/workspace/.pairing`. Klienci (agent, CLI) muszą przedstawić ten sekret aby się połączyć.
```bash
zeroclaw pairing rotate # Generuje nowy sekret i unieważnia stary
```
### Sandbox
- **Docker Runtime** — pełna izolacja kontenera z oddzielnymi systemami plików i sieciami
- **Natywny Runtime** — działa jako proces użytkownika, domyślnie ograniczony do workspace
### Listy Dozwolone
Kanały mogą ograniczać dostęp po ID użytkownika:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Jawna lista dozwolona
```
### Szyfrowanie
- **Matrix E2EE** — pełne szyfrowanie end-to-end z weryfikacją urządzenia
- **Transport TLS** — cały ruch API i tunnel używa HTTPS/TLS
Zobacz [Dokumentację Bezpieczeństwa](docs/security/README.md) dla pełnych polityk i praktyk.
## Obserwowalność
ZeroClaw loguje do `~/.zeroclaw/workspace/logs/` domyślnie. Logi są przechowywane po komponentach:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Logi daemon (startup, żądania API, błędy)
├── agent.log # Logi agent (routing wiadomości, wykonanie narzędzi)
├── telegram.log # Logi specyficzne dla kanału (jeśli włączone)
└── matrix.log # Logi specyficzne dla kanału (jeśli włączone)
```
### Konfiguracja Logowania
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # Dla rotacji opartej na rozmiarze
retention_days = 30 # Automatyczne czyszczenie po N dniach
```
Zobacz [Referencje Konfiguracji](docs/config-reference.md#logging) dla wszystkich opcji logowania.
### Metryki (Planowane)
Wsparcie metryk Prometheus dla monitoringu produkcyjnego wkrótce. Śledzenie w [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## Umiejętności
ZeroClaw wspiera własne umiejętności — wielokrotnego użytku moduły rozszerzające możliwości systemu.
### Definicja Umiejętności
Umiejętności są przechowywane w `~/.zeroclaw/workspace/skills/<skill-name>/` z tą strukturą:
```
skills/
└── my-skill/
├── skill.toml # Metadane umiejętności (nazwa, opis, zależności)
├── prompt.md # Prompt systemowy dla AI
└── tools/ # Opcjonalne własne narzędzia
└── my_tool.py
```
### Przykład Umiejętności
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Szuka w web i podsumowuje wyniki"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
Jesteś asystentem badawczym. Kiedy proszą o zbadanie czegoś:
1. Użyj web_fetch aby pobrać treść
2. Podsumuj wyniki w łatwym do czytania formacie
3. Zacytuj źródła z URL-ami
```
### Użycie Umiejętności
Umiejętności są automatycznie ładowane przy starcie agenta. Odwołuj się do nich po nazwie w konwersacjach:
```
Użytkownik: Użyj umiejętności web-research aby znaleźć najnowsze wiadomości AI
Bot: [ładuje umiejętność web-research, wykonuje web_fetch, podsumowuje wyniki]
```
Zobacz sekcję [Umiejętności](#umiejętności) dla pełnych instrukcji tworzenia umiejętności.
## Open Skills
ZeroClaw wspiera [Open Skills](https://github.com/openagents-com/open-skills) — modułowy i agnostyczny względem dostawcy system do rozszerzania możliwości agentów AI.
### Włącz Open Skills
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # opcjonalne
```
Możesz też nadpisać w runtime używając `ZEROCLAW_OPEN_SKILLS_ENABLED` i `ZEROCLAW_OPEN_SKILLS_DIR`.
## Rozwój
```bash
cargo build # Build deweloperski
cargo build --release # Build release (codegen-units=1, działa na wszystkich urządzeniach w tym Raspberry Pi)
cargo build --profile release-fast # Szybszy build (codegen-units=8, wymaga 16 GB+ RAM)
cargo test # Uruchom pełny zestaw testów
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Formatowanie
# Uruchom benchmark porównawczy SQLite vs Markdown
cargo test --test memory_comparison -- --nocapture
```
### Hook pre-push
Hook git uruchamia `cargo fmt --check`, `cargo clippy -- -D warnings`, i `cargo test` przed każdym push. Włącz go raz:
```bash
git config core.hooksPath .githooks
```
### Rozwiązywanie Problemów Build (błędy OpenSSL na Linux)
Jeśli napotkasz błąd build `openssl-sys`, zsynchronizuj zależności i przekompiluj z lockfile repozytorium:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw jest skonfigurowany do używania `rustls` dla zależności HTTP/TLS; `--locked` utrzymuje graf przechodni deterministyczny w czystych środowiskach.
Aby pominąć hook gdy potrzebujesz szybkiego push podczas rozwoju:
```bash
git push --no-verify
```
## Współpraca i Docs
Zacznij od centrum dokumentacji dla mapy opartej na zadaniach:
- Centrum Dokumentacji: [`docs/README.md`](docs/README.md)
- Zunifikowany Spis Treści Docs: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Referencje Komend: [`docs/commands-reference.md`](docs/commands-reference.md)
- Referencje Konfiguracji: [`docs/config-reference.md`](docs/config-reference.md)
- Referencje Dostawców: [`docs/providers-reference.md`](docs/providers-reference.md)
- Referencje Kanałów: [`docs/channels-reference.md`](docs/channels-reference.md)
- Runbook Operacji: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Rozwiązywanie Problemów: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Inwentarz/Klasyfikacja Docs: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- Snapshot Triages PR/Issue (stan na 18 lutego 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Główne referencje współpracy:
- Centrum Dokumentacji: [docs/README.md](docs/README.md)
- Szablon Dokumentacji: [docs/doc-template.md](docs/doc-template.md)
- Checklist Zmiany Dokumentacji: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Referencje Konfiguracji Kanałów: [docs/channels-reference.md](docs/channels-reference.md)
- Operacje Zaszyfrowanych Pokoi Matrix: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Przewodnik Wkładu: [CONTRIBUTING.md](CONTRIBUTING.md)
- Polityka Workflow PR: [docs/pr-workflow.md](docs/pr-workflow.md)
- Playbook Recenzenta (triage + głęboka recenzja): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Mapa Własności i Triages CI: [docs/ci-map.md](docs/ci-map.md)
- Polityka Ujawnienia Bezpieczeństwa: [SECURITY.md](SECURITY.md)
Dla wdrażania i operacji runtime:
- Przewodnik Wdrażania Sieciowego: [docs/network-deployment.md](docs/network-deployment.md)
- Playbook Proxy Agent: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## Wspieraj ZeroClaw
Jeśli ZeroClaw pomaga twojej pracy i chcesz wspierać ciągły rozwój, możesz przekazać darowiznę tutaj:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Kup Mi Kawę" /></a>
### 🙏 Specjalne Podziękowania
Serdeczne podziękowania dla społeczności i instytucji które inspirują i zasilają tę pracę open-source:
- **Harvard University** — za promowanie intelektualnej ciekawości i przesuwanie granic tego co możliwe.
- **MIT** — za obronę otwartej wiedzy, open source, i przekonania że technologia powinna być dostępna dla wszystkich.
- **Sundai Club** — za społeczność, energię, i nieustanną wolę budowania rzeczy które mają znaczenie.
- **Świat i Dalej** 🌍✨ — dla każdego kontrybutora, marzyciela, i budowniczego tam na zewnątrz który czyni open source siłą dla dobra. To dla ciebie.
Budujemy w open source ponieważ najlepsze pomysły przychodzą zewsząd. Jeśli to czytasz, jesteś tego częścią. Witamy. 🦀❤️
## ⚠️ Oficjalne Repozytorium i Ostrzeżenie o Podszywaniu Się
**To jest jedyne oficjalne repozytorium ZeroClaw:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Jakiekolwiek inne repozytorium, organizacja, domena lub pakiet twierdzący że jest "ZeroClaw" lub sugerujący powiązanie z ZeroClaw Labs jest **nieautoryzowany i niepowiązany z tym projektem**. Znane nieautoryzowane forki będą wymienione w [TRADEMARK.md](TRADEMARK.md).
Jeśli napotkasz podszywanie się lub nadużycie znaku towarowego, proszę [otwórz issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## Licencja
ZeroClaw jest podwójnie licencjonowany dla maksymalnej otwartości i ochrony kontrybutorów:
| Licencja | Przypadki Użycia |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Open-source, badania, akademicki, użycie osobiste |
| [Apache 2.0](LICENSE-APACHE) | Ochrona patentowa, instytucjonalne, wdrożenie komercyjne |
Możesz wybrać jedną z licencji. **Kontrybutorzy automatycznie przyznają prawa pod obiema** — zobacz [CLA.md](CLA.md) dla pełnej umowy kontrybutora.
### Znak Towarowy
Nazwa **ZeroClaw** i logo są zarejestrowanymi znakami towarowymi ZeroClaw Labs. Ta licencja nie przyznaje pozwolenia na ich używanie do sugerowania poparcia lub powiązania. Zobacz [TRADEMARK.md](TRADEMARK.md) dla dozwolonych i zabronionych użyć.
### Ochrony Kontrybutorów
- **Zachowuj prawa autorskie** swoich wkładów
- **Grant patentowy** (Apache 2.0) chroni cię przed roszczeniami patentowymi innych kontrybutorów
- Twoje wkłady są **trwale przypisane** w historii commitów i [NOTICE](NOTICE)
- Żadne prawa znaku towarowego nie są przenoszone przez kontrybucję
## Wkład
Zobacz [CONTRIBUTING.md](CONTRIBUTING.md) i [CLA.md](CLA.md). Zaimplementuj trait, prześlij PR:
- Przewodnik workflow CI: [docs/ci-map.md](docs/ci-map.md)
- Nowy `Provider``src/providers/`
- Nowy `Channel``src/channels/`
- Nowy `Observer``src/observability/`
- Nowe `Tool``src/tools/`
- Nowa `Memory``src/memory/`
- Nowy `Tunnel``src/tunnel/`
- Nowa `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Zero narzutu. Zero kompromisów. Wdrażaj wszędzie. Zamieniaj cokolwiek. 🦀
## Historia Gwiazdek
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Wykres Historii Gwiazdek" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

914
README.pt.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Zero sobrecarga. Zero compromisso. 100% Rust. 100% Agnóstico.</strong><br>
⚡️ <strong>Roda em hardware de $10 com <5MB de RAM: Isso é 99% menos memória que o OpenClaw e 98% mais barato que um Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Construído por estudantes e membros das comunidades Harvard, MIT e Sundai.Club.
</p>
<p align="center">
🌐 <strong>Idiomas:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#início-rápido">Início Rápido</a> |
<a href="bootstrap.sh">Configuração com Um Clique</a> |
<a href="docs/README.md">Hub de Documentação</a> |
<a href="docs/SUMMARY.md">Índice de Documentação</a>
</p>
<p align="center">
<strong>Acessos rápidos:</strong>
<a href="docs/reference/README.md">Referência</a> ·
<a href="docs/operations/README.md">Operações</a> ·
<a href="docs/troubleshooting.md">Solução de Problemas</a> ·
<a href="docs/security/README.md">Segurança</a> ·
<a href="docs/hardware/README.md">Hardware</a> ·
<a href="docs/contributing/README.md">Contribuir</a>
</p>
<p align="center">
<strong>Infraestrutura de assistente AI rápida, leve e totalmente autônoma</strong><br />
Implante em qualquer lugar. Troque qualquer coisa.
</p>
<p align="center">
ZeroClaw é o <strong>sistema operacional de runtime</strong> para fluxos de trabalho de agentes — uma infraestrutura que abstrai modelos, ferramentas, memória e execução para construir agentes uma vez e executá-los em qualquer lugar.
</p>
<p align="center"><code>Arquitetura baseada em traits · runtime seguro por padrão · provedor/canal/ferramenta intercambiáveis · tudo é conectável</code></p>
### 📢 Anúncios
Use esta tabela para avisos importantes (mudanças de compatibilidade, avisos de segurança, janelas de manutenção e bloqueios de versão).
| Data (UTC) | Nível | Aviso | Ação |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Crítico_ | **Não somos afiliados** ao `openagen/zeroclaw` ou `zeroclaw.org`. O domínio `zeroclaw.org` atualmente aponta para o fork `openagen/zeroclaw`, e este domínio/repositório está falsificando nosso site/projeto oficial. | Não confie em informações, binários, arrecadações ou anúncios dessas fontes. Use apenas [este repositório](https://github.com/zeroclaw-labs/zeroclaw) e nossas contas sociais verificadas. |
| 2026-02-21 | _Importante_ | Nosso site oficial agora está online: [zeroclawlabs.ai](https://zeroclawlabs.ai). Obrigado pela paciência durante a espera. Ainda detectamos tentativas de falsificação: não participe de nenhuma atividade de investimento/financiamento em nome do ZeroClaw se não for publicada através de nossos canais oficiais. | Use [este repositório](https://github.com/zeroclaw-labs/zeroclaw) como a única fonte de verdade. Siga [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (grupo)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), e [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) para atualizações oficiais. |
| 2026-02-19 | _Importante_ | A Anthropic atualizou os termos de uso de autenticação e credenciais em 2026-02-19. A autenticação OAuth (Free, Pro, Max) é exclusivamente para Claude Code e Claude.ai; o uso de tokens OAuth do Claude Free/Pro/Max em qualquer outro produto, ferramenta ou serviço (incluindo Agent SDK) não é permitido e pode violar os Termos de Uso do Consumidor. | Por favor, evite temporariamente as integrações OAuth do Claude Code para prevenir qualquer perda potencial. Cláusula original: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Funcionalidades
- 🏎️ **Runtime Leve por Padrão:** Fluxos de trabalho CLI comuns e comandos de status rodam dentro de um espaço de memória de poucos megabytes em builds de produção.
- 💰 **Implantação Econômica:** Projetado para placas de baixo custo e pequenas instâncias cloud sem dependências de runtime pesadas.
- ⚡ **Inícios a Frio Rápidos:** O runtime Rust de binário único mantém o início de comandos e daemons quase instantâneo para operações diárias.
- 🌍 **Arquitetura Portátil:** Um fluxo de trabalho de binário único em ARM, x86 e RISC-V com provedor/canal/ferramenta intercambiáveis.
### Por que as equipes escolhem o ZeroClaw
- **Leve por padrão:** binário Rust pequeno, início rápido, baixa pegada de memória.
- **Seguro por design:** emparelhamento, sandboxing estrito, listas de permissão explícitas, escopo de workspace.
- **Totalmente intercambiável:** os sistemas principais são traits (provedores, canais, ferramentas, memória, túneis).
- **Sem lock-in de provedor:** suporte de provedor compatível com OpenAI + endpoints personalizados conectáveis.
## Instantâneo de Benchmark (ZeroClaw vs OpenClaw, Reproduzível)
Benchmark rápido em máquina local (macOS arm64, fev. 2026) normalizado para hardware edge de 0.8 GHz.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Linguagem** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Início (núcleo 0.8 GHz)** | > 500s | > 30s | < 1s | **< 10ms** |
| **Tamanho Binário** | ~28 MB (dist) | N/A (Scripts) | ~8 MB | **3.4 MB** |
| **Custo** | Mac Mini $599 | Linux SBC ~$50 | Placa Linux $10 | **Qualquer hardware $10** |
> Notas: Os resultados do ZeroClaw são medidos em builds de produção usando `/usr/bin/time -l`. O OpenClaw requer o runtime Node.js (tipicamente ~390 MB de sobrecarga de memória adicional), enquanto o NanoBot requer o runtime Python. PicoClaw e ZeroClaw são binários estáticos. As cifras de RAM acima são memória de runtime; os requisitos de compilação em tempo de build são maiores.
<p align="center">
<img src="zero-claw.jpeg" alt="Comparação ZeroClaw vs OpenClaw" width="800" />
</p>
### Medição Local Reproduzível
As alegações de benchmark podem derivar à medida que o código e as toolchains evoluem, então sempre meça seu build atual localmente:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Exemplo de amostra (macOS arm64, medido em 18 de fevereiro de 2026):
- Tamanho do binário release: `8.8M`
- `zeroclaw --help`: tempo real aprox `0.02s`, pegada de memória máxima ~`3.9 MB`
- `zeroclaw status`: tempo real aprox `0.01s`, pegada de memória máxima ~`4.1 MB`
## Pré-requisitos
<details>
<summary><strong>Windows</strong></summary>
### Windows — Obrigatório
1. **Visual Studio Build Tools** (fornece o linker MSVC e o Windows SDK):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Durante a instalação (ou via Visual Studio Installer), selecione a carga de trabalho **"Desenvolvimento Desktop com C++"**.
2. **Toolchain Rust:**
```powershell
winget install Rustlang.Rustup
```
Após a instalação, abra um novo terminal e execute `rustup default stable` para garantir que a toolchain estável esteja ativa.
3. **Verifique** que ambos funcionam:
```powershell
rustc --version
cargo --version
```
### Windows — Opcional
- **Docker Desktop** — obrigatório apenas se você usar o [runtime Docker sandboxed](#suporte-de-runtime-atual) (`runtime.kind = "docker"`). Instale via `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Obrigatório
1. **Ferramentas de build essenciais:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Instale as Xcode Command Line Tools: `xcode-select --install`
2. **Toolchain Rust:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Veja [rustup.rs](https://rustup.rs) para detalhes.
3. **Verifique:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — Opcional
- **Docker** — obrigatório apenas se você usar o [runtime Docker sandboxed](#suporte-de-runtime-atual) (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** veja [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** veja [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** instale o Docker Desktop via [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## Início Rápido
### Opção 1: Configuração automatizada (recomendada)
O script `bootstrap.sh` instala Rust, clona ZeroClaw, compila, e configura seu ambiente de desenvolvimento inicial:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
Isso vai:
1. Instalar Rust (se não presente)
2. Clonar o repositório ZeroClaw
3. Compilar ZeroClaw em modo release
4. Instalar `zeroclaw` em `~/.cargo/bin/`
5. Criar a estrutura de workspace padrão em `~/.zeroclaw/workspace/`
6. Gerar um arquivo de configuração inicial `~/.zeroclaw/workspace/config.toml`
Após o bootstrap, recarregue seu shell ou execute `source ~/.cargo/env` para usar o comando `zeroclaw` globalmente.
### Opção 2: Instalação manual
<details>
<summary><strong>Clique para ver os passos de instalação manual</strong></summary>
```bash
# 1. Clone o repositório
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. Compile em release
cargo build --release --locked
# 3. Instale o binário
cargo install --path . --locked
# 4. Inicialize o workspace
zeroclaw init
# 5. Verifique a instalação
zeroclaw --version
zeroclaw status
```
</details>
### Após a instalação
Uma vez instalado (via bootstrap ou manualmente), você deve ver:
```
~/.zeroclaw/workspace/
├── config.toml # Configuração principal
├── .pairing # Segredos de emparelhamento (gerado no primeiro início)
├── logs/ # Logs de daemon/agent
├── skills/ # Habilidades personalizadas
└── memory/ # Armazenamento de contexto conversacional
```
**Próximos passos:**
1. Configure seus provedores de AI em `~/.zeroclaw/workspace/config.toml`
2. Confira a [referência de configuração](docs/config-reference.md) para opções avançadas
3. Inicie o agente: `zeroclaw agent start`
4. Teste via seu canal preferido (veja [referência de canais](docs/channels-reference.md))
## Configuração
Edite `~/.zeroclaw/workspace/config.toml` para configurar provedores, canais e comportamento do sistema.
### Referência de Configuração Rápida
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # ou "sqlite" ou "none"
[runtime]
kind = "native" # ou "docker" (requer Docker)
```
**Documentos de referência completos:**
- [Referência de Configuração](docs/config-reference.md) — todas as configurações, validações, valores padrão
- [Referência de Provedores](docs/providers-reference.md) — configurações específicas de provedores de AI
- [Referência de Canais](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord e mais
- [Operações](docs/operations-runbook.md) — monitoramento em produção, rotação de segredos, escalonamento
### Suporte de Runtime (atual)
ZeroClaw suporta dois backends de execução de código:
- **`native`** (padrão) — execução de processo direta, caminho mais rápido, ideal para ambientes confiáveis
- **`docker`** — isolamento completo de container, políticas de segurança reforçadas, requer Docker
Use `runtime.kind = "docker"` se você precisar de sandboxing estrito ou isolamento de rede. Veja [referência de configuração](docs/config-reference.md#runtime) para detalhes completos.
## Comandos
```bash
# Gestão de workspace
zeroclaw init # Inicializa um novo workspace
zeroclaw status # Mostra status de daemon/agent
zeroclaw config validate # Verifica sintaxe e valores do config.toml
# Gestão de daemon
zeroclaw daemon start # Inicia o daemon em segundo plano
zeroclaw daemon stop # Para o daemon em execução
zeroclaw daemon restart # Reinicia o daemon (recarga de config)
zeroclaw daemon logs # Mostra logs do daemon
# Gestão de agent
zeroclaw agent start # Inicia o agent (requer daemon rodando)
zeroclaw agent stop # Para o agent
zeroclaw agent restart # Reinicia o agent (recarga de config)
# Operações de emparelhamento
zeroclaw pairing init # Gera um novo segredo de emparelhamento
zeroclaw pairing rotate # Rotaciona o segredo de emparelhamento existente
# Tunneling (para exposição pública)
zeroclaw tunnel start # Inicia um tunnel para o daemon local
zeroclaw tunnel stop # Para o tunnel ativo
# Diagnóstico
zeroclaw doctor # Executa verificações de saúde do sistema
zeroclaw version # Mostra versão e informações de build
```
Veja [Referência de Comandos](docs/commands-reference.md) para opções e exemplos completos.
## Arquitetura
```
┌─────────────────────────────────────────────────────────────────┐
│ Canais (trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Orquestrador Agent │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Roteamento │ │ Contexto │ │ Execução │ │
│ │ Mensagem │ │ Memória │ │ Ferramenta │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Provedores │ │ Memória │ │ Ferramentas │
│ (trait) │ │ (trait) │ │ (trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Runtime (trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Princípios chave:**
- Tudo é um **trait** — provedores, canais, ferramentas, memória, túneis
- Canais chamam o orquestrador; o orquestrador chama provedores + ferramentas
- O sistema de memória gerencia contexto conversacional (markdown, SQLite, ou nenhum)
- O runtime abstrai a execução de código (nativo ou Docker)
- Sem lock-in de provedor — troque Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama sem mudanças de código
Veja [documentação de arquitetura](docs/architecture.svg) para diagramas detalhados e detalhes de implementação.
## Exemplos
### Bot do Telegram
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Seu ID de usuário do Telegram
```
Inicie o daemon + agent, então envie uma mensagem para seu bot no Telegram:
```
/start
Olá! Você poderia me ajudar a escrever um script Python?
```
O bot responde com código gerado por AI, executa ferramentas se solicitado, e mantém o contexto de conversação.
### Matrix (criptografia ponta a ponta)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Convide `@zeroclaw:matrix.org` para uma sala criptografada, e o bot responderá com criptografia completa. Veja [Guia Matrix E2EE](docs/matrix-e2ee-guide.md) para configuração de verificação de dispositivo.
### Multi-Provedor
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Failover em erro de provedor
```
Se Anthropic falhar ou tiver rate-limit, o orquestrador faz failover automaticamente para OpenAI.
### Memória Personalizada
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # Purga automática após 90 dias
```
Ou use Markdown para armazenamento legível por humanos:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Veja [Referência de Configuração](docs/config-reference.md#memory) para todas as opções de memória.
## Suporte de Provedor
| Provedor | Status | API Key | Modelos de Exemplo |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Estável | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Estável | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Estável | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Estável | N/A (local) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Estável | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Estável | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Planejado | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Planejado | `COHERE_API_KEY` | TBD |
### Endpoints Personalizados
ZeroClaw suporta endpoints compatíveis com OpenAI:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Exemplo: use [LiteLLM](https://github.com/BerriAI/litellm) como proxy para acessar qualquer LLM via interface OpenAI.
Veja [Referência de Provedores](docs/providers-reference.md) para detalhes de configuração completos.
## Suporte de Canal
| Canal | Status | Autenticação | Notas |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Estável | Bot Token | Suporte completo incluindo arquivos, imagens, botões inline |
| **Matrix** | ✅ Estável | Senha ou Token | Suporte E2EE com verificação de dispositivo |
| **Slack** | 🚧 Planejado | OAuth ou Bot Token | Requer acesso ao workspace |
| **Discord** | 🚧 Planejado | Bot Token | Requer permissões de guild |
| **WhatsApp** | 🚧 Planejado | Twilio ou API oficial | Requer conta business |
| **CLI** | ✅ Estável | Nenhum | Interface conversacional direta |
| **Web** | 🚧 Planejado | API Key ou OAuth | Interface de chat baseada em navegador |
Veja [Referência de Canais](docs/channels-reference.md) para instruções de configuração completas.
## Suporte de Ferramentas
ZeroClaw fornece ferramentas integradas para execução de código, acesso ao sistema de arquivos e recuperação web:
| Ferramenta | Descrição | Runtime Requerido |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Executa comandos shell | Nativo ou Docker |
| **python** | Executa scripts Python | Python 3.8+ (nativo) ou Docker |
| **javascript** | Executa código Node.js | Node.js 18+ (nativo) ou Docker |
| **filesystem_read** | Lê arquivos | Nativo ou Docker |
| **filesystem_write** | Escreve arquivos | Nativo ou Docker |
| **web_fetch** | Obtém conteúdo web | Nativo ou Docker |
### Segurança de Execução
- **Runtime Nativo** — roda como processo de usuário do daemon, acesso completo ao sistema de arquivos
- **Runtime Docker** — isolamento completo de container, sistemas de arquivos e redes separados
Configure a política de execução em `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Lista de permissão explícita
```
Veja [Referência de Configuração](docs/config-reference.md#runtime) para opções de segurança completas.
## Implantação
### Implantação Local (Desenvolvimento)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Implantação em Servidor (Produção)
Use systemd para gerenciar o daemon e agent como serviços:
```bash
# Instale o binário
cargo install --path . --locked
# Configure o workspace
zeroclaw init
# Crie arquivos de serviço systemd
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# Habilite e inicie os serviços
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# Verifique o status
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Veja [Guia de Implantação de Rede](docs/network-deployment.md) para instruções completas de implantação em produção.
### Docker
```bash
# Compile a imagem
docker build -t zeroclaw:latest .
# Execute o container
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Veja [`Dockerfile`](Dockerfile) para detalhes de build e opções de configuração.
### Hardware Edge
ZeroClaw é projetado para rodar em hardware de baixo consumo:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, núcleo ARMv8 único, < $5 custo de hardware
- **Raspberry Pi 4/5** — 1 GB+ RAM, multi-núcleo, ideal para workloads concorrentes
- **Orange Pi Zero 2** — ~512 MB RAM, quad-core ARMv8, custo ultra-baixo
- **SBCs x86 (Intel N100)** — 4-8 GB RAM, builds rápidos, suporte Docker nativo
Veja [Guia de Hardware](docs/hardware/README.md) para instruções de configuração específicas por dispositivo.
## Tunneling (Exposição Pública)
Exponha seu daemon ZeroClaw local à rede pública via túneis seguros:
```bash
zeroclaw tunnel start --provider cloudflare
```
Provedores de tunnel suportados:
- **Cloudflare Tunnel** — HTTPS grátis, sem exposição de portas, suporte multi-domínio
- **Ngrok** — configuração rápida, domínios personalizados (plano pago)
- **Tailscale** — rede mesh privada, sem porta pública
Veja [Referência de Configuração](docs/config-reference.md#tunnel) para opções de configuração completas.
## Segurança
ZeroClaw implementa múltiplas camadas de segurança:
### Emparelhamento
O daemon gera um segredo de emparelhamento no primeiro início armazenado em `~/.zeroclaw/workspace/.pairing`. Clientes (agent, CLI) devem apresentar este segredo para conectar.
```bash
zeroclaw pairing rotate # Gera um novo segredo e invalida o anterior
```
### Sandboxing
- **Runtime Docker** — isolamento completo de container com sistemas de arquivos e redes separados
- **Runtime Nativo** — roda como processo de usuário, com escopo de workspace por padrão
### Listas de Permissão
Canais podem restringir acesso por ID de usuário:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Lista de permissão explícita
```
### Criptografia
- **Matrix E2EE** — criptografia ponta a ponta completa com verificação de dispositivo
- **Transporte TLS** — todo o tráfego de API e tunnel usa HTTPS/TLS
Veja [Documentação de Segurança](docs/security/README.md) para políticas e práticas completas.
## Observabilidade
ZeroClaw registra logs em `~/.zeroclaw/workspace/logs/` por padrão. Os logs são armazenados por componente:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Logs do daemon (início, requisições API, erros)
├── agent.log # Logs do agent (roteamento de mensagens, execução de ferramentas)
├── telegram.log # Logs específicos do canal (se habilitado)
└── matrix.log # Logs específicos do canal (se habilitado)
```
### Configuração de Logging
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # Para rotação baseada em tamanho
retention_days = 30 # Purga automática após N dias
```
Veja [Referência de Configuração](docs/config-reference.md#logging) para todas as opções de logging.
### Métricas (Planejado)
Suporte a métricas Prometheus para monitoramento em produção em breve. Rastreamento em [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## Habilidades (Skills)
ZeroClaw suporta habilidades personalizadas — módulos reutilizáveis que estendem as capacidades do sistema.
### Definição de Habilidade
Habilidades são armazenadas em `~/.zeroclaw/workspace/skills/<skill-name>/` com esta estrutura:
```
skills/
└── my-skill/
├── skill.toml # Metadados da habilidade (nome, descrição, dependências)
├── prompt.md # Prompt de sistema para a AI
└── tools/ # Ferramentas personalizadas opcionais
└── my_tool.py
```
### Exemplo de Habilidade
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Pesquisa na web e resume resultados"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
Você é um assistente de pesquisa. Quando pedirem para pesquisar algo:
1. Use web_fetch para obter o conteúdo
2. Resuma os resultados em um formato fácil de ler
3. Cite as fontes com URLs
```
### Uso de Habilidades
Habilidades são carregadas automaticamente no início do agent. Referencie-as por nome em conversas:
```
Usuário: Use a habilidade web-research para encontrar as últimas notícias de AI
Bot: [carrega a habilidade web-research, executa web_fetch, resume resultados]
```
Veja seção [Habilidades (Skills)](#habilidades-skills) para instruções completas de criação de habilidades.
## Open Skills
ZeroClaw suporta [Open Skills](https://github.com/openagents-com/open-skills) — um sistema modular e agnóstico de provedores para estender capacidades de agentes AI.
### Habilitar Open Skills
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # opcional
```
Você também pode sobrescrever em runtime com `ZEROCLAW_OPEN_SKILLS_ENABLED` e `ZEROCLAW_OPEN_SKILLS_DIR`.
## Desenvolvimento
```bash
cargo build # Build de desenvolvimento
cargo build --release # Build release (codegen-units=1, funciona em todos os dispositivos incluindo Raspberry Pi)
cargo build --profile release-fast # Build mais rápido (codegen-units=8, requer 16 GB+ RAM)
cargo test # Executa o suite de testes completo
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Formato
# Executa o benchmark de comparação SQLite vs Markdown
cargo test --test memory_comparison -- --nocapture
```
### Hook pre-push
Um hook de git executa `cargo fmt --check`, `cargo clippy -- -D warnings`, e `cargo test` antes de cada push. Ative-o uma vez:
```bash
git config core.hooksPath .githooks
```
### Solução de Problemas de Build (erros OpenSSL no Linux)
Se você encontrar um erro de build `openssl-sys`, sincronize dependências e recompile com o lockfile do repositório:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw está configurado para usar `rustls` para dependências HTTP/TLS; `--locked` mantém o grafo transitivo determinístico em ambientes limpios.
Para pular o hook quando precisar de um push rápido durante desenvolvimento:
```bash
git push --no-verify
```
## Colaboração e Docs
Comece com o hub de documentação para um mapa baseado em tarefas:
- Hub de Documentação: [`docs/README.md`](docs/README.md)
- Índice Unificado de Docs: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Referência de Comandos: [`docs/commands-reference.md`](docs/commands-reference.md)
- Referência de Configuração: [`docs/config-reference.md`](docs/config-reference.md)
- Referência de Provedores: [`docs/providers-reference.md`](docs/providers-reference.md)
- Referência de Canais: [`docs/channels-reference.md`](docs/channels-reference.md)
- Runbook de Operações: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Solução de Problemas: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Inventário/Classificação de Docs: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- Snapshot de Triage de PR/Issue (em 18 de fev. de 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Referências principais de colaboração:
- Hub de Documentação: [docs/README.md](docs/README.md)
- Modelo de Documentação: [docs/doc-template.md](docs/doc-template.md)
- Checklist de Mudança de Documentação: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Referência de Configuração de Canais: [docs/channels-reference.md](docs/channels-reference.md)
- Operações de Salas Criptografadas Matrix: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Guia de Contribuição: [CONTRIBUTING.md](CONTRIBUTING.md)
- Política de Fluxo de Trabalho PR: [docs/pr-workflow.md](docs/pr-workflow.md)
- Playbook do Revisor (triage + revisão profunda): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Mapa de Propriedade e Triage CI: [docs/ci-map.md](docs/ci-map.md)
- Política de Divulgação de Segurança: [SECURITY.md](SECURITY.md)
Para implantação e operações de runtime:
- Guia de Implantação de Rede: [docs/network-deployment.md](docs/network-deployment.md)
- Playbook de Agent Proxy: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## Apoiar o ZeroClaw
Se ZeroClaw ajuda seu trabalho e você deseja apoiar o desenvolvimento contínuo, você pode doar aqui:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Me Pague um Café" /></a>
### 🙏 Agradecimentos Especiais
Um sincero agradecimento às comunidades e instituições que inspiram e alimentam este trabalho de código aberto:
- **Harvard University** — por fomentar a curiosidade intelectual e empurrar os limites do possível.
- **MIT** — por defender o conhecimento aberto, o código aberto, e a convicção de que a tecnologia deveria ser acessível a todos.
- **Sundai Club** — pela comunidade, energia, e vontade incessante de construir coisas que importam.
- **O Mundo e Além** 🌍✨ — a cada contribuidor, sonhador, e construtor lá fora que faz do código aberto uma força para o bem. Isso é por você.
Construímos em código aberto porque as melhores ideias vêm de todo lugar. Se você está lendo isso, você é parte disso. Bem-vindo. 🦀❤️
## ⚠️ Repositório Oficial e Aviso de Falsificação
**Este é o único repositório oficial do ZeroClaw:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Qualquer outro repositório, organização, domínio ou pacote que afirme ser "ZeroClaw" ou que implique afiliação com ZeroClaw Labs é **não autorizado e não é afiliado a este projeto**. Forks não autorizados conhecidos serão listados em [TRADEMARK.md](TRADEMARK.md).
Se você encontrar falsificação ou uso indevido de marca, por favor [abra uma issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## Licença
ZeroClaw tem licença dupla para máxima abertura e proteção de contribuidores:
| Licença | Casos de Uso |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Código aberto, pesquisa, acadêmico, uso pessoal |
| [Apache 2.0](LICENSE-APACHE) | Proteção de patentes, institucional, implantação comercial |
Você pode escolher qualquer uma das licenças. **Os contribuidores concedem automaticamente direitos sob ambas** — veja [CLA.md](CLA.md) para o acordo de contribuidor completo.
### Marca
O nome **ZeroClaw** e o logo são marcas registradas da ZeroClaw Labs. Esta licença não concede permissão para usá-los para implicar aprovação ou afiliação. Veja [TRADEMARK.md](TRADEMARK.md) para usos permitidos e proibidos.
### Proteções do Contribuidor
- **Você mantém os direitos autorais** de suas contribuições
- **Concessão de patentes** (Apache 2.0) protege você contra reivindicações de patentes por outros contribuidores
- Suas contribuições são **atribuídas permanentemente** no histórico de commits e [NOTICE](NOTICE)
- Nenhum direito de marca é transferido ao contribuir
## Contribuir
Veja [CONTRIBUTING.md](CONTRIBUTING.md) e [CLA.md](CLA.md). Implemente um trait, envie uma PR:
- Guia de fluxo de trabalho CI: [docs/ci-map.md](docs/ci-map.md)
- Novo `Provider``src/providers/`
- Novo `Channel``src/channels/`
- Novo `Observer``src/observability/`
- Novo `Tool``src/tools/`
- Nova `Memory``src/memory/`
- Novo `Tunnel``src/tunnel/`
- Nova `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Zero sobrecarga. Zero compromisso. Implante em qualquer lugar. Troque qualquer coisa. 🦀
## Histórico de Estrelas
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Gráfico de Histórico de Estrelas" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

179
README.ro.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Zero overhead. Zero compromisuri. 100% Rust. 100% Agnostic.</strong><br>
⚡️ <strong>Rulează pe hardware de $10 cu <5MB RAM: Asta e cu 99% mai puțină memorie decât OpenClaw și cu 98% mai ieftin decât un Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Limbi:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## Ce este ZeroClaw?
ZeroClaw este o infrastructură de asistent AI ușoară, mutabilă și extensibilă construită în Rust. Conectează diverși furnizori de LLM (Anthropic, OpenAI, Google, Ollama, etc.) printr-o interfață unificată și suportă multiple canale (Telegram, Matrix, CLI, etc.).
### Caracteristici Principale
- **🦀 Scris în Rust**: Performanță ridicată, siguranță a memoriei și abstracțiuni fără costuri
- **🔌 Agnostic față de furnizori**: Suportă OpenAI, Anthropic, Google Gemini, Ollama și alții
- **📱 Multi-canal**: Telegram, Matrix (cu E2EE), CLI și altele
- **🧠 Memorie modulară**: Backend-uri SQLite și Markdown
- **🛠️ Instrumente extensibile**: Adaugă instrumente personalizate cu ușurință
- **🔒 Securitate pe primul loc**: Reverse proxy, design axat pe confidențialitate
---
## Start Rapid
### Cerințe
- Rust 1.70+
- O cheie API de furnizor LLM (Anthropic, OpenAI, etc.)
### Instalare
```bash
# Clonează repository-ul
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Construiește
cargo build --release
# Rulează
cargo run --release
```
### Cu Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Configurare
ZeroClaw folosește un fișier de configurare YAML. În mod implicit, caută `config.yaml`.
```yaml
# Furnizor implicit
provider: anthropic
# Configurare furnizori
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Configurare memorie
memory:
backend: sqlite
path: data/memory.db
# Configurare canale
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Documentație
Pentru documentație detaliată, vezi:
- [Hub Documentație](docs/README.md)
- [Referință Comenzi](docs/commands-reference.md)
- [Referință Furnizori](docs/providers-reference.md)
- [Referință Canale](docs/channels-reference.md)
- [Referință Configurare](docs/config-reference.md)
---
## Contribuții
Contribuțiile sunt binevenite! Te rugăm să citești [Ghidul de Contribuții](CONTRIBUTING.md).
---
## Licență
Acest proiect este licențiat dual:
- MIT License
- Apache License, versiunea 2.0
Vezi [LICENSE-APACHE](LICENSE-APACHE) și [LICENSE-MIT](LICENSE-MIT) pentru detalii.
---
## Comunitate
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Sponsori
Dacă ZeroClaw îți este util, te rugăm să iei în considerare să ne cumperi o cafea:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

View File

@ -1,5 +1,5 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
<img src="docs/assets/zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀(Русский)</h1>
@ -21,12 +21,43 @@
</p>
<p align="center">
🌐 Языки: <a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.ru.md">Русский</a> · <a href="README.fr.md">Français</a> · <a href="README.vi.md">Tiếng Việt</a>
🌐 Языки:
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="bootstrap.sh">Установка в 1 клик</a> |
<a href="docs/getting-started/README.md">Быстрый старт</a> |
<a href="install.sh">Установка в 1 клик</a> |
<a href="docs/setup-guides/README.md">Быстрый старт</a> |
<a href="docs/README.ru.md">Хаб документации</a> |
<a href="docs/SUMMARY.md">TOC docs</a>
</p>
@ -34,8 +65,8 @@
<p align="center">
<strong>Быстрые маршруты:</strong>
<a href="docs/reference/README.md">Справочники</a> ·
<a href="docs/operations/README.md">Операции</a> ·
<a href="docs/troubleshooting.md">Диагностика</a> ·
<a href="docs/ops/README.md">Операции</a> ·
<a href="docs/ops/troubleshooting.md">Диагностика</a> ·
<a href="docs/security/README.md">Безопасность</a> ·
<a href="docs/hardware/README.md">Аппаратная часть</a> ·
<a href="docs/contributing/README.md">Вклад и CI</a>
@ -87,7 +118,7 @@ ZeroClaw — это производительная и расширяемая
> Примечание: результаты ZeroClaw получены на release-сборке с помощью `/usr/bin/time -l`. OpenClaw требует Node.js runtime; только этот runtime обычно добавляет около 390MB дополнительного потребления памяти. NanoBot требует Python runtime. PicoClaw и ZeroClaw — статические бинарники.
<p align="center">
<img src="zero-claw.jpeg" alt="Сравнение ZeroClaw и OpenClaw" width="800" />
<img src="docs/assets/zeroclaw-comparison.jpeg" alt="Сравнение ZeroClaw и OpenClaw" width="800" />
</p>
### Локально воспроизводимое измерение
@ -113,12 +144,12 @@ ls -lh target/release/zeroclaw
```bash
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
./bootstrap.sh
./install.sh
```
Для полной инициализации окружения: `./bootstrap.sh --install-system-deps --install-rust` (для системных пакетов может потребоваться `sudo`).
Для полной инициализации окружения: `./install.sh --install-system-deps --install-rust` (для системных пакетов может потребоваться `sudo`).
Подробности: [`docs/one-click-bootstrap.md`](docs/one-click-bootstrap.md).
Подробности: [`docs/setup-guides/one-click-bootstrap.md`](docs/setup-guides/one-click-bootstrap.md).
## Быстрый старт
@ -195,7 +226,7 @@ zeroclaw agent --provider anthropic -m "hello"
Каждая подсистема — это **Trait**: меняйте реализации через конфигурацию, без изменения кода.
<p align="center">
<img src="docs/architecture.svg" alt="Архитектура ZeroClaw" width="900" />
<img src="docs/assets/architecture.svg" alt="Архитектура ZeroClaw" width="900" />
</p>
| Подсистема | Trait | Встроенные реализации | Расширение |
@ -279,20 +310,20 @@ allow_public_bind = false
- Хаб документации (English): [`docs/README.md`](docs/README.md)
- Единый TOC docs: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Хаб документации (Русский): [`docs/README.ru.md`](docs/README.ru.md)
- Справочник команд: [`docs/commands-reference.md`](docs/commands-reference.md)
- Справочник конфигурации: [`docs/config-reference.md`](docs/config-reference.md)
- Справочник providers: [`docs/providers-reference.md`](docs/providers-reference.md)
- Справочник channels: [`docs/channels-reference.md`](docs/channels-reference.md)
- Операционный runbook: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Устранение неполадок: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Инвентарь и классификация docs: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- Снимок triage проекта: [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
- Справочник команд: [`docs/reference/cli/commands-reference.md`](docs/reference/cli/commands-reference.md)
- Справочник конфигурации: [`docs/reference/api/config-reference.md`](docs/reference/api/config-reference.md)
- Справочник providers: [`docs/reference/api/providers-reference.md`](docs/reference/api/providers-reference.md)
- Справочник channels: [`docs/reference/api/channels-reference.md`](docs/reference/api/channels-reference.md)
- Операционный runbook: [`docs/ops/operations-runbook.md`](docs/ops/operations-runbook.md)
- Устранение неполадок: [`docs/ops/troubleshooting.md`](docs/ops/troubleshooting.md)
- Инвентарь и классификация docs: [`docs/maintainers/docs-inventory.md`](docs/maintainers/docs-inventory.md)
- Снимок triage проекта: [`docs/maintainers/project-triage-snapshot-2026-02-18.md`](docs/maintainers/project-triage-snapshot-2026-02-18.md)
## Вклад и лицензия
- Contribution guide: [`CONTRIBUTING.md`](CONTRIBUTING.md)
- PR workflow: [`docs/pr-workflow.md`](docs/pr-workflow.md)
- Reviewer playbook: [`docs/reviewer-playbook.md`](docs/reviewer-playbook.md)
- PR workflow: [`docs/contributing/pr-workflow.md`](docs/contributing/pr-workflow.md)
- Reviewer playbook: [`docs/contributing/reviewer-playbook.md`](docs/contributing/reviewer-playbook.md)
- License: MIT or Apache 2.0 ([`LICENSE-MIT`](LICENSE-MIT), [`LICENSE-APACHE`](LICENSE-APACHE), [`NOTICE`](NOTICE))
---

179
README.sv.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Noll overhead. Noll kompromiss. 100% Rust. 100% Agnostisk.</strong><br>
⚡️ <strong>Kör på $10 hårdvara med <5MB RAM: Det är 99% mindre minne än OpenClaw och 98% billigare än en Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Språk:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## Vad är ZeroClaw?
ZeroClaw är en lättvikts, föränderlig och utökningsbar AI-assistent-infrastruktur byggd i Rust. Den ansluter olika LLM-leverantörer (Anthropic, OpenAI, Google, Ollama, etc.) via ett enhetligt gränssnitt och stöder flera kanaler (Telegram, Matrix, CLI, etc.).
### Huvudfunktioner
- **🦀 Skrivet i Rust**: Hög prestanda, minnessäkerhet och nollkostnadsabstraktioner
- **🔌 Leverantörsagnostisk**: Stöder OpenAI, Anthropic, Google Gemini, Ollama och andra
- **📱 Multi-kanal**: Telegram, Matrix (med E2EE), CLI och andra
- **🧠 Pluggbart minne**: SQLite och Markdown-backends
- **🛠️ Utökningsbara verktyg**: Lägg enkelt till anpassade verktyg
- **🔒 Säkerhet först**: Omvänd proxy, integritetsförst-design
---
## Snabbstart
### Krav
- Rust 1.70+
- En LLM-leverantörs API-nyckel (Anthropic, OpenAI, etc.)
### Installation
```bash
# Klona repositoryt
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Bygg
cargo build --release
# Kör
cargo run --release
```
### Med Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Konfiguration
ZeroClaw använder en YAML-konfigurationsfil. Som standard letar den efter `config.yaml`.
```yaml
# Standardleverantör
provider: anthropic
# Leverantörskonfiguration
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Minneskonfiguration
memory:
backend: sqlite
path: data/memory.db
# Kanalkonfiguration
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Dokumentation
För detaljerad dokumentation, se:
- [Dokumentationshubb](docs/README.md)
- [Kommandoreferens](docs/commands-reference.md)
- [Leverantörsreferens](docs/providers-reference.md)
- [Kanalreferens](docs/channels-reference.md)
- [Konfigurationsreferens](docs/config-reference.md)
---
## Bidrag
Bidrag är välkomna! Vänligen läs [Bidragsguiden](CONTRIBUTING.md).
---
## Licens
Detta projekt är dubbellicensierat:
- MIT License
- Apache License, version 2.0
Se [LICENSE-APACHE](LICENSE-APACHE) och [LICENSE-MIT](LICENSE-MIT) för detaljer.
---
## Community
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Sponsorer
Om ZeroClaw är användbart för dig, vänligen överväg att köpa en kaffe till oss:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

179
README.th.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>โอเวอร์เฮดเป็นศูนย์ ไม่มีการประนีประนอม 100% Rust 100% Agnostic</strong><br>
⚡️ <strong>ทำงานบนฮาร์ดแวร์ $10 ด้วย RAM <5MB: ใช้หน่วยความจำน้อยกว่า OpenClaw 99% และถูกกว่า Mac mini 98%!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>ภาษา:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## ZeroClaw คืออะไร?
ZeroClaw เป็นโครงสร้างพื้นฐานผู้ช่วย AI ที่มีน้ำหนักเบา ปรับเปลี่ยนได้ และขยายได้ สร้างด้วย Rust มันเชื่อมต่อผู้ให้บริการ LLM ต่างๆ (Anthropic, OpenAI, Google, Ollama ฯลฯ) ผ่านอินเทอร์เฟซแบบรวมและรองรับหลายช่องทาง (Telegram, Matrix, CLI ฯลฯ)
### คุณสมบัติหลัก
- **🦀 เขียนด้วย Rust**: ประสิทธิภาพสูง ความปลอดภัยของหน่วยความจำ และ abstraction แบบไม่มีค่าใช้จ่าย
- **🔌 Agnostic ต่อผู้ให้บริการ**: รองรับ OpenAI, Anthropic, Google Gemini, Ollama และอื่นๆ
- **📱 หลายช่องทาง**: Telegram, Matrix (พร้อม E2EE), CLI และอื่นๆ
- **🧠 หน่วยความจำแบบเสียบได้**: Backend แบบ SQLite และ Markdown
- **🛠️ เครื่องมือที่ขยายได้**: เพิ่มเครื่องมือที่กำหนดเองได้ง่าย
- **🔒 ความปลอดภัยเป็นอันดับหนึ่ง**: Reverse proxy, การออกแบบที่ให้ความสำคัญกับความเป็นส่วนตัว
---
## เริ่มต้นอย่างรวดเร็ว
### ข้อกำหนด
- Rust 1.70+
- API key ของผู้ให้บริการ LLM (Anthropic, OpenAI ฯลฯ)
### การติดตั้ง
```bash
# Clone repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Build
cargo build --release
# Run
cargo run --release
```
### ด้วย Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## การกำหนดค่า
ZeroClaw ใช้ไฟล์กำหนดค่า YAML โดยค่าเริ่มต้นจะค้นหา `config.yaml`
```yaml
# ผู้ให้บริการเริ่มต้น
provider: anthropic
# การกำหนดค่าผู้ให้บริการ
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# การกำหนดค่าหน่วยความจำ
memory:
backend: sqlite
path: data/memory.db
# การกำหนดค่าช่องทาง
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## เอกสาร
สำหรับเอกสารโดยละเอียด ดูที่:
- [ศูนย์เอกสาร](docs/README.md)
- [ข้อมูลอ้างอิงคำสั่ง](docs/commands-reference.md)
- [ข้อมูลอ้างอิงผู้ให้บริการ](docs/providers-reference.md)
- [ข้อมูลอ้างอิงช่องทาง](docs/channels-reference.md)
- [ข้อมูลอ้างอิงการกำหนดค่า](docs/config-reference.md)
---
## การมีส่วนร่วม
ยินดีต้อนรับการมีส่วนร่วม! โปรดอ่าน [คู่มือการมีส่วนร่วม](CONTRIBUTING.md)
---
## สัญญาอนุญาต
โปรเจกต์นี้มีสัญญาอนุญาตคู่:
- MIT License
- Apache License, เวอร์ชัน 2.0
ดู [LICENSE-APACHE](LICENSE-APACHE) และ [LICENSE-MIT](LICENSE-MIT) สำหรับรายละเอียด
---
## ชุมชน
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## ผู้สนับสนุน
หาก ZeroClaw มีประโยชน์สำหรับคุณ โปรดพิจารณาซื้อกาแฟให้เรา:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

914
README.tl.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Zero overhead. Zero compromise. 100% Rust. 100% Agnostic.</strong><br>
⚡️ <strong>Tumatakbo sa $10 hardware na may <5MB RAM: Ito ay 99% mas kaunting memorya kaysa sa OpenClaw at 98% mas mura kaysa sa isang Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Binuo ng mga mag-aaral at miyembro ng Harvard, MIT, at Sundai.Club na komunidad.
</p>
<p align="center">
🌐 <strong>Mga Wika:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#mabilis-na-pagsisimula">Mabilis na Pagsisimula</a> |
<a href="bootstrap.sh">One-Click na Setup</a> |
<a href="docs/README.md">Hub ng Dokumentasyon</a> |
<a href="docs/SUMMARY.md">Talaan ng Nilalaman</a>
</p>
<p align="center">
<strong>Mga mabilis na access:</strong>
<a href="docs/reference/README.md">Reference</a> ·
<a href="docs/operations/README.md">Operations</a> ·
<a href="docs/troubleshooting.md">Troubleshooting</a> ·
<a href="docs/security/README.md">Security</a> ·
<a href="docs/hardware/README.md">Hardware</a> ·
<a href="docs/contributing/README.md">Mag-contribute</a>
</p>
<p align="center">
<strong>Mabilis, magaan, at ganap na autonomous na AI assistant infrastructure</strong><br />
I-deploy kahit saan. I-swap ang anumang bagay.
</p>
<p align="center">
Ang ZeroClaw ay ang <strong>runtime operating system</strong> para sa agent workflows — isang infrastructure na nag-a-abstract ng mga modelo, tools, memory, at execution upang bumuo ng mga agent nang isang beses at patakbuhin ang mga ito kahit saan.
</p>
<p align="center"><code>Trait-driven architecture · secure-by-default runtime · swappable provider/channel/tool · lahat ay pluggable</code></p>
### 📢 Mga Anunsyo
Gamitin ang talahanayang ito para sa mahahalagang paunawa (compatibility changes, security notices, maintenance windows, at version blocks).
| Petsa (UTC) | Antas | Paunawa | Aksyon |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Kritikal_ | **Hindi kami kaugnay** sa `openagen/zeroclaw` o `zeroclaw.org`. Ang domain na `zeroclaw.org` ay kasalukuyang tumuturo sa fork na `openagen/zeroclaw`, at ang domain/repository na ito ay nanggagaya sa aming opisyal na website/proyekto. | Huwag magtiwala sa impormasyon, binaries, fundraising, o mga anunsyo mula sa mga pinagmulang ito. Gamitin lamang [ang repository na ito](https://github.com/zeroclaw-labs/zeroclaw) at aming mga verified social media accounts. |
| 2026-02-21 | _Mahalaga_ | Ang aming opisyal na website ay ngayon online: [zeroclawlabs.ai](https://zeroclawlabs.ai). Salamat sa iyong pasensya sa panahon ng paghihintay. Nakikita pa rin namin ang mga pagtatangka ng panliliko: huwag lumahok sa anumang investment/funding activity sa ngalan ng ZeroClaw kung hindi ito nai-publish sa pamamagitan ng aming mga opisyal na channel. | Gamitin [ang repository na ito](https://github.com/zeroclaw-labs/zeroclaw) bilang nag-iisang source of truth. Sundan [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (grupo)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/), at [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search) para sa mga opisyal na update. |
| 2026-02-19 | _Mahalaga_ | In-update ng Anthropic ang authentication at credential use terms noong 2026-02-19. Ang OAuth authentication (Free, Pro, Max) ay eksklusibo para sa Claude Code at Claude.ai; ang paggamit ng Claude Free/Pro/Max OAuth tokens sa anumang iba pang produkto, tool, o serbisyo (kasama ang Agent SDK) ay hindi pinapayagan at maaaring lumabag sa Consumer Terms of Use. | Mangyaring pansamantalang iwasan ang Claude Code OAuth integrations upang maiwasan ang anumang potensyal na pagkawala. Orihinal na clause: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Mga Tampok
- 🏎️ **Lightweight Runtime by Default:** Ang mga karaniwang CLI workflows at status commands ay tumatakbo sa loob ng ilang megabytes ng memory footprint sa production builds.
- 💰 **Cost-Effective Deployment:** Dinisenyo para sa low-cost boards at maliliit na cloud instances nang walang mga heavy runtime dependencies.
- ⚡ **Fast Cold Starts:** Ang single-binary Rust runtime ay nagpapanatili ng command at daemon startup na halos instant para sa pang-araw-araw na operasyon.
- 🌍 **Portable Architecture:** Isang single-binary workflow sa ARM, x86, at RISC-V na may swappable na provider/channel/tool.
### Bakit pinipili ng mga team ang ZeroClaw
- **Lightweight by default:** maliit na Rust binary, mabilis na startup, mababang memory footprint.
- **Secure by design:** pairing, strict sandboxing, explicit allowlists, workspace scope.
- **Fully swappable:** ang core systems ay traits (providers, channels, tools, memory, tunnels).
- **No vendor lock-in:** OpenAI-compatible provider support + pluggable custom endpoints.
## Benchmark Snapshot (ZeroClaw vs OpenClaw, Reproducible)
Mabilis na benchmark sa lokal na machine (macOS arm64, Peb. 2026) na normalized para sa 0.8 GHz edge hardware.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Wika** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Startup (0.8 GHz core)** | > 500s | > 30s | < 1s | **< 10ms** |
| **Binary Size** | ~28 MB (dist) | N/A (Scripts) | ~8 MB | **3.4 MB** |
| **Gastos** | Mac Mini $599 | Linux SBC ~$50 | Linux board $10 | **Kahit anong hardware $10** |
> Mga Tala: Ang mga resulta ng ZeroClaw ay sinusukat sa production builds gamit ang `/usr/bin/time -l`. Ang OpenClaw ay nangangailangan ng Node.js runtime (typically ~390 MB additional memory overhead), habang ang NanoBot ay nangangailangan ng Python runtime. Ang PicoClaw at ZeroClaw ay static binaries. Ang mga RAM figure sa itaas ay runtime memory; ang build-time compilation requirements ay mas mataas.
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw Comparison" width="800" />
</p>
### Reproducible Local Measurement
Ang mga benchmark claim ay maaaring mag-drift habang ang code at toolchains ay nag-e-evolve, kaya palaging sukatin ang iyong current build locally:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Halimbawa ng sample (macOS arm64, nasukat noong Pebrero 18, 2026):
- Release binary size: `8.8M`
- `zeroclaw --help`: real time na humigit-kumulang `0.02s`, peak memory footprint ~`3.9 MB`
- `zeroclaw status`: real time na humigit-kumulang `0.01s`, peak memory footprint ~`4.1 MB`
## Mga Kinakailangan
<details>
<summary><strong>Windows</strong></summary>
### Windows — Kinakailangan
1. **Visual Studio Build Tools** (nagbibigay ng MSVC linker at Windows SDK):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Sa panahon ng installation (o sa pamamagitan ng Visual Studio Installer), piliin ang **"Desktop development with C++"** workload.
2. **Rust Toolchain:**
```powershell
winget install Rustlang.Rustup
```
Pagkatapos ng installation, magbukas ng bagong terminal at patakbuhin ang `rustup default stable` upang matiyak na ang stable toolchain ay aktibo.
3. **I-verify** na ang pareho ay gumagana:
```powershell
rustc --version
cargo --version
```
### Windows — Opsyonal
- **Docker Desktop** — kinakailangan lamang kung gagamit ka ng [Docker sandboxed runtime](#current-runtime-support) (`runtime.kind = "docker"`). I-install sa pamamagitan ng `winget install Docker.DockerDesktop`.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Kinakailangan
1. **Essential build tools:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** I-install ang Xcode Command Line Tools: `xcode-select --install`
2. **Rust Toolchain:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Tingnan ang [rustup.rs](https://rustup.rs) para sa mga detalye.
3. **I-verify:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — Opsyonal
- **Docker** — kinakailangan lamang kung gagamit ka ng [Docker sandboxed runtime](#current-runtime-support) (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** tingnan ang [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/)
- **Linux (Fedora/RHEL):** tingnan ang [docs.docker.com](https://docs.docker.com/engine/install/fedora/)
- **macOS:** i-install ang Docker Desktop sa pamamagitan ng [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
</details>
## Mabilis na Pagsisimula
### Option 1: Automated setup (inirerekomenda)
Ang `bootstrap.sh` script ay nag-i-install ng Rust, nagi-clone ng ZeroClaw, nagi-compile, at nagse-set up ng iyong paunang development environment:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
Ito ay:
1. Mag-i-install ng Rust (kung wala)
2. Magi-clone ng ZeroClaw repository
3. Magi-compile ng ZeroClaw sa release mode
4. Mag-i-install ng `zeroclaw` sa `~/.cargo/bin/`
5. Gagawa ng default workspace structure sa `~/.zeroclaw/workspace/`
6. Gagawa ng paunang configuration file na `~/.zeroclaw/workspace/config.toml`
Pagkatapos ng bootstrap, i-reload ang iyong shell o patakbuhin ang `source ~/.cargo/env` para gamitin ang `zeroclaw` command globally.
### Option 2: Manual installation
<details>
<summary><strong>I-click para makita ang mga manual installation steps</strong></summary>
```bash
# 1. I-clone ang repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. I-compile sa release
cargo build --release --locked
# 3. I-install ang binary
cargo install --path . --locked
# 4. I-initialize ang workspace
zeroclaw init
# 5. I-verify ang installation
zeroclaw --version
zeroclaw status
```
</details>
### Pagkatapos ng Installation
Kapag na-install (sa pamamagitan ng bootstrap o manual), dapat mong makita:
```
~/.zeroclaw/workspace/
├── config.toml # Main configuration
├── .pairing # Pairing secrets (generated on first launch)
├── logs/ # Daemon/agent logs
├── skills/ # Custom skills
└── memory/ # Conversation context storage
```
**Mga susunod na hakbang:**
1. I-configure ang iyong AI providers sa `~/.zeroclaw/workspace/config.toml`
2. Tingnan ang [configuration reference](docs/config-reference.md) para sa advanced options
3. Simulan ang agent: `zeroclaw agent start`
4. I-test sa pamamagitan ng iyong preferred channel (tingnan ang [channels reference](docs/channels-reference.md))
## Configuration
I-edit ang `~/.zeroclaw/workspace/config.toml` para i-configure ang providers, channels, at system behavior.
### Quick Configuration Reference
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # o "sqlite" o "none"
[runtime]
kind = "native" # o "docker" (nangangailangan ng Docker)
```
**Mga kumpletong reference document:**
- [Configuration Reference](docs/config-reference.md) — lahat ng settings, validations, defaults
- [Providers Reference](docs/providers-reference.md) — AI provider-specific configurations
- [Channels Reference](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord, at higit pa
- [Operations](docs/operations-runbook.md) — production monitoring, secret rotation, scaling
### Current Runtime Support
Sinusuportahan ng ZeroClaw ang dalawang code execution backends:
- **`native`** (default) — direct process execution, pinakamabilis na path, ideal para sa trusted environments
- **`docker`** — full container isolation, hardened security policies, nangangailangan ng Docker
Gamitin ang `runtime.kind = "docker"` kung kailangan mo ng strict sandboxing o network isolation. Tingnan ang [configuration reference](docs/config-reference.md#runtime) para sa buong detalye.
## Mga Command
```bash
# Workspace management
zeroclaw init # Nag-initialize ng bagong workspace
zeroclaw status # Nagpapakita ng daemon/agent status
zeroclaw config validate # Nag-verify ng config.toml syntax at values
# Daemon management
zeroclaw daemon start # Nagse-start ng daemon sa background
zeroclaw daemon stop # Naghihinto sa running daemon
zeroclaw daemon restart # Nagre-restart ng daemon (config reload)
zeroclaw daemon logs # Nagpapakita ng daemon logs
# Agent management
zeroclaw agent start # Nagse-start ng agent (nangangailangan ng running daemon)
zeroclaw agent stop # Naghihinto sa agent
zeroclaw agent restart # Nagre-restart ng agent (config reload)
# Pairing operations
zeroclaw pairing init # Nag-generate ng bagong pairing secret
zeroclaw pairing rotate # Nag-rotate ng existing pairing secret
# Tunneling (para sa public exposure)
zeroclaw tunnel start # Nagse-start ng tunnel sa local daemon
zeroclaw tunnel stop # Naghihinto sa active tunnel
# Diagnostics
zeroclaw doctor # Nagpapatakbo ng system health checks
zeroclaw version # Nagpapakita ng version at build info
```
Tingnan ang [Commands Reference](docs/commands-reference.md) para sa buong options at examples.
## Architecture
```
┌─────────────────────────────────────────────────────────────────┐
│ Channels (trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Agent Orchestrator │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Message │ │ Context │ │ Tool │ │
│ │ Routing │ │ Memory │ │ Execution │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Providers │ │ Memory │ │ Tools │
│ (trait) │ │ (trait) │ │ (trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ None │ │ Web Fetch │
│ Ollama │ │ Custom │ │ Custom │
│ Custom │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Runtime (trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Mga pangunahing prinsipyo:**
- Ang lahat ay isang **trait** — providers, channels, tools, memory, tunnels
- Ang mga channel ay tumatawag sa orchestrator; ang orchestrator ay tumatawag sa providers + tools
- Ang memory system ay nagmamaneho ng conversation context (markdown, SQLite, o none)
- Ang runtime ay nag-a-abstract ng code execution (native o Docker)
- Walang provider lock-in — i-swap ang Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama nang walang code changes
Tingnan ang [architecture documentation](docs/architecture.svg) para sa mga detalyadong diagram at implementation details.
## Mga Halimbawa
### Telegram Bot
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Ang iyong Telegram user ID
```
Simulan ang daemon + agent, pagkatapos ay magpadala ng mensahe sa iyong bot sa Telegram:
```
/start
Hello! Could you help me write a Python script?
```
Ang bot ay tumutugon gamit ang AI-generated code, nagpapatupad ng mga tool kung hiniling, at nagpapanatili ng conversation context.
### Matrix (end-to-end encryption)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Imbitahan ang `@zeroclaw:matrix.org` sa isang encrypted room, at ang bot ay tutugon gamit ang full encryption. Tingnan ang [Matrix E2EE Guide](docs/matrix-e2ee-guide.md) para sa device verification setup.
### Multi-Provider
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Failover on provider error
```
Kung ang Anthropic ay mabigo o ma-rate-limit, ang orchestrator ay awtomatikong mag-failover sa OpenAI.
### Custom Memory
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # Automatic purge after 90 days
```
O gamitin ang Markdown para sa human-readable storage:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Tingnan ang [Configuration Reference](docs/config-reference.md#memory) para sa lahat ng memory options.
## Provider Support
| Provider | Status | API Key | Example Models |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Stable | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Stable | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Stable | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Stable | N/A (local) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Stable | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Stable | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Planned | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Planned | `COHERE_API_KEY` | TBD |
### Custom Endpoints
Sinusuportahan ng ZeroClaw ang OpenAI-compatible endpoints:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Halimbawa: gamitin ang [LiteLLM](https://github.com/BerriAI/litellm) bilang proxy para ma-access ang anumang LLM sa pamamagitan ng OpenAI interface.
Tingnan ang [Providers Reference](docs/providers-reference.md) para sa kumpletong configuration details.
## Channel Support
| Channel | Status | Authentication | Notes |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Stable | Bot Token | Full support including files, images, inline buttons |
| **Matrix** | ✅ Stable | Password or Token | E2EE support with device verification |
| **Slack** | 🚧 Planned | OAuth or Bot Token | Requires workspace access |
| **Discord** | 🚧 Planned | Bot Token | Requires guild permissions |
| **WhatsApp** | 🚧 Planned | Twilio or official API | Requires business account |
| **CLI** | ✅ Stable | None | Direct conversational interface |
| **Web** | 🚧 Planned | API Key or OAuth | Browser-based chat interface |
Tingnan ang [Channels Reference](docs/channels-reference.md) para sa kumpletong configuration instructions.
## Tool Support
Nagbibigay ang ZeroClaw ng built-in tools para sa code execution, filesystem access, at web retrieval:
| Tool | Description | Required Runtime |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Executes shell commands | Native or Docker |
| **python** | Executes Python scripts | Python 3.8+ (native) or Docker |
| **javascript** | Executes Node.js code | Node.js 18+ (native) or Docker |
| **filesystem_read** | Reads files | Native or Docker |
| **filesystem_write** | Writes files | Native or Docker |
| **web_fetch** | Fetches web content | Native or Docker |
### Execution Security
- **Native Runtime** — runs as daemon's user process, full filesystem access
- **Docker Runtime** — full container isolation, separate filesystems and networks
I-configure ang execution policy sa `config.toml`:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Explicit allowlist
```
Tingnan ang [Configuration Reference](docs/config-reference.md#runtime) para sa kumpletong security options.
## Deployment
### Local Deployment (Development)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Server Deployment (Production)
Gamitin ang systemd para mamaneho ang daemon at agent bilang services:
```bash
# I-install ang binary
cargo install --path . --locked
# I-configure ang workspace
zeroclaw init
# Gumawa ng systemd service files
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# I-enable at i-start ang services
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# I-verify ang status
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Tingnan ang [Network Deployment Guide](docs/network-deployment.md) para sa kumpletong production deployment instructions.
### Docker
```bash
# I-build ang image
docker build -t zeroclaw:latest .
# I-run ang container
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Tingnan ang [`Dockerfile`](Dockerfile) para sa build details at configuration options.
### Edge Hardware
Ang ZeroClaw ay dinisenyo para tumakbo sa low-power hardware:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, single ARMv8 core, < $5 hardware cost
- **Raspberry Pi 4/5** — 1 GB+ RAM, multi-core, ideal for concurrent workloads
- **Orange Pi Zero 2** — ~512 MB RAM, quad-core ARMv8, ultra-low cost
- **x86 SBCs (Intel N100)** — 4-8 GB RAM, fast builds, native Docker support
Tingnan ang [Hardware Guide](docs/hardware/README.md) para sa device-specific setup instructions.
## Tunneling (Public Exposure)
I-expose ang iyong local ZeroClaw daemon sa public network sa pamamagitan ng secure tunnels:
```bash
zeroclaw tunnel start --provider cloudflare
```
Mga supported tunnel provider:
- **Cloudflare Tunnel** — free HTTPS, no port exposure, multi-domain support
- **Ngrok** — quick setup, custom domains (paid plan)
- **Tailscale** — private mesh network, no public port
Tingnan ang [Configuration Reference](docs/config-reference.md#tunnel) para sa kumpletong configuration options.
## Security
Nagpapatupad ang ZeroClaw ng maraming layer ng security:
### Pairing
Ang daemon ay nag-generate ng pairing secret sa unang launch na nakaimbak sa `~/.zeroclaw/workspace/.pairing`. Ang mga client (agent, CLI) ay dapat mag-present ng secret na ito para kumonekta.
```bash
zeroclaw pairing rotate # Gagawa ng bagong secret at i-invalidate ang dati
```
### Sandboxing
- **Docker Runtime** — full container isolation na may separate filesystems at networks
- **Native Runtime** — runs as user process, scoped sa workspace by default
### Allowlists
Ang mga channel ay maaaring mag-limit ng access by user ID:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Explicit allowlist
```
### Encryption
- **Matrix E2EE** — full end-to-end encryption with device verification
- **TLS Transport** — all API and tunnel traffic uses HTTPS/TLS
Tingnan ang [Security Documentation](docs/security/README.md) para sa kumpletong policies at practices.
## Observability
Ang ZeroClaw ay naglo-log sa `~/.zeroclaw/workspace/logs/` by default. Ang mga log ay nakaimbak by component:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Daemon logs (startup, API requests, errors)
├── agent.log # Agent logs (message routing, tool execution)
├── telegram.log # Channel-specific logs (if enabled)
└── matrix.log # Channel-specific logs (if enabled)
```
### Logging Configuration
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # daily, hourly, size
max_size_mb = 100 # For size-based rotation
retention_days = 30 # Automatic purge after N days
```
Tingnan ang [Configuration Reference](docs/config-reference.md#logging) para sa lahat ng logging options.
### Metrics (Planned)
Prometheus metrics support para sa production monitoring ay coming soon. Tracking sa [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234).
## Skills
Sinusuportahan ng ZeroClaw ang custom skills — reusable modules na nag-e-extend sa system capabilities.
### Skill Definition
Ang mga skill ay nakaimbak sa `~/.zeroclaw/workspace/skills/<skill-name>/` na may ganitong structure:
```
skills/
└── my-skill/
├── skill.toml # Skill metadata (name, description, dependencies)
├── prompt.md # System prompt for the AI
└── tools/ # Optional custom tools
└── my_tool.py
```
### Skill Example
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Searches the web and summarizes results"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
You are a research assistant. When asked to research something:
1. Use web_fetch to retrieve content
2. Summarize results in an easy-to-read format
3. Cite sources with URLs
```
### Skill Usage
Ang mga skill ay automatically loaded sa agent startup. I-reference ang mga ito by name sa conversations:
```
User: Use the web-research skill to find the latest AI news
Bot: [loads web-research skill, executes web_fetch, summarizes results]
```
Tingnan ang [Skills](#skills) section para sa kumpletong skill creation instructions.
## Open Skills
Sinusuportahan ng ZeroClaw ang [Open Skills](https://github.com/openagents-com/open-skills) — isang modular at provider-agnostic system para sa pag-extend sa AI agent capabilities.
### Enable Open Skills
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # optional
```
Maaari mo ring i-override sa runtime gamit ang `ZEROCLAW_OPEN_SKILLS_ENABLED` at `ZEROCLAW_OPEN_SKILLS_DIR`.
## Development
```bash
cargo build # Dev build
cargo build --release # Release build (codegen-units=1, works on all devices including Raspberry Pi)
cargo build --profile release-fast # Faster build (codegen-units=8, requires 16 GB+ RAM)
cargo test # Run full test suite
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Format
# Run SQLite vs Markdown comparison benchmark
cargo test --test memory_comparison -- --nocapture
```
### Pre-push hook
Ang isang git hook ay nagpapatakbo ng `cargo fmt --check`, `cargo clippy -- -D warnings`, at `cargo test` bago ang bawat push. I-enable ito nang isang beses:
```bash
git config core.hooksPath .githooks
```
### Build Troubleshooting (OpenSSL errors on Linux)
Kung makakita ka ng `openssl-sys` build error, i-sync ang dependencies at i-recompile gamit ang repository's lockfile:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
Ang ZeroClaw ay naka-configure na gumamit ng `rustls` para sa HTTP/TLS dependencies; ang `--locked` ay nagpapanatili sa transitive graph na deterministic sa clean environments.
Para i-skip ang hook kapag kailangan mo ng quick push habang nagde-develop:
```bash
git push --no-verify
```
## Collaboration & Docs
Magsimula sa documentation hub para sa task-based map:
- Documentation Hub: [`docs/README.md`](docs/README.md)
- Unified Docs TOC: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Commands Reference: [`docs/commands-reference.md`](docs/commands-reference.md)
- Configuration Reference: [`docs/config-reference.md`](docs/config-reference.md)
- Providers Reference: [`docs/providers-reference.md`](docs/providers-reference.md)
- Channels Reference: [`docs/channels-reference.md`](docs/channels-reference.md)
- Operations Runbook: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Troubleshooting: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Docs Inventory/Classification: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- PR/Issue Triage Snapshot (as of Feb 18, 2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Mga pangunahing collaboration references:
- Documentation Hub: [docs/README.md](docs/README.md)
- Documentation Template: [docs/doc-template.md](docs/doc-template.md)
- Documentation Change Checklist: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Channel Configuration Reference: [docs/channels-reference.md](docs/channels-reference.md)
- Matrix Encrypted Room Operations: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Contributing Guide: [CONTRIBUTING.md](CONTRIBUTING.md)
- PR Workflow Policy: [docs/pr-workflow.md](docs/pr-workflow.md)
- Reviewer Playbook (triage + deep review): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Ownership and CI Triage Map: [docs/ci-map.md](docs/ci-map.md)
- Security Disclosure Policy: [SECURITY.md](SECURITY.md)
Para sa deployment at runtime operations:
- Network Deployment Guide: [docs/network-deployment.md](docs/network-deployment.md)
- Proxy Agent Playbook: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## Suportahan ang ZeroClaw
Kung tinutulungan ng ZeroClaw ang iyong trabaho at nais mong suportahan ang patuloy na development, maaari kang mag-donate dito:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Bilhan Mo Ako ng Kape" /></a>
### 🙏 Special Thanks
Isang taos-pusong pasasalamat sa mga komunidad at institusyon na nagbibigay-inspirasyon at nagpapakain sa open-source work na ito:
- **Harvard University** — para sa pagpapaunlad ng intelektwal na kuryosidad at pagtulak sa mga hangganan ng kung ano ang posible.
- **MIT** — para sa pagtatanggol ng open knowledge, open source, at ang paniniwala na ang teknolohiya ay dapat na accessible sa lahat.
- **Sundai Club** — para sa komunidad, enerhiya, at ang walang-humpay na kagustuhang bumuo ng mga bagay na mahalaga.
- **Ang Mundo at Higit Pa** 🌍✨ — sa bawat contributor, dreamer, at builder doon sa labas na gumagawa ng open source bilang isang puwersa para sa kabutihan. Ito ay para sa iyo.
Kami ay bumubuo sa open source dahil ang mga pinakamahusay na ideya ay nagmumula sa lahat ng dako. Kung binabasa mo ito, ikaw ay bahagi nito. Maligayang pagdating. 🦀❤️
## ⚠️ Official Repository at Impersonation Warning
**Ito ang tanging opisyal na ZeroClaw repository:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Ang anumang iba pang repository, organization, domain, o package na nagpapanggap na "ZeroClaw" o nagpapahiwatig ng affiliation sa ZeroClaw Labs ay **hindi awtorisado at hindi kaugnay sa proyektong ito**. Ang mga kilalang unauthorized forks ay ililista sa [TRADEMARK.md](TRADEMARK.md).
Kung makakita ka ng impersonation o trademark misuse, mangyaring [magbukas ng isyu](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## License
Ang ZeroClaw ay dual-licensed para sa maximum openness at contributor protection:
| License | Use Cases |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Open-source, research, academic, personal use |
| [Apache 2.0](LICENSE-APACHE) | Patent protection, institutional, commercial deployment |
Maaari mong piliin ang alinmang license. **Ang mga contributor ay awtomatikong nagbibigay ng rights sa ilalim ng pareho** — tingnan ang [CLA.md](CLA.md) para sa kumpletong contributor agreement.
### Trademark
Ang pangalang **ZeroClaw** at logo ay mga rehistradong trademark ng ZeroClaw Labs. Ang license na ito ay hindi nagbibigay ng pahintulot na gamitin ang mga ito upang ipahiwatig ang endorsement o affiliation. Tingnan ang [TRADEMARK.md](TRADEMARK.md) para sa mga allowed at prohibited uses.
### Contributor Protections
- **Mo namang pinapanatili** ang copyright ng iyong mga kontribusyon
- **Patent grant** (Apache 2.0) ay nagpoprotekta sa iyo laban sa patent claims ng ibang mga contributor
- Ang iyong mga kontribusyon ay **permanenteng naa-attributed** sa commit history at [NOTICE](NOTICE)
- Walang trademark rights ang naililipat sa pamamagitan ng pagko-contribute
## Mag-contribute
Tingnan ang [CONTRIBUTING.md](CONTRIBUTING.md) at [CLA.md](CLA.md). Mag-implement ng isang trait, mag-submit ng PR:
- CI workflow guide: [docs/ci-map.md](docs/ci-map.md)
- Bagong `Provider``src/providers/`
- Bagong `Channel``src/channels/`
- Bagong `Observer``src/observability/`
- Bagong `Tool``src/tools/`
- Bagong `Memory``src/memory/`
- Bagong `Tunnel``src/tunnel/`
- Bagong `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Zero overhead. Zero compromise. Deploy anywhere. Swap anything. 🦀
## Star History
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Star History Graph" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

914
README.tr.md Normal file
View File

@ -0,0 +1,914 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Sıfırıırı yok. Sıfır ödün ver yok. %100 Rust. %100 Agnostik.</strong><br>
⚡️ <strong>$10 donanımla <5MB RAM ile çalışır: OpenClaw'dan %99 daha az bellek ve Mac mini'den %98 daha ucuz!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
<a href="https://www.reddit.com/r/zeroclawlabs/"><img src="https://img.shields.io/badge/Reddit-r%2Fzeroclawlabs-FF4500?style=flat&logo=reddit&logoColor=white" alt="Reddit: r/zeroclawlabs" /></a>
</p>
<p align="center">
Harvard, MIT ve Sundai.Club topluluklarının öğrencileri ve üyeleri tarafından inşa edilmiştir.
</p>
<p align="center">
🌐 <strong>Diller:</strong><a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#hızlı-başlangıç">Hızlı Başlangıç</a> |
<a href="bootstrap.sh">Tek Tıklama Kurulumu</a> |
<a href="docs/README.md">Dokümantasyon Merkezi</a> |
<a href="docs/SUMMARY.md">Dokümantasyon İçindekiler</a>
</p>
<p align="center">
<strong>Hızlı erişim:</strong>
<a href="docs/reference/README.md">Referans</a> ·
<a href="docs/operations/README.md">Operasyonlar</a> ·
<a href="docs/troubleshooting.md">Sorun Giderme</a> ·
<a href="docs/security/README.md">Güvenlik</a> ·
<a href="docs/hardware/README.md">Donanım</a> ·
<a href="docs/contributing/README.md">Katkıda Bulunma</a>
</p>
<p align="center">
<strong>Hızlı, hafif ve tamamen otonom AI asistan altyapısı</strong><br />
Her yerde dağıtın. Her şeyi değiştirin.
</p>
<p align="center">
ZeroClaw, ajan iş akışları için <strong>çalışma zamanı işletim sistemidir</strong> — modelleri, araçları, belleği ve yürütmeyi soyutlayan, ajanları bir kez oluşturup ve her yerde çalıştıran bir altyapıdır.
</p>
<p align="center"><code>Trait tabanlı mimari · varsayılan olarak güvenli çalışma zamanı · değiştirilebilir sağlayıcı/kanal/araç · her şey eklenebilir</code></p>
### 📢 Duyurular
Önemli duyurular için bu tabloyu kullanın (uyumluluk değişiklikleri, güvenlik bildirimleri, bakım pencereleri ve sürüm engellemeleri).
| Tarih (UTC) | Seviye | Duyuru | Eylem |
| ---------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 2026-02-19 | _Kritik_ | **`openagen/zeroclaw` veya `zeroclaw.org` ile bağlantılı değiliz.** `zeroclaw.org` alanı şu anda `openagen/zeroclaw` fork'una işaret ediyor ve bu alan/depo taklitçiliğini yapıyor. | Bu kaynaklardan bilgi, ikili dosyalar, bağış toplama veya duyurulara güvenmeyin. Sadece [bu depoyu](https://github.com/zeroclaw-labs/zeroclaw) ve doğrulanmış sosyal medya hesaplarımızı kullanın. |
| 2026-02-21 | _Önemli_ | Resmi web sitemiz artık çevrimiçi: [zeroclawlabs.ai](https://zeroclawlabs.ai). Bekleme sürecinde sabırlarınız için teşekkürler. Hala taklit girişimleri tespit ediyoruz: ZeroClaw adına resmi kanallarımız aracılığıyla yayınlanmayan herhangi bir yatırım/bağış faaliyetine katılmayın. | [Bu depoyu](https://github.com/zeroclaw-labs/zeroclaw) tek doğruluk kaynağı olarak kullanın. Resmi güncellemeler için [X (@zeroclawlabs)](https://x.com/zeroclawlabs?s=21), [Telegram (@zeroclawlabs)](https://t.me/zeroclawlabs), [Facebook (grup)](https://www.facebook.com/groups/zeroclaw), [Reddit (r/zeroclawlabs)](https://www.reddit.com/r/zeroclawlabs/) ve [Xiaohongshu](https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search)'u takip edin. |
| 2026-02-19 | _Önemli_ | Anthropic, 2026-02-19 tarihinde kimlik doğrulama ve kimlik bilgileri kullanım şartlarını güncelledi. OAuth kimlik doğrulaması (Free, Pro, Max) yalnızca Claude Code ve Claude.ai içindir; Claude Free/Pro/Max OAuth belirteçlerini başka herhangi bir ürün, araç veya hizmette (Agent SDK dahil) kullanmak yasaktır ve Tüketici Kullanım Şartlarını ihlal edebilir. | Olası kayıpları önlemek için lütfen geçici olarak Claude Code OAuth entegrasyonlarından kaçının. Orijinal madde: [Authentication and Credential Use](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use). |
### ✨ Özellikler
- 🏎️ **Varsayılan Hafif Çalışma Zamanı:** Yaygın CLI iş akışları ve durum komutları üretim derlemelerinde birkaç megabaytlık bellek alanında çalışır.
- 💰 **Maliyet Etkin Dağıtım:**ır çalışma zamanı bağımlılıkları olmadan düşük maliyetli kartlar ve küçük bulut örnekleri için tasarlanmıştır.
- 💡 **Hızlı Soğuk Başlangıçlar:** Tek ikili Rust çalışma zamanı, komut ve arka plan programı başlatmalarını günlük operasyonlar için neredeyse anlık tutar.
- 🌍 **Taşınabilir Mimari:** Değiştirilebilir sağlayıcı/kanal/araç ile ARM, x86 ve RISC-V üzerinde tek ikili iş akışı.
### Neden ekipler ZeroClaw'ı seçiyor
- **Varsayılan hafif:** küçük Rust ikilisi, hızlı başlangıç, düşük bellek ayak izi.
- **Tasarıma göre güvenli:** eşleştirme, katı kum alanı, açık izin listeleri, çalışma alanı kapsamı.
- **Tamamen değiştirilebilir:** çekirdek sistemler trait'tir (sağlayıcılar, kanallar, araçlar, bellek, tüneller).
- **Satıcı kilitlenmesi yok:** OpenAI uyumlu sağlayıcı desteği + eklenebilir özel uç noktalar.
## Kıyaslama Anlık Görüntüsü (ZeroClaw vs OpenClaw, Tekrarlanabilir)
Yerel makinede hızlı kıyaslama (macOS arm64, Şub. 2026) 0.8 GHz uç donanımı için normalize edilmiş.
| | OpenClaw | NanoBot | PicoClaw | ZeroClaw 🦀 |
| ---------------------------- | ------------- | -------------- | --------------- | --------------------- |
| **Dil** | TypeScript | Python | Go | **Rust** |
| **RAM** | > 1 GB | > 100 MB | < 10 MB | **< 5 MB** |
| **Başlangıç (0.8 GHz çekirdek)** | > 500s | > 30s | < 1s | **< 10ms** |
| **İkili Boyut** | ~28 MB (dist) | Yok (Betikler) | ~8 MB | **3.4 MB** |
| **Maliyet** | Mac Mini $599 | Linux SBC ~$50 | Linux kart $10 | **Herhangi bir donanım $10** |
> Notlar: ZeroClaw sonuçları `/usr/bin/time -l` kullanılarak üretim derlemelerinde ölçülür. OpenClaw Node.js çalışma zamanı gerektirir (tipik olarak ~390 MB ek bellek yükü), NanoBot ise Python çalışma zamanı gerektirir. PicoClaw ve ZeroClaw statik ikililerdir. Yukarıdaki RAM rakamları çalışma zamanı belleğidir; derleme zamanı derleme gereksinimleri daha yüksektir.
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw Karşılaştırması" width="800" />
</p>
### Tekrarlanabilir Yerel Ölçüm
Kıyaslama iddiaları kod ve araç zincirleri geliştikçe değişebilir, bu yüzden her zaman mevcut derlemenizi yerel olarak ölçün:
```bash
cargo build --release
ls -lh target/release/zeroclaw
/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status
```
Örnek numune (macOS arm64, 18 Şubat 2026'da ölçüldü):
- Sürüm ikili boyutu: `8.8M`
- `zeroclaw --help`: gerçek süre yaklaşık `0.02s`, en büyük bellek ayak izi ~`3.9 MB`
- `zeroclaw status`: gerçek süre yaklaşık `0.01s`, en büyük bellek ayak izi ~`4.1 MB`
## Ön Koşullar
<details>
<summary><strong>Windows</strong></summary>
### Windows — Gerekli
1. **Visual Studio Build Tools** (MSVC bağlayıcısını ve Windows SDK'yı sağlar):
```powershell
winget install Microsoft.VisualStudio.2022.BuildTools
```
Kurulum sırasında (veya Visual Studio Installer aracılığıyla), **"C++ ile Masaüstü Geliştirme"** iş yükünü seçin.
2. **Rust Araç Zinciri:**
```powershell
winget install Rustlang.Rustup
```
Kurulumdan sonra, yeni bir terminal açın ve kararlı araç zincirinin aktif olduğundan emin olmak için `rustup default stable` çalıştırın.
3. **Doğrulayın** ikisinin de çalıştığını:
```powershell
rustc --version
cargo --version
```
### Windows — İsteğe Bağlı
- **Docker Desktop** — yalnızca [Docker kum alanlı çalışma zamanı](#mevcut-çalışma-zamanı-desteği) kullanıyorsanız gereklidir (`runtime.kind = "docker"`). `winget install Docker.DockerDesktop` aracılığıyla yükleyin.
</details>
<details>
<summary><strong>Linux / macOS</strong></summary>
### Linux / macOS — Gerekli
1. **Temel derleme araçları:**
- **Linux (Debian/Ubuntu):** `sudo apt install build-essential pkg-config`
- **Linux (Fedora/RHEL):** `sudo dnf group install development-tools && sudo dnf install pkg-config`
- **macOS:** Xcode Command Line Tools'u yükleyin: `xcode-select --install`
2. **Rust Araç Zinciri:**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Detaylar için [rustup.rs](https://rustup.rs) adresine bakın.
3. **Doğrulayın:**
```bash
rustc --version
cargo --version
```
### Linux / macOS — İsteğe Bağlı
- **Docker** — yalnızca [Docker kum alanlı çalışma zamanı](#mevcut-çalışma-zamanı-desteği) kullanıyorsanız gereklidir (`runtime.kind = "docker"`).
- **Linux (Debian/Ubuntu):** [docs.docker.com](https://docs.docker.com/engine/install/ubuntu/) adresine bakın
- **Linux (Fedora/RHEL):** [docs.docker.com](https://docs.docker.com/engine/install/fedora/) adresine bakın
- **macOS:** [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/) adresinden Docker Desktop'u yükleyin
</details>
## Hızlı Başlangıç
### Seçenek 1: Otomatik kurulum (önerilen)
`bootstrap.sh` betiği Rust'u yükler, ZeroClaw'ı klonlar, derler ve ilk geliştirme ortamınızı ayarlar:
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/bootstrap.sh | bash
```
Bu işlem:
1. Rust'u yükler (yoksa)
2. ZeroClaw deposunu klonlar
3. ZeroClaw'ı sürüm modunda derler
4. `zeroclaw`'ı `~/.cargo/bin/`e yükler
5. `~/.zeroclaw/workspace/` içinde varsayılan çalışma alanı yapısını oluşturur
6. Başlangıç `~/.zeroclaw/workspace/config.toml` yapılandırma dosyasını üretir
Önyüklemeden sonra, `zeroclaw` komutunu global olarak kullanmak için kabuğunuzu yeniden yükleyin veya `source ~/.cargo/env` çalıştırın.
### Seçenek 2: Manuel kurulum
<details>
<summary><strong>Manuel kurulum adımlarını görmek için tıklayın</strong></summary>
```bash
# 1. Depoyu klonla
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# 2. Sürüm olarak derle
cargo build --release --locked
# 3. İkiliyi yükle
cargo install --path . --locked
# 4. Çalışma alanını başlat
zeroclaw init
# 5. Kurulumu doğrula
zeroclaw --version
zeroclaw status
```
</details>
### Kurulumdan Sonra
Kurulumdan sonra (önyükleme veya manuel olarak), şunları görmelisiniz:
```
~/.zeroclaw/workspace/
├── config.toml # Ana yapılandırma
├── .pairing # Eşleştirme sırları (ilk başlangıçta oluşturulur)
├── logs/ # Arka plan programı/ajan logları
├── skills/ # Özel beceriler
└── memory/ # Konuşma bağlamı depolaması
```
**Sonraki adımlar:**
1. AI sağlayıcılarınızı `~/.zeroclaw/workspace/config.toml` içinde yapılandırın
2. Gelişmiş seçenekler için [yapılandırma referansına](docs/config-reference.md) bakın
3. Ajanı başlatın: `zeroclaw agent start`
4. Tercih ettiğiniz kanal üzerinden test edin ([kanallar referansına](docs/channels-reference.md) bakın)
## Yapılandırma
Sağlayıcıları, kanalları ve sistem davranışını yapılandırmak için `~/.zeroclaw/workspace/config.toml` dosyasını düzenleyin.
### Hızlı Yapılandırma Referansı
```toml
[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
api_key = "sk-..."
model = "gpt-4o"
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."
[memory]
kind = "markdown" # veya "sqlite" veya "none"
[runtime]
kind = "native" # veya "docker" (Docker gerektirir)
```
**Tam referans belgeleri:**
- [Yapılandırma Referansı](docs/config-reference.md) — tüm ayarlar, doğrulamalar, varsayılanlar
- [Sağlayıcı Referansı](docs/providers-reference.md) — AI sağlayıcıya özgü yapılandırmalar
- [Kanallar Referansı](docs/channels-reference.md) — Telegram, Matrix, Slack, Discord ve daha fazlası
- [Operasyonlar](docs/operations-runbook.md) — üretim izleme, sırları döndürme, ölçeklendirme
### Mevcut Çalışma Zamanı Desteği
ZeroClaw iki kod yürütme arka ucu destekler:
- **`native`** (varsayılan) — doğrudan süreç yürütme, en hızlı yol, güvenilir ortamlar için ideal
- **`docker`** — tam konteyner yalıtımı. sertleştirilmiş güvenlik ilkeleri. Docker gerektirir
Katı kum alanı veya ağ yalıtımı gerekiyorsa `runtime.kind = "docker"` kullanın. Tam detaylar için [yapılandırma referansına](docs/config-reference.md#runtime) bakın.
## Komutlar
```bash
# Çalışma alanı yönetimi
zeroclaw init # Yeni bir çalışma alanı başlatır
zeroclaw status # Arka plan programı/ajan durumunu gösterir
zeroclaw config validate # config.toml sözdizimini ve değerlerini doğrular
# Arka plan programı yönetimi
zeroclaw daemon start # Arka plan programını arka planda başlatır
zeroclaw daemon stop # Çalışan arka plan programını durdurur
zeroclaw daemon restart # Arka plan programını yeniden başlatır (yapılandırmayı yeniden yükler)
zeroclaw daemon logs # Arka plan programı loglarını gösterir
# Ajan yönetimi
zeroclaw agent start # Ajanı başlatır (çalışan arka plan programı gerektirir)
zeroclaw agent stop # Ajanı durdurur
zeroclaw agent restart # Ajanı yeniden başlatır (yapılandırmayı yeniden yükler)
# Eşleştirme operasyonları
zeroclaw pairing init # Yeni bir eşleştirme sırrı oluşturur
zeroclaw pairing rotate # Mevcut eşleştirme sırrını döndürür
# Tünelleme (herkese açık kullanım için)
zeroclaw tunnel start # Yerel arka plan programına bir tünel başlatır
zeroclaw tunnel stop # Aktif tüneli durdurur
# Teşhis
zeroclaw doctor # Sistem sağlık kontrollerini çalıştırır
zeroclaw version # Sürüm ve derleme bilgilerini gösterir
```
Tam seçenekler ve örnekler için [Komutlar Referansına](docs/commands-reference.md) bakın.
## Mimari
```
┌─────────────────────────────────────────────────────────────────┐
│ Kanallar (trait) │
│ Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Özel │
└─────────────────────────┬───────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Ajan Orkestratörü │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Mesaj │ │ Bağlam │ │ Araç │ │
│ │ Yönlendirme│ │ Bellek │ │ Yürütme │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────┬───────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Sağlayıcılar│ │ Bellek │ │ Araçlar │
│ (trait) │ │ (trait) │ │ (trait) │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ Anthropic │ │ Markdown │ │ Filesystem │
│ OpenAI │ │ SQLite │ │ Bash │
│ Gemini │ │ Yok │ │ Web Fetch │
│ Ollama │ │ Özel │ │ Özel │
│ Özel │ └──────────────┘ └──────────────┘
└──────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Çalışma Zamanı (trait) │
│ Native │ Docker │
└─────────────────────────────────────────────────────────────────┘
```
**Temel ilkeler:**
- Her şey bir **trait'tir** — sağlayıcılar, kanallar, araçlar, bellek, tüneller
- Kanallar orkestratörü çağırır; orkestratör sağlayıcıları + araçları çağırır
- Bellek sistemi konuşma bağlamını yönetir (markdown, SQLite veya yok)
- Çalışma zamanı kod yürütmeyi soyutlar (yerel veya Docker)
- Satıcı kilitlenmesi yok — kod değişikliği olmadan Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama değiştirin
Detaylı diyagramlar ve uygulama detayları için [mimari belgelerine](docs/architecture.svg) bakın.
## Örnekler
### Telegram Bot
```toml
[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321] # Telegram kullanıcı ID'niz
```
Arka plan programını + ajanı başlatın, ardından Telegram'da botunuza bir mesaj gönderin:
```
/start
Merhaba! Bir Python betiği yazmama yardımcı olabilir misin?
```
Bot, AI tarafından oluşturulan kodla yanıt verir, istenirse araçları yürütür ve konuşma bağlamını korur.
### Matrix (uçtan uca şifreleme)
```toml
[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true
```
Şifreli bir odaya `@zeroclaw:matrix.org` davet edin ve bot tam şifrelemeyle yanıt verecektir. Cihaz doğrulama kurulumu için [Matrix E2EE Kılavuzuna](docs/matrix-e2ee-guide.md) bakın.
### Çoklu-Sağlayıcı
```toml
[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"
[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"
[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"] # Sağlayıcı hatasında geçiş
```
Anthropic başarısız olursa veya hız sınırına ulaşırsa, orkestratör otomatik olarak OpenAI'ya geçer.
### Özel Bellek
```toml
[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90 # 90 gün sonra otomatik temizleme
```
Veya insan tarafından okunabilir depolama için Markdown kullanın:
```toml
[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"
```
Tüm bellek seçenekleri için [Yapılandırma Referansına](docs/config-reference.md#memory) bakın.
## Sağlayıcı Desteği
| Sağlayıcı | Durum | API Anahtarı | Örnek Modeller |
| ----------------- | ----------- | ------------------- | ---------------------------------------------------- |
| **Anthropic** | ✅ Kararlı | `ANTHROPIC_API_KEY` | `claude-sonnet-4-20250514`, `claude-opus-4-20250514` |
| **OpenAI** | ✅ Kararlı | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini` |
| **Google Gemini** | ✅ Kararlı | `GOOGLE_API_KEY` | `gemini-2.0-flash-exp`, `gemini-exp-1206` |
| **Ollama** | ✅ Kararlı | Yok (yerel) | `llama3.3`, `qwen2.5`, `phi4` |
| **Cerebras** | ✅ Kararlı | `CEREBRAS_API_KEY` | `llama-3.3-70b` |
| **Groq** | ✅ Kararlı | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
| **Mistral** | 🚧 Planlanan | `MISTRAL_API_KEY` | TBD |
| **Cohere** | 🚧 Planlanan | `COHERE_API_KEY` | TBD |
### Özel Uç Noktalar
ZeroClaw, OpenAI uyumlu uç noktaları destekler:
```toml
[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"
```
Örnek: herhangi bir LLM'ye OpenAI arayüzü üzerinden erişmek için [LiteLLM](https://github.com/BerriAI/litellm)'i proxy olarak kullanın.
Tam yapılandırma detayları için [Sağlayıcı Referansına](docs/providers-reference.md) bakın.
## Kanal Desteği
| Kanal | Durum | Kimlik Doğrulama | Notlar |
| ------------ | ----------- | ------------------------ | --------------------------------------------------------- |
| **Telegram** | ✅ Kararlı | Bot Token | Dosyalar, resimler, satır içi düğmeler dahil tam destek |
| **Matrix** | ✅ Kararlı | Şifre veya Token | Cihaz doğrulamalı E2EE desteği |
| **Slack** | 🚧 Planlanan | OAuth veya Bot Token | Çalışma alanı erişimi gerektirir |
| **Discord** | 🚧 Planlanan | Bot Token | Guild izinleri gerektirir |
| **WhatsApp** | 🚧 Planlanan | Twilio veya resmi API | İş hesabı gerektirir |
| **CLI** | ✅ Kararlı | Yok | Doğrudan konuşma arayüzü |
| **Web** | 🚧 Planlanan | API Anahtarı veya OAuth | Tarayıcı tabanlı sohbet arayüzü |
Tam yapılandırma talimatları için [Kanallar Referansına](docs/channels-reference.md) bakın.
## Araç Desteği
ZeroClaw, kod yürütme, dosya sistemi erişimi ve web alımı için yerleşik araçlar sağlar:
| Araç | Açıklama | Gerekli Çalışma Zamanı |
| -------------------- | --------------------------- | ----------------------------- |
| **bash** | Shell komutlarını yürüt | Yerel veya Docker |
| **python** | Python betiklerini yürüt | Python 3.8+ (yerel) veya Docker |
| **javascript** | Node.js kodunu yürüt | Node.js 18+ (yerel) veya Docker |
| **filesystem_read** | Dosyaları oku | Yerel veya Docker |
| **filesystem_write** | Dosyaları yaz | Yerel veya Docker |
| **web_fetch** | Web içeriği al | Yerel veya Docker |
### Yürütme Güvenliği
- **Yerel Çalışma Zamanı** — arka plan programının kullanıcı süreci olarak çalışır, tam dosya sistemi erişimi
- **Docker Çalışma Zamanı** — tam konteyner yalıtımı, ayrı dosya sistemleri ve ağlar
`config.toml` içinde yürütme ilkesini yapılandırın:
```toml
[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"] # Açık izin listesi
```
Tam güvenlik seçenekleri için [Yapılandırma Referansına](docs/config-reference.md#runtime) bakın.
## Dağıtım
### Yerel Dağıtım (Geliştirme)
```bash
zeroclaw daemon start
zeroclaw agent start
```
### Sunucu Dağıtımı (Üretim)
Arka plan programını ve ajanı hizmet olarak yönetmek için systemd kullanın:
```bash
# İkiliyi yükle
cargo install --path . --locked
# Çalışma alanını yapılandır
zeroclaw init
# systemd hizmet dosyaları oluştur
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/
# Hizmetleri etkinleştir ve başlat
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent
# Durumu doğrula
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent
```
Tam üretim dağıtım talimatları için [Ağ Dağıtımı Kılavuzuna](docs/network-deployment.md) bakın.
### Docker
```bash
# İmajı oluştur
docker build -t zeroclaw:latest .
# Konteyneri çalıştır
docker run -d \
--name zeroclaw \
-v ~/.zeroclaw/workspace:/workspace \
-e ANTHROPIC_API_KEY=sk-ant-... \
zeroclaw:latest
```
Derleme detayları ve yapılandırma seçenekleri için [`Dockerfile`](Dockerfile)'a bakın.
### Uç Donanım
ZeroClaw, düşük güç tüketimli donanımda çalışmak üzere tasarlanmıştır:
- **Raspberry Pi Zero 2 W** — ~512 MB RAM, tek ARMv8 çekirdek, < $5 donanım maliyeti
- **Raspberry Pi 4/5** — 1 GB+ RAM, çok çekirdekli, eşzamanlı iş yükleri için ideal
- **Orange Pi Zero 2** — ~512 MB RAM, dört çekirdekli ARMv8, ultra düşük maliyet
- **x86 SBC'ler (Intel N100)** — 4-8 GB RAM, hızlı derlemeler, yerel Docker desteği
Cihaza özgü kurulum talimatları için [Donanım Kılavuzuna](docs/hardware/README.md) bakın.
## Tünelleme (Herkese Açık Kullanım)
Yerel ZeroClaw arka plan programınızı güvenli tüneller aracılığıyla herkese açık ağa çıkarın:
```bash
zeroclaw tunnel start --provider cloudflare
```
Desteklenen tünel sağlayıcıları:
- **Cloudflare Tunnel** — ücretsiz HTTPS, port açığa çıkarma yok, çoklu etki alanı desteği
- **Ngrok** — hızlı kurulum, özel etki alanları (ücretli plan)
- **Tailscale** — özel mesh ağı. herkese açık port yok
Tam yapılandırma seçenekleri için [Yapılandırma Referansına](docs/config-reference.md#tunnel) bakın.
## Güvenlik
ZeroClaw birden çok güvenlik katmanı uygular:
### Eşleştirme
Arka plan programı ilk başlangıçta `~/.zeroclaw/workspace/.pairing` içinde saklanan bir eşleştirme sırrı oluşturur. İstemciler (ajan, CLI) bağlanmak için bu sırrı sunmalıdır.
```bash
zeroclaw pairing rotate # Yeni bir sır oluşturur ve eskisini geçersiz kılar
```
### Kum Alanı
- **Docker Çalışma Zamanı** — ayrı dosya sistemleri ve ağlarla tam konteyner yalıtımı
- **Yerel Çalışma Zamanı** — kullanıcı süreci olarak çalışır; varsayılan olarak çalışma alanıyla sınırlıdır
### İzin Listeleri
Kanallar kullanıcı ID'sine göre erişimi kısıtlayabilir:
```toml
[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321] # Açık izin listesi
```
### Şifreleme
- **Matrix E2EE** — cihaz doğrulamalı tam uçtan uca şifreleme
- **TLS Taşıma** — tüm API ve tünel trafiği HTTPS/TLS kullanır
Tam ilkeler ve uygulamalar için [Güvenlik Belgelerine](docs/security/README.md) bakın.
## Gözlemlenebilirlik
ZeroClaw varsayılan olarak `~/.zeroclaw/workspace/logs/` dizinine log yazar. Loglar bileşene göre saklanır:
```
~/.zeroclaw/workspace/logs/
├── daemon.log # Arka plan programı logları (başlangıç, API istekleri, hatalar)
├── agent.log # Ajan logları (mesaj yönlendirme, araç yürütme)
├── telegram.log # Kanala özgü loglar (etkinse)
└── matrix.log # Kanala özgü loglar (etkinse)
```
### Loglama Yapılandırması
```toml
[logging]
level = "info" # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily" # günlük, saatlik, boyut
max_size_mb = 100 # Boyut tabanlı döndürme için
retention_days = 30 # N gün sonra otomatik temizleme
```
Tüm loglama seçenekleri için [Yapılandırma Referansına](docs/config-reference.md#logging) bakın.
### Metrikler (Planlanan)
Üretim izleme için Prometheus metrikleri desteği yakında geliyor. [#234](https://github.com/zeroclaw-labs/zeroclaw/issues/234) numaralı konuda takip ediliyor.
## Beceriler
ZeroClaw, sistem yeteneklerini genişleten yeniden kullanılabilir modüller olan özel becerileri destekler.
### Beceri Tanımı
Beceriler bu yapı ile `~/.zeroclaw/workspace/skills/<skill-name>/` içinde saklanır:
```
skills/
└── my-skill/
├── skill.toml # Beceri metaverileri (ad, açıklama, bağımlılıklar)
├── prompt.md # AI için sistem istemi
└── tools/ # İsteğe bağlı özel araçlar
└── my_tool.py
```
### Beceri Örneği
```toml
# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Web'de arama yapar ve sonuçları özetler"
version = "1.0.0"
[dependencies]
tools = ["web_fetch", "bash"]
```
```markdown
<!-- skills/web-research/prompt.md -->
Sen bir araştırma asistanısın. Bir şeyi araştırmam istendiğinde:
1. İçeriği almak için web_fetch kullan
2. Sonuçları okunması kolay bir biçimde özetle
3. Kaynakları URL'lerle göster
```
### Beceri Kullanımı
Beceriler ajan başlangıcında otomatik olarak yüklenir. Konuşmalarda ada göre başvurun:
```
Kullanıcı: En son AI haberlerini bulmak için web-research becerisini kullan
Bot: [web-research becerisini yükler, web_fetch'i yürütür, sonuçları özetler]
```
Tam beceri oluşturma talimatları için [Beceriler](#beceriler) bölümüne bakın.
## Open Skills
ZeroClaw, AI ajan yeteneklerini genişletmek için modüler ve sağlayıcıdan bağımsız bir sistem olan [Open Skills](https://github.com/openagents-com/open-skills)'i destekler.
### Open Skills'i Etkinleştir
```toml
[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills" # isteğe bağlı
```
Ayrıca `ZEROCLAW_OPEN_SKILLS_ENABLED` ve `ZEROCLAW_OPEN_SKILLS_DIR` ile çalışma zamanında geçersiz kılabilirsiniz.
## Geliştirme
```bash
cargo build # Geliştirme derlemesi
cargo build --release # Sürüm derlemesi (codegen-units=1, Raspberry Pi dahil tüm cihazlarda çalışır)
cargo build --profile release-fast # Daha hızlı derleme (codegen-units=8, 16 GB+ RAM gerektirir)
cargo test # Tam test paketini çalıştır
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt # Biçimlendir
# SQLite vs Markdown karşılaştırma kıyaslamasını çalıştır
cargo test --test memory_comparison -- --nocapture
```
### Ön push kancası
Bir git kancası her push'tan önce `cargo fmt --check`, `cargo clippy -- -D warnings` ve `cargo test` çalıştırır. Bir kez etkinleştirin:
```bash
git config core.hooksPath .githooks
```
### Derleme Sorun Giderme (Linux'ta OpenSSL hataları)
Bir `openssl-sys` derleme hatasıyla karşılaşırsanız, bağımlılıkları eşzamanlayın ve deponun lockfile'ı ile yeniden derleyin:
```bash
git pull
cargo build --release --locked
cargo install --path . --force --locked
```
ZeroClaw, HTTP/TLS bağımlılıkları için `rustls` kullanacak şekilde yapılandırılmıştır; `--locked`, geçişli grafiği temiz ortamlarda deterministik tutar.
Geliştirme sırasında hızlı bir push'a ihtiyacınız olduğunda kancayı atlamak için:
```bash
git push --no-verify
```
## İşbirliği ve Belgeler
Görev tabanlı bir harita için belge merkeziyle başlayın:
- Belge Merkezi: [`docs/README.md`](docs/README.md)
- Birleşik Docs İçindekiler: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Komutlar Referansı: [`docs/commands-reference.md`](docs/commands-reference.md)
- Yapılandırma Referansı: [`docs/config-reference.md`](docs/config-reference.md)
- Sağlayıcı Referansı: [`docs/providers-reference.md`](docs/providers-reference.md)
- Kanallar Referansı: [`docs/channels-reference.md`](docs/channels-reference.md)
- Operasyonlar Runbook'u: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Sorun Giderme: [`docs/troubleshooting.md`](docs/troubleshooting.md)
- Docs Envanteri/Sınıflandırma: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- PR/Issue Triaj Anlık Görüntüsü (18 Şub. 2026 itibariyle): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
Ana işbirliği referansları:
- Belge Merkezi: [docs/README.md](docs/README.md)
- Belge Şablonu: [docs/doc-template.md](docs/doc-template.md)
- Belge Değişikliği Kontrol Listesi: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Kanal Yapılandırma Referansı: [docs/channels-reference.md](docs/channels-reference.md)
- Matrix Şifreli Oda Operasyonları: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Katkı Kılavuzu: [CONTRIBUTING.md](CONTRIBUTING.md)
- PR İş Akışı İlkesi: [docs/pr-workflow.md](docs/pr-workflow.md)
- Gözden Geçiren Playbook'u (triaj + derinlemesine gözden geçirme): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Sahiplik ve CI Triaj Haritası: [docs/ci-map.md](docs/ci-map.md)
- Güvenlik Açıklama İlkesi: [SECURITY.md](SECURITY.md)
Dağıtım ve çalışma zamanı operasyonları için:
- Ağ Dağıtımı Kılavuzu: [docs/network-deployment.md](docs/network-deployment.md)
- Proxy Agent Playbook'u: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
## ZeroClaw'ı Destekleyin
ZeroClaw işinize yardımcı oluyorsa ve sürekli geliştirmeyi desteklemek istiyorsanız, buradan bağış yapabilirsiniz:
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=for-the-badge&logo=buy-me-a-coffee" alt="Bana Bir Kahve Ismarla" /></a>
### 🙏 Özel Teşekkürler
Bu açık kaynak çalışmasını ilham veren ve besleyen topluluklara ve kurumlara içten teşekkürler:
- **Harvard Üniversitesi** — entelektüel merakı teşvik ettikleri ve mümkün olanın sınırlarını zorladıkları için.
- **MIT** — açık bilgiyi, açık kaynağı ve teknolojinin herkes için erişilebilir olması gerektiği inancını savundukları için.
- **Sundai Club** — topluluk, enerji ve önemli şeyler inşa etme konusundaki amansız irade için.
- **Dünya ve Ötesi** 🌍✨ — açık kaynağı iyi bir güç haline getiren her katılımcı, hayalper ve inşa edene. Bu senin için.
En iyi fikirler her yerden geldiği için açık kaynakta inşa ediyoruz. Bunu okuyorsan, bunun bir parçasısın. Hoş geldin. 🦀❤️
## ⚠️ Resmi Depo ve Taklit Uyarısı
**Bu tek resmi ZeroClaw deposudur:**
> <https://github.com/zeroclaw-labs/zeroclaw>
ZeroClaw olduğunu iddia eden veya ZeroClaw Labs ile bağlantıyı ima eden başka herhangi bir depo, organizasyon, etki alanı veya paket **yetkisizdir ve bu projeyle bağlantılı değildir**. Bilinen yetkisiz forklar [TRADEMARK.md](TRADEMARK.md)'da listelenecektir.
Taklit veya marka kötüye kullanımıyla karşılaşırsanız, lütfen [bir sorun açın](https://github.com/zeroclaw-labs/zeroclaw/issues).
---
## Lisans
ZeroClaw, maksimum açıklık ve katılımcı koruma için çift lisanslıdır:
| Lisans | Kullanım Durumları |
| ---------------------------- | ------------------------------------------------------------ |
| [MIT](LICENSE-MIT) | Açık kaynak, araştırma, akademik, kişisel kullanım |
| [Apache 2.0](LICENSE-APACHE) | Patent koruması, kurumsal, ticari dağıtım |
Lisanslardan birini seçebilirsiniz. **Katılımcılar otomatik olarak her ikisi altında da hak verir** — tam katılımcı anlaşması için [CLA.md](CLA.md)'ye bakın.
### Marka
**ZeroClaw** adı ve logosu, ZeroClaw Labs'ın tescilli markalarıdır. Bu lisans, onay veya bağlantı ima etmek için kullanım izni vermez. İzin verilen ve yasaklanan kullanımlar için [TRADEMARK.md](TRADEMARK.md)'e bakın.
### Katılımcı Korumaları
- Katkılarınızın **telif hakkını sizde tutarsınız**
- **Patent hibesi** (Apache 2.0) sizi diğer katılımcıların patent iddialarından korur
- Katkılarınız commit geçmişinde ve [NOTICE](NOTICE)'da **kalıcı olarak atfedilir**
- Katkıda bulunarak marka hakları devredilmez
## Katkıda Bulunma
[CONTRIBUTING.md](CONTRIBUTING.md) ve [CLA.md](CLA.md)'ye bakın. Bir trait uygulayın, bir PR gönderin:
- CI iş akışı kılavuzu: [docs/ci-map.md](docs/ci-map.md)
- Yeni `Provider``src/providers/`
- Yeni `Channel``src/channels/`
- Yeni `Observer``src/observability/`
- Yeni `Tool``src/tools/`
- Yeni `Memory``src/memory/`
- Yeni `Tunnel``src/tunnel/`
- Yeni `Skill``~/.zeroclaw/workspace/skills/<n>/`
---
**ZeroClaw** — Sıfır yük. Sıfır ödün. Her yerde dağıtın. Her şeyi değiştirin. 🦀
## Yıldız Geçmişi
<p align="center">
<a href="https://www.star-history.com/#zeroclaw-labs/zeroclaw&type=date&legend=top-left">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&theme=dark&legend=top-left" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
<img alt="Yıldız Geçmişi Grafiği" src="https://api.star-history.com/svg?repos=zeroclaw-labs/zeroclaw&type=date&legend=top-left" />
</picture>
</a>
</p>

179
README.uk.md Normal file
View File

@ -0,0 +1,179 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center">
<strong>Нуль накладних витрат. Нуль компромісів. 100% Rust. 100% Агностичний.</strong><br>
⚡️ <strong>Працює на $10 обладнанні з <5MB RAM: Це на 99% менше пам'яті ніж OpenClaw і на 98% дешевше ніж Mac mini!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center">
🌐 <strong>Мови:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## Що таке ZeroClaw?
ZeroClaw — це легка, змінювана та розширювана інфраструктура AI-асистента, написана на Rust. Вона з'єднує різних LLM-провайдерів (Anthropic, OpenAI, Google, Ollama тощо) через уніфікований інтерфейс і підтримує багато каналів (Telegram, Matrix, CLI тощо).
### Ключові особливості
- **🦀 Написано на Rust**: Висока продуктивність, безпека пам'яті та абстракції без накладних витрат
- **🔌 Агностичний до провайдерів**: Підтримка OpenAI, Anthropic, Google Gemini, Ollama та інших
- **📱 Багатоканальність**: Telegram, Matrix (з E2EE), CLI та інші
- **🧠 Плагінна пам'ять**: SQLite та Markdown бекенди
- **🛠️ Розширювані інструменти**: Легко додавайте власні інструменти
- **🔒 Безпека першочергово**: Зворотний проксі, дизайн з пріоритетом конфіденційності
---
## Швидкий старт
### Вимоги
- Rust 1.70+
- API-ключ LLM-провайдера (Anthropic, OpenAI тощо)
### Встановлення
```bash
# Клонуйте репозиторій
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# Зберіть проект
cargo build --release
# Запустіть
cargo run --release
```
### З Docker
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## Конфігурація
ZeroClaw використовує YAML-файл конфігурації. За замовчуванням він шукає `config.yaml`.
```yaml
# Провайдер за замовчуванням
provider: anthropic
# Конфігурація провайдерів
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# Конфігурація пам'яті
memory:
backend: sqlite
path: data/memory.db
# Конфігурація каналів
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## Документація
Для детальної документації дивіться:
- [Хаб документації](docs/README.md)
- [Довідник команд](docs/commands-reference.md)
- [Довідник провайдерів](docs/providers-reference.md)
- [Довідник каналів](docs/channels-reference.md)
- [Довідник конфігурації](docs/config-reference.md)
---
## Внесок
Внески вітаються! Будь ласка, прочитайте [Керівництво з внеску](CONTRIBUTING.md).
---
## Ліцензія
Цей проєкт має подвійну ліцензію:
- MIT License
- Apache License, версія 2.0
Дивіться [LICENSE-APACHE](LICENSE-APACHE) та [LICENSE-MIT](LICENSE-MIT) для деталей.
---
## Спільнота
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## Спонсори
Якщо ZeroClaw корисний для вас, будь ласка, розгляньте можливість купити нам каву:
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

197
README.ur.md Normal file
View File

@ -0,0 +1,197 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
<p align="center" dir="rtl">
<strong>صفر اوور ہیڈ۔ صفر سمجھوتہ۔ 100% رسٹ۔ 100% اگنوسٹک۔</strong><br>
⚡️ <strong>$10 کے ہارڈویئر پر <5MB RAM کے ساتھ چلتا ہے: یہ OpenClaw سے 99% کم میموری اور Mac mini سے 98% سستا ہے!</strong>
</p>
<p align="center">
<a href="LICENSE-APACHE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache%202.0-blue.svg" alt="License: MIT OR Apache-2.0" /></a>
<a href="NOTICE"><img src="https://img.shields.io/badge/contributors-27+-green.svg" alt="Contributors" /></a>
<a href="https://buymeacoffee.com/argenistherose"><img src="https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee" alt="Buy Me a Coffee" /></a>
<a href="https://x.com/zeroclawlabs?s=21"><img src="https://img.shields.io/badge/X-%40zeroclawlabs-000000?style=flat&logo=x&logoColor=white" alt="X: @zeroclawlabs" /></a>
<a href="https://zeroclawlabs.cn/group.jpg"><img src="https://img.shields.io/badge/WeChat-Group-B7D7A8?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
<a href="https://www.xiaohongshu.com/user/profile/67cbfc43000000000d008307?xsec_token=AB73VnYnGNx5y36EtnnZfGmAmS-6Wzv8WMuGpfwfkg6Yc%3D&xsec_source=pc_search"><img src="https://img.shields.io/badge/Xiaohongshu-Official-FF2442?style=flat" alt="Xiaohongshu: Official" /></a>
<a href="https://t.me/zeroclawlabs"><img src="https://img.shields.io/badge/Telegram-%40zeroclawlabs-26A5E4?style=flat&logo=telegram&logoColor=white" alt="Telegram: @zeroclawlabs" /></a>
<a href="https://www.facebook.com/groups/zeroclaw"><img src="https://img.shields.io/badge/Facebook-Group-1877F2?style=flat&logo=facebook&logoColor=white" alt="Facebook Group" /></a>
</p>
<p align="center" dir="rtl">
🌐 <strong>زبانیں:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
---
## ZeroClaw کیا ہے؟
<p align="center" dir="rtl">
ZeroClaw ایک ہلکا، قابل تبدیلی اور توسیع پذیر AI اسسٹنٹ انفراسٹرکچر ہے جو رسٹ میں بنایا گیا ہے۔ یہ مختلف LLM فراہم کنندگان (Anthropic, OpenAI, Google, Ollama, وغیرہ) کو ایک متحد انٹرفیس کے ذریعے جوڑتا ہے اور متعدد چینلز (Telegram, Matrix, CLI, وغیرہ) کی حمایت کرتا ہے۔
</p>
### اہم خصوصیات
<p align="center" dir="rtl">
- **🦀 رسٹ میں لکھا گیا**: اعلیٰ کارکردگی، میموری سیورٹی، اور بغیر لاگت کے ایبسٹریکشن
- **🔌 فراہم کنندہ-اگنوسٹک**: OpenAI, Anthropic, Google Gemini, Ollama, اور دیگر کی حمایت
- **📱 ملٹی چینل**: Telegram, Matrix (E2EE کے ساتھ), CLI, اور دیگر
- **🧠 پلگ ایبل میموری**: SQLite اور Markdown بیک اینڈ
- **🛠️ قابل توسیع ٹولز**: آسانی سے کسٹم ٹولز شامل کریں
- **🔒 سیورٹی فرسٹ**: ریورس پراکسی، پرائیویسی فرسٹ ڈیزائن
</p>
---
## فوری شروعات
### ضروریات
<p align="center" dir="rtl">
- Rust 1.70+
- ایک LLM فراہم کنندہ API کی (Anthropic, OpenAI, وغیرہ)
</p>
### انسٹالیشن
```bash
# ریپوزٹری کلون کریں
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
# بلڈ کریں
cargo build --release
# چلائیں
cargo run --release
```
### Docker کے ساتھ
```bash
docker run -d \
--name zeroclaw \
-e ANTHROPIC_API_KEY=your_key \
-v zeroclaw-data:/app/data \
zeroclaw/zeroclaw:latest
```
---
## کنفیگریشن
<p align="center" dir="rtl">
ZeroClaw ایک YAML کنفیگریشن فائل استعمال کرتا ہے۔ ڈیفالٹ طور پر، یہ `config.yaml` تلاش کرتا ہے۔
</p>
```yaml
# ڈیفالٹ فراہم کنندہ
provider: anthropic
# فراہم کنندگان کی کنفیگریشن
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20241022
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4o
# میموری کنفیگریشن
memory:
backend: sqlite
path: data/memory.db
# چینلز کی کنفیگریشن
channels:
telegram:
token: ${TELEGRAM_BOT_TOKEN}
```
---
## دستاویزات
<p align="center" dir="rtl">
تفصیلی دستاویزات کے لیے، دیکھیں:
</p>
- [دستاویزات ہب](docs/README.md)
- [کمانڈز ریفرنس](docs/commands-reference.md)
- [فراہم کنندگان ریفرنس](docs/providers-reference.md)
- [چینلز ریفرنس](docs/channels-reference.md)
- [کنفیگریشن ریفرنس](docs/config-reference.md)
---
## شراکت
<p align="center" dir="rtl">
شراکت کا خیرمقدم ہے! براہ کرم [شراکت گائیڈ](CONTRIBUTING.md) پڑھیں۔
</p>
---
## لائسنس
<p align="center" dir="rtl">
یہ پروجیکٹ ڈول لائسنس یافتہ ہے:
</p>
- MIT License
- Apache License, ورژن 2.0
<p align="center" dir="rtl">
تفصیلات کے لیے [LICENSE-APACHE](LICENSE-APACHE) اور [LICENSE-MIT](LICENSE-MIT) دیکھیں۔
</p>
---
## کمیونٹی
- [Telegram](https://t.me/zeroclawlabs)
- [Facebook Group](https://www.facebook.com/groups/zeroclaw)
- [WeChat Group](https://zeroclawlabs.cn/group.jpg)
---
## سپانسرز
<p align="center" dir="rtl">
اگر ZeroClaw آپ کے لیے مفید ہے، تو براہ کرم ہمیں کافی خریدنے پر غور کریں:
</p>
[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-Donate-yellow.svg?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/argenistherose)

View File

@ -1,5 +1,5 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
<img src="docs/assets/zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀</h1>
@ -25,12 +25,43 @@
</p>
<p align="center">
🌐 <strong>Ngôn ngữ:</strong> <a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.ru.md">Русский</a> · <a href="README.fr.md">Français</a> · <a href="README.vi.md">Tiếng Việt</a>
🌐 <strong>Ngôn ngữ:</strong>
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="#quick-start">Bắt đầu</a> |
<a href="bootstrap.sh">Cài đặt một lần bấm</a> |
<a href="install.sh">Cài đặt một lần bấm</a> |
<a href="docs/i18n/vi/README.md">Trung tâm tài liệu</a> |
<a href="docs/SUMMARY.md">Mục lục tài liệu</a>
</p>
@ -38,7 +69,7 @@
<p align="center">
<strong>Truy cập nhanh:</strong>
<a href="docs/reference/README.md">Tài liệu tham khảo</a> ·
<a href="docs/operations/README.md">Vận hành</a> ·
<a href="docs/ops/README.md">Vận hành</a> ·
<a href="docs/i18n/vi/troubleshooting.md">Khắc phục sự cố</a> ·
<a href="docs/security/README.md">Bảo mật</a> ·
<a href="docs/hardware/README.md">Phần cứng</a> ·
@ -95,7 +126,7 @@ Bảng này dành cho các thông báo quan trọng (thay đổi không tương
> Ghi chú: Kết quả ZeroClaw được đo trên release build sử dụng `/usr/bin/time -l`. OpenClaw yêu cầu runtime Node.js (thường thêm ~390MB bộ nhớ overhead), còn NanoBot yêu cầu runtime Python. PicoClaw và ZeroClaw là các static binary. Số RAM ở trên là bộ nhớ runtime; yêu cầu biên dịch lúc build-time sẽ cao hơn.
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw Comparison" width="800" />
<img src="docs/assets/zeroclaw-comparison.jpeg" alt="ZeroClaw vs OpenClaw Comparison" width="800" />
</p>
### Tự đo trên máy bạn
@ -174,7 +205,7 @@ Ví dụ mẫu (macOS arm64, đo ngày 18 tháng 2 năm 2026):
Hoặc bỏ qua các bước trên, cài hết mọi thứ (system deps, Rust, ZeroClaw) chỉ bằng một lệnh:
```bash
curl -LsSf https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/scripts/install.sh | bash
curl -LsSf https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/install.sh | bash
```
#### Yêu cầu tài nguyên biên dịch
@ -189,13 +220,13 @@ Việc build từ source đòi hỏi nhiều tài nguyên hơn so với chạy b
Nếu cấu hình máy thấp hơn mức tối thiểu, dùng binary có sẵn:
```bash
./bootstrap.sh --prefer-prebuilt
./install.sh --prefer-prebuilt
```
Chỉ cài từ binary, không quay lại build từ source:
```bash
./bootstrap.sh --prebuilt-only
./install.sh --prebuilt-only
```
### Tùy chọn (Linux/macOS)
@ -220,37 +251,37 @@ brew install zeroclaw
# Khuyến nghị: clone rồi chạy script bootstrap cục bộ
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
./bootstrap.sh
./install.sh
# Tùy chọn: cài đặt system dependencies + Rust trên máy mới
./bootstrap.sh --install-system-deps --install-rust
./install.sh --install-system-deps --install-rust
# Tùy chọn: ưu tiên binary dựng sẵn (khuyến nghị cho máy ít RAM/ít dung lượng đĩa)
./bootstrap.sh --prefer-prebuilt
./install.sh --prefer-prebuilt
# Tùy chọn: cài đặt chỉ từ binary (không fallback sang build source)
./bootstrap.sh --prebuilt-only
./install.sh --prebuilt-only
# Tùy chọn: chạy onboarding trong cùng luồng
./bootstrap.sh --onboard --api-key "sk-..." --provider openrouter [--model "openrouter/auto"]
./install.sh --onboard --api-key "sk-..." --provider openrouter [--model "openrouter/auto"]
# Tùy chọn: chạy bootstrap + onboarding hoàn toàn ở chế độ tương thích với Docker
./bootstrap.sh --docker
./install.sh --docker
# Tùy chọn: ép dùng Podman làm container CLI
ZEROCLAW_CONTAINER_CLI=podman ./bootstrap.sh --docker
ZEROCLAW_CONTAINER_CLI=podman ./install.sh --docker
# Tùy chọn: ở chế độ --docker, bỏ qua build image local và dùng tag local hoặc pull image fallback
./bootstrap.sh --docker --skip-build
./install.sh --docker --skip-build
```
Cài từ xa bằng một lệnh (nên xem trước nếu môi trường nhạy cảm về bảo mật):
```bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/scripts/bootstrap.sh | bash
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/install.sh | bash
```
Chi tiết: [`docs/one-click-bootstrap.md`](docs/one-click-bootstrap.md) (chế độ toolchain có thể yêu cầu `sudo` cho các gói hệ thống).
Chi tiết: [`docs/setup-guides/one-click-bootstrap.md`](docs/setup-guides/one-click-bootstrap.md) (chế độ toolchain có thể yêu cầu `sudo` cho các gói hệ thống).
### Binary có sẵn
@ -383,7 +414,7 @@ zeroclaw agent --provider anthropic -m "hello"
Mọi hệ thống con đều là **trait** — chỉ cần đổi cấu hình, không cần sửa code.
<p align="center">
<img src="docs/architecture.svg" alt="ZeroClaw Architecture" width="900" />
<img src="docs/assets/architecture.svg" alt="ZeroClaw Architecture" width="900" />
</p>
| Hệ thống con | Trait | Đi kèm sẵn | Mở rộng |
@ -482,7 +513,7 @@ Chính sách kiểm soát người gửi đã được thống nhất:
Mặc định an toàn, hạn chế tối đa rủi ro lộ thông tin.
Tài liệu tham khảo đầy đủ về cấu hình channel: [docs/channels-reference.md](docs/channels-reference.md).
Tài liệu tham khảo đầy đủ về cấu hình channel: [docs/reference/api/channels-reference.md](docs/reference/api/channels-reference.md).
Cài đặt được khuyến nghị (bảo mật + nhanh):
@ -734,7 +765,7 @@ api_key = "ollama_api_key_here"
### Endpoint provider tùy chỉnh
Cấu hình chi tiết cho endpoint tùy chỉnh tương thích OpenAI và Anthropic, xem [docs/custom-providers.md](docs/custom-providers.md).
Cấu hình chi tiết cho endpoint tùy chỉnh tương thích OpenAI và Anthropic, xem [docs/contributing/custom-providers.md](docs/contributing/custom-providers.md).
## Gói Python đi kèm (`zeroclaw-tools`)
@ -894,7 +925,7 @@ Xem [aieos.org](https://aieos.org) để có schema đầy đủ và ví dụ tr
| `hardware` | Lệnh khám phá/kiểm tra/thông tin USB |
| `peripheral` | Quản lý và flash thiết bị ngoại vi phần cứng |
Để có hướng dẫn lệnh theo tác vụ, xem [`docs/commands-reference.md`](docs/commands-reference.md).
Để có hướng dẫn lệnh theo tác vụ, xem [`docs/reference/cli/commands-reference.md`](docs/reference/cli/commands-reference.md).
### Opt-In Open-Skills
@ -956,30 +987,30 @@ Bắt đầu từ trung tâm tài liệu để có bản đồ theo tác vụ:
- Mục lục tài liệu thống nhất: [`docs/SUMMARY.md`](docs/SUMMARY.md)
- Tài liệu tham khảo lệnh: [`docs/i18n/vi/commands-reference.md`](docs/i18n/vi/commands-reference.md)
- Tài liệu tham khảo cấu hình: [`docs/i18n/vi/config-reference.md`](docs/i18n/vi/config-reference.md)
- Tài liệu tham khảo provider: [`docs/providers-reference.md`](docs/providers-reference.md)
- Tài liệu tham khảo channel: [`docs/channels-reference.md`](docs/channels-reference.md)
- Sổ tay vận hành: [`docs/operations-runbook.md`](docs/operations-runbook.md)
- Tài liệu tham khảo provider: [`docs/reference/api/providers-reference.md`](docs/reference/api/providers-reference.md)
- Tài liệu tham khảo channel: [`docs/reference/api/channels-reference.md`](docs/reference/api/channels-reference.md)
- Sổ tay vận hành: [`docs/ops/operations-runbook.md`](docs/ops/operations-runbook.md)
- Khắc phục sự cố: [`docs/i18n/vi/troubleshooting.md`](docs/i18n/vi/troubleshooting.md)
- Kiểm kê/phân loại tài liệu: [`docs/docs-inventory.md`](docs/docs-inventory.md)
- Tổng hợp phân loại PR/Issue (tính đến 18/2/2026): [`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
- Kiểm kê/phân loại tài liệu: [`docs/maintainers/docs-inventory.md`](docs/maintainers/docs-inventory.md)
- Tổng hợp phân loại PR/Issue (tính đến 18/2/2026): [`docs/maintainers/project-triage-snapshot-2026-02-18.md`](docs/maintainers/project-triage-snapshot-2026-02-18.md)
Tài liệu tham khảo cộng tác cốt lõi:
- Trung tâm tài liệu: [docs/i18n/vi/README.md](docs/i18n/vi/README.md)
- Template tài liệu: [docs/doc-template.md](docs/doc-template.md)
- Template tài liệu: [docs/contributing/doc-template.md](docs/contributing/doc-template.md)
- Danh sách kiểm tra thay đổi tài liệu: [docs/README.md#4-documentation-change-checklist](docs/README.md#4-documentation-change-checklist)
- Tài liệu tham khảo cấu hình channel: [docs/channels-reference.md](docs/channels-reference.md)
- Vận hành phòng mã hóa Matrix: [docs/matrix-e2ee-guide.md](docs/matrix-e2ee-guide.md)
- Tài liệu tham khảo cấu hình channel: [docs/reference/api/channels-reference.md](docs/reference/api/channels-reference.md)
- Vận hành phòng mã hóa Matrix: [docs/security/matrix-e2ee-guide.md](docs/security/matrix-e2ee-guide.md)
- Hướng dẫn đóng góp: [CONTRIBUTING.md](CONTRIBUTING.md)
- Chính sách quy trình PR: [docs/pr-workflow.md](docs/pr-workflow.md)
- Sổ tay người review (phân loại + review sâu): [docs/reviewer-playbook.md](docs/reviewer-playbook.md)
- Bản đồ sở hữu và phân loại CI: [docs/ci-map.md](docs/ci-map.md)
- Chính sách quy trình PR: [docs/contributing/pr-workflow.md](docs/contributing/pr-workflow.md)
- Sổ tay người review (phân loại + review sâu): [docs/contributing/reviewer-playbook.md](docs/contributing/reviewer-playbook.md)
- Bản đồ sở hữu và phân loại CI: [docs/contributing/ci-map.md](docs/contributing/ci-map.md)
- Chính sách tiết lộ bảo mật: [SECURITY.md](SECURITY.md)
Cho triển khai và vận hành runtime:
- Hướng dẫn triển khai mạng: [docs/network-deployment.md](docs/network-deployment.md)
- Sổ tay proxy agent: [docs/proxy-agent-playbook.md](docs/proxy-agent-playbook.md)
- Hướng dẫn triển khai mạng: [docs/ops/network-deployment.md](docs/ops/network-deployment.md)
- Sổ tay proxy agent: [docs/ops/proxy-agent-playbook.md](docs/ops/proxy-agent-playbook.md)
## Ủng hộ ZeroClaw
@ -1003,7 +1034,7 @@ Chúng tôi xây dựng công khai vì ý tưởng hay đến từ khắp nơi.
**Đây là repository ZeroClaw chính thức duy nhất:**
> <https://github.com/zeroclaw-labs/zeroclaw>
Bất kỳ repository, tổ chức, tên miền hay gói nào khác tuyên bố là "ZeroClaw" hoặc ngụ ý liên kết với ZeroClaw Labs đều là **không được ủy quyền và không liên kết với dự án này**. Các fork không được ủy quyền đã biết sẽ được liệt kê trong [TRADEMARK.md](TRADEMARK.md).
Bất kỳ repository, tổ chức, tên miền hay gói nào khác tuyên bố là "ZeroClaw" hoặc ngụ ý liên kết với ZeroClaw Labs đều là **không được ủy quyền và không liên kết với dự án này**. Các fork không được ủy quyền đã biết sẽ được liệt kê trong [TRADEMARK.md](docs/maintainers/trademark.md).
Nếu bạn phát hiện hành vi mạo danh hoặc lạm dụng nhãn hiệu, vui lòng [mở một issue](https://github.com/zeroclaw-labs/zeroclaw/issues).
@ -1018,11 +1049,11 @@ ZeroClaw được cấp phép kép để tối đa hóa tính mở và bảo v
| [MIT](LICENSE-MIT) | Mã nguồn mở, nghiên cứu, học thuật, sử dụng cá nhân |
| [Apache 2.0](LICENSE-APACHE) | Bảo hộ bằng sáng chế, triển khai tổ chức, thương mại |
Bạn có thể chọn một trong hai giấy phép. **Người đóng góp tự động cấp quyền theo cả hai** — xem [CLA.md](CLA.md) để biết thỏa thuận đóng góp đầy đủ.
Bạn có thể chọn một trong hai giấy phép. **Người đóng góp tự động cấp quyền theo cả hai** — xem [CLA.md](docs/contributing/cla.md) để biết thỏa thuận đóng góp đầy đủ.
### Nhãn hiệu
Tên **ZeroClaw** và logo là nhãn hiệu của ZeroClaw Labs. Giấy phép này không cấp phép sử dụng chúng để ngụ ý chứng thực hoặc liên kết. Xem [TRADEMARK.md](TRADEMARK.md) để biết các sử dụng được phép và bị cấm.
Tên **ZeroClaw** và logo là nhãn hiệu của ZeroClaw Labs. Giấy phép này không cấp phép sử dụng chúng để ngụ ý chứng thực hoặc liên kết. Xem [TRADEMARK.md](docs/maintainers/trademark.md) để biết các sử dụng được phép và bị cấm.
### Bảo vệ người đóng góp
@ -1033,8 +1064,8 @@ Tên **ZeroClaw** và logo là nhãn hiệu của ZeroClaw Labs. Giấy phép n
## Đóng góp
Xem [CONTRIBUTING.md](CONTRIBUTING.md) và [CLA.md](CLA.md). Triển khai một trait, gửi PR:
- Hướng dẫn quy trình CI: [docs/ci-map.md](docs/ci-map.md)
Xem [CONTRIBUTING.md](CONTRIBUTING.md) và [CLA.md](docs/contributing/cla.md). Triển khai một trait, gửi PR:
- Hướng dẫn quy trình CI: [docs/contributing/ci-map.md](docs/contributing/ci-map.md)
- `Provider` mới → `src/providers/`
- `Channel` mới → `src/channels/`
- `Observer` mới → `src/observability/`

View File

@ -1,5 +1,5 @@
<p align="center">
<img src="zeroclaw.png" alt="ZeroClaw" width="200" />
<img src="docs/assets/zeroclaw.png" alt="ZeroClaw" width="200" />
</p>
<h1 align="center">ZeroClaw 🦀(简体中文)</h1>
@ -21,12 +21,43 @@
</p>
<p align="center">
🌐 语言:<a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.ru.md">Русский</a> · <a href="README.fr.md">Français</a> · <a href="README.vi.md">Tiếng Việt</a>
🌐 语言:
<a href="README.md">🇺🇸 English</a> ·
<a href="README.zh-CN.md">🇨🇳 简体中文</a> ·
<a href="README.ja.md">🇯🇵 日本語</a> ·
<a href="README.ko.md">🇰🇷 한국어</a> ·
<a href="README.vi.md">🇻🇳 Tiếng Việt</a> ·
<a href="README.tl.md">🇵🇭 Tagalog</a> ·
<a href="README.es.md">🇪🇸 Español</a> ·
<a href="README.pt.md">🇧🇷 Português</a> ·
<a href="README.it.md">🇮🇹 Italiano</a> ·
<a href="README.de.md">🇩🇪 Deutsch</a> ·
<a href="README.fr.md">🇫🇷 Français</a> ·
<a href="README.ar.md">🇸🇦 العربية</a> ·
<a href="README.hi.md">🇮🇳 हिन्दी</a> ·
<a href="README.ru.md">🇷🇺 Русский</a> ·
<a href="README.bn.md">🇧🇩 বাংলা</a> ·
<a href="README.he.md">🇮🇱 עברית</a> ·
<a href="README.pl.md">🇵🇱 Polski</a> ·
<a href="README.cs.md">🇨🇿 Čeština</a> ·
<a href="README.nl.md">🇳🇱 Nederlands</a> ·
<a href="README.tr.md">🇹🇷 Türkçe</a> ·
<a href="README.uk.md">🇺🇦 Українська</a> ·
<a href="README.id.md">🇮🇩 Bahasa Indonesia</a> ·
<a href="README.th.md">🇹🇭 ไทย</a> ·
<a href="README.ur.md">🇵🇰 اردو</a> ·
<a href="README.ro.md">🇷🇴 Română</a> ·
<a href="README.sv.md">🇸🇪 Svenska</a> ·
<a href="README.el.md">🇬🇷 Ελληνικά</a> ·
<a href="README.hu.md">🇭🇺 Magyar</a> ·
<a href="README.fi.md">🇫🇮 Suomi</a> ·
<a href="README.da.md">🇩🇰 Dansk</a> ·
<a href="README.nb.md">🇳🇴 Norsk</a>
</p>
<p align="center">
<a href="bootstrap.sh">一键部署</a> |
<a href="docs/getting-started/README.md">安装入门</a> |
<a href="install.sh">一键部署</a> |
<a href="docs/setup-guides/README.md">安装入门</a> |
<a href="docs/README.zh-CN.md">文档总览</a> |
<a href="docs/SUMMARY.md">文档目录</a>
</p>
@ -34,8 +65,8 @@
<p align="center">
<strong>场景分流:</strong>
<a href="docs/reference/README.md">参考手册</a> ·
<a href="docs/operations/README.md">运维部署</a> ·
<a href="docs/troubleshooting.md">故障排查</a> ·
<a href="docs/ops/README.md">运维部署</a> ·
<a href="docs/ops/troubleshooting.md">故障排查</a> ·
<a href="docs/security/README.md">安全专题</a> ·
<a href="docs/hardware/README.md">硬件外设</a> ·
<a href="docs/contributing/README.md">贡献与 CI</a>
@ -87,7 +118,7 @@ ZeroClaw 是一个高性能、低资源占用、可组合的自主智能体运
> 说明ZeroClaw 的数据来自 release 构建,并通过 `/usr/bin/time -l` 测得。OpenClaw 需要 Node.js 运行时环境,仅该运行时通常就会带来约 390MB 的额外内存占用NanoBot 需要 Python 运行时环境。PicoClaw 与 ZeroClaw 为静态二进制。
<p align="center">
<img src="zero-claw.jpeg" alt="ZeroClaw vs OpenClaw 对比图" width="800" />
<img src="docs/assets/zeroclaw-comparison.jpeg" alt="ZeroClaw vs OpenClaw 对比图" width="800" />
</p>
### 本地可复现测量
@ -113,12 +144,12 @@ ls -lh target/release/zeroclaw
```bash
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
./bootstrap.sh
./install.sh
```
可选环境初始化:`./bootstrap.sh --install-system-deps --install-rust`(可能需要 `sudo`)。
可选环境初始化:`./install.sh --install-system-deps --install-rust`(可能需要 `sudo`)。
详细说明见:[`docs/one-click-bootstrap.md`](docs/one-click-bootstrap.md)。
详细说明见:[`docs/setup-guides/one-click-bootstrap.md`](docs/setup-guides/one-click-bootstrap.md)。
## 快速开始
@ -200,7 +231,7 @@ zeroclaw agent --provider anthropic -m "hello"
每个子系统都是一个 **Trait** — 通过配置切换即可更换实现,无需修改代码。
<p align="center">
<img src="docs/architecture.svg" alt="ZeroClaw 架构图" width="900" />
<img src="docs/assets/architecture.svg" alt="ZeroClaw 架构图" width="900" />
</p>
| 子系统 | Trait | 内置实现 | 扩展方式 |
@ -284,20 +315,20 @@ allow_public_bind = false
- 文档总览(英文):[`docs/README.md`](docs/README.md)
- 统一目录TOC[`docs/SUMMARY.md`](docs/SUMMARY.md)
- 文档总览(简体中文):[`docs/README.zh-CN.md`](docs/README.zh-CN.md)
- 命令参考:[`docs/commands-reference.md`](docs/commands-reference.md)
- 配置参考:[`docs/config-reference.md`](docs/config-reference.md)
- Provider 参考:[`docs/providers-reference.md`](docs/providers-reference.md)
- Channel 参考:[`docs/channels-reference.md`](docs/channels-reference.md)
- 运维手册:[`docs/operations-runbook.md`](docs/operations-runbook.md)
- 故障排查:[`docs/troubleshooting.md`](docs/troubleshooting.md)
- 文档清单与分类:[`docs/docs-inventory.md`](docs/docs-inventory.md)
- 项目 triage 快照2026-02-18[`docs/project-triage-snapshot-2026-02-18.md`](docs/project-triage-snapshot-2026-02-18.md)
- 命令参考:[`docs/reference/cli/commands-reference.md`](docs/reference/cli/commands-reference.md)
- 配置参考:[`docs/reference/api/config-reference.md`](docs/reference/api/config-reference.md)
- Provider 参考:[`docs/reference/api/providers-reference.md`](docs/reference/api/providers-reference.md)
- Channel 参考:[`docs/reference/api/channels-reference.md`](docs/reference/api/channels-reference.md)
- 运维手册:[`docs/ops/operations-runbook.md`](docs/ops/operations-runbook.md)
- 故障排查:[`docs/ops/troubleshooting.md`](docs/ops/troubleshooting.md)
- 文档清单与分类:[`docs/maintainers/docs-inventory.md`](docs/maintainers/docs-inventory.md)
- 项目 triage 快照2026-02-18[`docs/maintainers/project-triage-snapshot-2026-02-18.md`](docs/maintainers/project-triage-snapshot-2026-02-18.md)
## 贡献与许可证
- 贡献指南:[`CONTRIBUTING.md`](CONTRIBUTING.md)
- PR 工作流:[`docs/pr-workflow.md`](docs/pr-workflow.md)
- Reviewer 指南:[`docs/reviewer-playbook.md`](docs/reviewer-playbook.md)
- PR 工作流:[`docs/contributing/pr-workflow.md`](docs/contributing/pr-workflow.md)
- Reviewer 指南:[`docs/contributing/reviewer-playbook.md`](docs/contributing/reviewer-playbook.md)
- 许可证MIT 或 Apache 2.0(见 [`LICENSE-MIT`](LICENSE-MIT)、[`LICENSE-APACHE`](LICENSE-APACHE) 与 [`NOTICE`](NOTICE)
---

View File

@ -13,7 +13,7 @@
Instead, please report them responsibly:
1. **Email**: Send details to the maintainers via GitHub private vulnerability reporting
2. **GitHub**: Use [GitHub Security Advisories](https://github.com/theonlyhennygod/zeroclaw/security/advisories/new)
2. **GitHub**: Use [GitHub Security Advisories](https://github.com/zeroclaw-labs/zeroclaw/security/advisories/new)
### What to Include
@ -87,7 +87,7 @@ docker run --read-only -v /path/to/workspace:/workspace zeroclaw gateway
### CI Enforcement
The `docker` job in `.github/workflows/ci.yml` automatically verifies:
The `docker` job in `.github/workflows/checks-on-pr.yml` automatically verifies:
1. Container does not run as root (UID 0)
2. Runtime stage uses `:nonroot` variant
3. Explicit `USER` directive with numeric UID exists

View File

@ -1,5 +0,0 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" >/dev/null 2>&1 && pwd || pwd)"
exec "$ROOT_DIR/zeroclaw_install.sh" "$@"

View File

@ -171,7 +171,7 @@ sudo usermod -aG dialout $USER
```bash
# Clone repo (or copy from USB)
git clone https://github.com/theonlyhennygod/zeroclaw
git clone https://github.com/zeroclaw-labs/zeroclaw
cd zeroclaw
# Build robot kit

View File

@ -11,24 +11,24 @@ Hubs localisés : [简体中文](README.zh-CN.md) · [日本語](README.ja.md)
| Je veux… | Lire ceci |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Installer et exécuter ZeroClaw rapidement | [README.md (Démarrage Rapide)](../README.md#quick-start) |
| Bootstrap en une seule commande | [one-click-bootstrap.md](one-click-bootstrap.md) |
| Trouver des commandes par tâche | [commands-reference.md](commands-reference.md) |
| Vérifier rapidement les valeurs par défaut et clés de config | [config-reference.md](config-reference.md) |
| Configurer des fournisseurs/endpoints personnalisés | [custom-providers.md](custom-providers.md) |
| Configurer le fournisseur Z.AI / GLM | [zai-glm-setup.md](zai-glm-setup.md) |
| Utiliser les modèles d'intégration LangGraph | [langgraph-integration.md](langgraph-integration.md) |
| Opérer le runtime (runbook jour-2) | [operations-runbook.md](operations-runbook.md) |
| Dépanner les problèmes d'installation/runtime/canal | [troubleshooting.md](troubleshooting.md) |
| Exécuter la configuration et diagnostics de salles chiffrées Matrix | [matrix-e2ee-guide.md](matrix-e2ee-guide.md) |
| Bootstrap en une seule commande | [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md) |
| Trouver des commandes par tâche | [commands-reference.md](reference/cli/commands-reference.md) |
| Vérifier rapidement les valeurs par défaut et clés de config | [config-reference.md](reference/api/config-reference.md) |
| Configurer des fournisseurs/endpoints personnalisés | [custom-providers.md](contributing/custom-providers.md) |
| Configurer le fournisseur Z.AI / GLM | [zai-glm-setup.md](setup-guides/zai-glm-setup.md) |
| Utiliser les modèles d'intégration LangGraph | [langgraph-integration.md](contributing/langgraph-integration.md) |
| Opérer le runtime (runbook jour-2) | [operations-runbook.md](ops/operations-runbook.md) |
| Dépanner les problèmes d'installation/runtime/canal | [troubleshooting.md](ops/troubleshooting.md) |
| Exécuter la configuration et diagnostics de salles chiffrées Matrix | [matrix-e2ee-guide.md](security/matrix-e2ee-guide.md) |
| Parcourir les docs par catégorie | [SUMMARY.md](SUMMARY.md) |
| Voir l'instantané docs des PR/issues du projet | [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md) |
| Voir l'instantané docs des PR/issues du projet | [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md) |
## Arbre de Décision Rapide (10 secondes)
- Besoin de configuration ou installation initiale ? → [getting-started/README.md](getting-started/README.md)
- Besoin de configuration ou installation initiale ? → [setup-guides/README.md](setup-guides/README.md)
- Besoin de clés CLI/config exactes ? → [reference/README.md](reference/README.md)
- Besoin d'opérations de production/service ? → [operations/README.md](operations/README.md)
- Vous voyez des échecs ou régressions ? → [troubleshooting.md](troubleshooting.md)
- Besoin d'opérations de production/service ? → [ops/README.md](ops/README.md)
- Vous voyez des échecs ou régressions ? → [troubleshooting.md](ops/troubleshooting.md)
- Vous travaillez sur le durcissement sécurité ou la roadmap ? → [security/README.md](security/README.md)
- Vous travaillez avec des cartes/périphériques ? → [hardware/README.md](hardware/README.md)
- Contribution/revue/workflow CI ? → [contributing/README.md](contributing/README.md)
@ -36,55 +36,55 @@ Hubs localisés : [简体中文](README.zh-CN.md) · [日本語](README.ja.md)
## Collections (Recommandées)
- Démarrage : [getting-started/README.md](getting-started/README.md)
- Démarrage : [setup-guides/README.md](setup-guides/README.md)
- Catalogues de référence : [reference/README.md](reference/README.md)
- Opérations & déploiement : [operations/README.md](operations/README.md)
- Opérations & déploiement : [ops/README.md](ops/README.md)
- Docs sécurité : [security/README.md](security/README.md)
- Matériel/périphériques : [hardware/README.md](hardware/README.md)
- Contribution/CI : [contributing/README.md](contributing/README.md)
- Instantanés projet : [project/README.md](project/README.md)
- Instantanés projet : [maintainers/README.md](maintainers/README.md)
## Par Audience
### Utilisateurs / Opérateurs
- [commands-reference.md](commands-reference.md) — recherche de commandes par workflow
- [providers-reference.md](providers-reference.md) — IDs fournisseurs, alias, variables d'environnement d'identifiants
- [channels-reference.md](channels-reference.md) — capacités des canaux et chemins de configuration
- [matrix-e2ee-guide.md](matrix-e2ee-guide.md) — configuration de salles chiffrées Matrix (E2EE) et diagnostics de non-réponse
- [config-reference.md](config-reference.md) — clés de configuration à haute signalisation et valeurs par défaut sécurisées
- [custom-providers.md](custom-providers.md) — modèles d'intégration de fournisseur personnalisé/URL de base
- [zai-glm-setup.md](zai-glm-setup.md) — configuration Z.AI/GLM et matrice d'endpoints
- [langgraph-integration.md](langgraph-integration.md) — intégration de secours pour les cas limites de modèle/appel d'outil
- [operations-runbook.md](operations-runbook.md) — opérations runtime jour-2 et flux de rollback
- [troubleshooting.md](troubleshooting.md) — signatures d'échec courantes et étapes de récupération
- [commands-reference.md](reference/cli/commands-reference.md) — recherche de commandes par workflow
- [providers-reference.md](reference/api/providers-reference.md) — IDs fournisseurs, alias, variables d'environnement d'identifiants
- [channels-reference.md](reference/api/channels-reference.md) — capacités des canaux et chemins de configuration
- [matrix-e2ee-guide.md](security/matrix-e2ee-guide.md) — configuration de salles chiffrées Matrix (E2EE) et diagnostics de non-réponse
- [config-reference.md](reference/api/config-reference.md) — clés de configuration à haute signalisation et valeurs par défaut sécurisées
- [custom-providers.md](contributing/custom-providers.md) — modèles d'intégration de fournisseur personnalisé/URL de base
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md) — configuration Z.AI/GLM et matrice d'endpoints
- [langgraph-integration.md](contributing/langgraph-integration.md) — intégration de secours pour les cas limites de modèle/appel d'outil
- [operations-runbook.md](ops/operations-runbook.md) — opérations runtime jour-2 et flux de rollback
- [troubleshooting.md](ops/troubleshooting.md) — signatures d'échec courantes et étapes de récupération
### Contributeurs / Mainteneurs
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### Sécurité / Fiabilité
> Note : cette zone inclut des docs de proposition/roadmap. Pour le comportement actuel, commencez par [config-reference.md](config-reference.md), [operations-runbook.md](operations-runbook.md), et [troubleshooting.md](troubleshooting.md).
> Note : cette zone inclut des docs de proposition/roadmap. Pour le comportement actuel, commencez par [config-reference.md](reference/api/config-reference.md), [operations-runbook.md](ops/operations-runbook.md), et [troubleshooting.md](ops/troubleshooting.md).
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [audit-logging.md](audit-logging.md)
- [resource-limits.md](resource-limits.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [audit-logging.md](security/audit-logging.md)
- [resource-limits.md](ops/resource-limits.md)
- [security-roadmap.md](security/security-roadmap.md)
## Navigation Système & Gouvernance
- Table des matières unifiée : [SUMMARY.md](SUMMARY.md)
- Carte de structure docs (langue/partie/fonction) : [structure/README.md](structure/README.md)
- Inventaire/classification de la documentation : [docs-inventory.md](docs-inventory.md)
- Instantané de triage du projet : [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md)
- Carte de structure docs (langue/partie/fonction) : [structure/README.md](maintainers/structure-README.md)
- Inventaire/classification de la documentation : [docs-inventory.md](maintainers/docs-inventory.md)
- Instantané de triage du projet : [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md)
## Autres langues

View File

@ -11,23 +11,23 @@
| やりたいこと | 参照先 |
|---|---|
| すぐにセットアップしたい | [../README.ja.md](../README.ja.md) / [../README.md](../README.md) |
| ワンコマンドで導入したい | [one-click-bootstrap.md](one-click-bootstrap.md) |
| コマンドを用途別に確認したい | [commands-reference.md](commands-reference.md) |
| 設定キーと既定値を確認したい | [config-reference.md](config-reference.md) |
| カスタム Provider / endpoint を追加したい | [custom-providers.md](custom-providers.md) |
| Z.AI / GLM Provider を設定したい | [zai-glm-setup.md](zai-glm-setup.md) |
| LangGraph ツール連携を使いたい | [langgraph-integration.md](langgraph-integration.md) |
| 日常運用runbookを確認したい | [operations-runbook.md](operations-runbook.md) |
| インストール/実行トラブルを解決したい | [troubleshooting.md](troubleshooting.md) |
| ワンコマンドで導入したい | [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md) |
| コマンドを用途別に確認したい | [commands-reference.md](reference/cli/commands-reference.md) |
| 設定キーと既定値を確認したい | [config-reference.md](reference/api/config-reference.md) |
| カスタム Provider / endpoint を追加したい | [custom-providers.md](contributing/custom-providers.md) |
| Z.AI / GLM Provider を設定したい | [zai-glm-setup.md](setup-guides/zai-glm-setup.md) |
| LangGraph ツール連携を使いたい | [langgraph-integration.md](contributing/langgraph-integration.md) |
| 日常運用runbookを確認したい | [operations-runbook.md](ops/operations-runbook.md) |
| インストール/実行トラブルを解決したい | [troubleshooting.md](ops/troubleshooting.md) |
| 統合 TOC から探したい | [SUMMARY.md](SUMMARY.md) |
| PR/Issue の現状を把握したい | [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md) |
| PR/Issue の現状を把握したい | [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md) |
## 10秒ルーティングまずここ
- 初回セットアップや導入をしたい → [getting-started/README.md](getting-started/README.md)
- 初回セットアップや導入をしたい → [setup-guides/README.md](setup-guides/README.md)
- CLI/設定キーを正確に確認したい → [reference/README.md](reference/README.md)
- 本番運用やサービス管理をしたい → [operations/README.md](operations/README.md)
- エラーや不具合を解消したい → [troubleshooting.md](troubleshooting.md)
- 本番運用やサービス管理をしたい → [ops/README.md](ops/README.md)
- エラーや不具合を解消したい → [troubleshooting.md](ops/troubleshooting.md)
- セキュリティ方針やロードマップを見たい → [security/README.md](security/README.md)
- ボード/周辺機器を扱いたい → [hardware/README.md](hardware/README.md)
- 貢献・レビュー・CIを確認したい → [contributing/README.md](contributing/README.md)
@ -35,53 +35,53 @@
## カテゴリ別ナビゲーション(推奨)
- 入門: [getting-started/README.md](getting-started/README.md)
- 入門: [setup-guides/README.md](setup-guides/README.md)
- リファレンス: [reference/README.md](reference/README.md)
- 運用 / デプロイ: [operations/README.md](operations/README.md)
- 運用 / デプロイ: [ops/README.md](ops/README.md)
- セキュリティ: [security/README.md](security/README.md)
- ハードウェア: [hardware/README.md](hardware/README.md)
- コントリビュート / CI: [contributing/README.md](contributing/README.md)
- プロジェクトスナップショット: [project/README.md](project/README.md)
- プロジェクトスナップショット: [maintainers/README.md](maintainers/README.md)
## ロール別
### ユーザー / オペレーター
- [commands-reference.md](commands-reference.md)
- [providers-reference.md](providers-reference.md)
- [channels-reference.md](channels-reference.md)
- [config-reference.md](config-reference.md)
- [custom-providers.md](custom-providers.md)
- [zai-glm-setup.md](zai-glm-setup.md)
- [langgraph-integration.md](langgraph-integration.md)
- [operations-runbook.md](operations-runbook.md)
- [troubleshooting.md](troubleshooting.md)
- [commands-reference.md](reference/cli/commands-reference.md)
- [providers-reference.md](reference/api/providers-reference.md)
- [channels-reference.md](reference/api/channels-reference.md)
- [config-reference.md](reference/api/config-reference.md)
- [custom-providers.md](contributing/custom-providers.md)
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md)
- [langgraph-integration.md](contributing/langgraph-integration.md)
- [operations-runbook.md](ops/operations-runbook.md)
- [troubleshooting.md](ops/troubleshooting.md)
### コントリビューター / メンテナー
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### セキュリティ / 信頼性
> 注: このセクションには proposal/roadmap 文書が含まれ、想定段階のコマンドや設定が記載される場合があります。現行動作は [config-reference.md](config-reference.md)、[operations-runbook.md](operations-runbook.md)、[troubleshooting.md](troubleshooting.md) を優先してください。
> 注: このセクションには proposal/roadmap 文書が含まれ、想定段階のコマンドや設定が記載される場合があります。現行動作は [config-reference.md](reference/api/config-reference.md)、[operations-runbook.md](ops/operations-runbook.md)、[troubleshooting.md](ops/troubleshooting.md) を優先してください。
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [resource-limits.md](resource-limits.md)
- [audit-logging.md](audit-logging.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [resource-limits.md](ops/resource-limits.md)
- [audit-logging.md](security/audit-logging.md)
- [security-roadmap.md](security/security-roadmap.md)
## ドキュメント運用 / 分類
- 統合 TOC: [SUMMARY.md](SUMMARY.md)
- ドキュメント構造マップ(言語/カテゴリ/機能): [structure/README.md](structure/README.md)
- ドキュメント一覧 / 分類: [docs-inventory.md](docs-inventory.md)
- ドキュメント構造マップ(言語/カテゴリ/機能): [structure/README.md](maintainers/structure-README.md)
- ドキュメント一覧 / 分類: [docs-inventory.md](maintainers/docs-inventory.md)
## 他言語

View File

@ -11,25 +11,25 @@ Localized hubs: [简体中文](README.zh-CN.md) · [日本語](README.ja.md) ·
| I want to… | Read this |
|---|---|
| Install and run ZeroClaw quickly | [README.md (Quick Start)](../README.md#quick-start) |
| Bootstrap in one command | [one-click-bootstrap.md](one-click-bootstrap.md) |
| Update or uninstall on macOS | [getting-started/macos-update-uninstall.md](getting-started/macos-update-uninstall.md) |
| Find commands by task | [commands-reference.md](commands-reference.md) |
| Check config defaults and keys quickly | [config-reference.md](config-reference.md) |
| Configure custom providers/endpoints | [custom-providers.md](custom-providers.md) |
| Configure Z.AI / GLM provider | [zai-glm-setup.md](zai-glm-setup.md) |
| Use LangGraph integration patterns | [langgraph-integration.md](langgraph-integration.md) |
| Operate runtime (day-2 runbook) | [operations-runbook.md](operations-runbook.md) |
| Troubleshoot install/runtime/channel issues | [troubleshooting.md](troubleshooting.md) |
| Run Matrix encrypted-room setup and diagnostics | [matrix-e2ee-guide.md](matrix-e2ee-guide.md) |
| Bootstrap in one command | [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md) |
| Update or uninstall on macOS | [macos-update-uninstall.md](setup-guides/macos-update-uninstall.md) |
| Find commands by task | [commands-reference.md](reference/cli/commands-reference.md) |
| Check config defaults and keys quickly | [config-reference.md](reference/api/config-reference.md) |
| Configure custom providers/endpoints | [custom-providers.md](contributing/custom-providers.md) |
| Configure Z.AI / GLM provider | [zai-glm-setup.md](setup-guides/zai-glm-setup.md) |
| Use LangGraph integration patterns | [langgraph-integration.md](contributing/langgraph-integration.md) |
| Operate runtime (day-2 runbook) | [operations-runbook.md](ops/operations-runbook.md) |
| Troubleshoot install/runtime/channel issues | [troubleshooting.md](ops/troubleshooting.md) |
| Run Matrix encrypted-room setup and diagnostics | [matrix-e2ee-guide.md](security/matrix-e2ee-guide.md) |
| Browse docs by category | [SUMMARY.md](SUMMARY.md) |
| See project PR/issue docs snapshot | [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md) |
| See project PR/issue docs snapshot | [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md) |
## Quick Decision Tree (10 seconds)
- Need first-time setup or install? → [getting-started/README.md](getting-started/README.md)
- Need first-time setup or install? → [setup-guides/README.md](setup-guides/README.md)
- Need exact CLI/config keys? → [reference/README.md](reference/README.md)
- Need production/service operations? → [operations/README.md](operations/README.md)
- Seeing failures or regressions? → [troubleshooting.md](troubleshooting.md)
- Need production/service operations? → [ops/README.md](ops/README.md)
- Seeing failures or regressions? → [troubleshooting.md](ops/troubleshooting.md)
- Working on security hardening or roadmap? → [security/README.md](security/README.md)
- Working with boards/peripherals? → [hardware/README.md](hardware/README.md)
- Contributing/reviewing/CI workflow? → [contributing/README.md](contributing/README.md)
@ -37,54 +37,54 @@ Localized hubs: [简体中文](README.zh-CN.md) · [日本語](README.ja.md) ·
## Collections (Recommended)
- Getting started: [getting-started/README.md](getting-started/README.md)
- Getting started: [setup-guides/README.md](setup-guides/README.md)
- Reference catalogs: [reference/README.md](reference/README.md)
- Operations & deployment: [operations/README.md](operations/README.md)
- Operations & deployment: [ops/README.md](ops/README.md)
- Security docs: [security/README.md](security/README.md)
- Hardware/peripherals: [hardware/README.md](hardware/README.md)
- Contributing/CI: [contributing/README.md](contributing/README.md)
- Project snapshots: [project/README.md](project/README.md)
- Project snapshots: [maintainers/README.md](maintainers/README.md)
## By Audience
### Users / Operators
- [commands-reference.md](commands-reference.md) — command lookup by workflow
- [providers-reference.md](providers-reference.md) — provider IDs, aliases, credential env vars
- [channels-reference.md](channels-reference.md) — channel capabilities and setup paths
- [matrix-e2ee-guide.md](matrix-e2ee-guide.md) — Matrix encrypted-room (E2EE) setup and no-response diagnostics
- [config-reference.md](config-reference.md) — high-signal config keys and secure defaults
- [custom-providers.md](custom-providers.md) — custom provider/base URL integration templates
- [zai-glm-setup.md](zai-glm-setup.md) — Z.AI/GLM setup and endpoint matrix
- [langgraph-integration.md](langgraph-integration.md) — fallback integration for model/tool-calling edge cases
- [operations-runbook.md](operations-runbook.md) — day-2 runtime operations and rollback flow
- [troubleshooting.md](troubleshooting.md) — common failure signatures and recovery steps
- [commands-reference.md](reference/cli/commands-reference.md) — command lookup by workflow
- [providers-reference.md](reference/api/providers-reference.md) — provider IDs, aliases, credential env vars
- [channels-reference.md](reference/api/channels-reference.md) — channel capabilities and setup paths
- [matrix-e2ee-guide.md](security/matrix-e2ee-guide.md) — Matrix encrypted-room (E2EE) setup and no-response diagnostics
- [config-reference.md](reference/api/config-reference.md) — high-signal config keys and secure defaults
- [custom-providers.md](contributing/custom-providers.md) — custom provider/base URL integration templates
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md) — Z.AI/GLM setup and endpoint matrix
- [langgraph-integration.md](contributing/langgraph-integration.md) — fallback integration for model/tool-calling edge cases
- [operations-runbook.md](ops/operations-runbook.md) — day-2 runtime operations and rollback flow
- [troubleshooting.md](ops/troubleshooting.md) — common failure signatures and recovery steps
### Contributors / Maintainers
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### Security / Reliability
> Note: this area includes proposal/roadmap docs. For current behavior, start with [config-reference.md](config-reference.md), [operations-runbook.md](operations-runbook.md), and [troubleshooting.md](troubleshooting.md).
> Note: this area includes proposal/roadmap docs. For current behavior, start with [config-reference.md](reference/api/config-reference.md), [operations-runbook.md](ops/operations-runbook.md), and [troubleshooting.md](ops/troubleshooting.md).
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [audit-logging.md](audit-logging.md)
- [resource-limits.md](resource-limits.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [audit-logging.md](security/audit-logging.md)
- [resource-limits.md](ops/resource-limits.md)
- [security-roadmap.md](security/security-roadmap.md)
## System Navigation & Governance
- Unified TOC: [SUMMARY.md](SUMMARY.md)
- Docs structure map (language/part/function): [structure/README.md](structure/README.md)
- Documentation inventory/classification: [docs-inventory.md](docs-inventory.md)
- Docs structure map (language/part/function): [structure/README.md](maintainers/structure-README.md)
- Documentation inventory/classification: [docs-inventory.md](maintainers/docs-inventory.md)
- i18n docs index: [i18n/README.md](i18n/README.md)
- i18n coverage map: [i18n-coverage.md](i18n-coverage.md)
- Project triage snapshot: [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md)
- i18n coverage map: [i18n-coverage.md](maintainers/i18n-coverage.md)
- Project triage snapshot: [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md)

View File

@ -11,23 +11,23 @@
| Что нужно | Куда смотреть |
|---|---|
| Быстро установить и запустить | [../README.ru.md](../README.ru.md) / [../README.md](../README.md) |
| Установить одной командой | [one-click-bootstrap.md](one-click-bootstrap.md) |
| Найти команды по задаче | [commands-reference.md](commands-reference.md) |
| Проверить ключи конфигурации и дефолты | [config-reference.md](config-reference.md) |
| Подключить кастомный provider / endpoint | [custom-providers.md](custom-providers.md) |
| Настроить provider Z.AI / GLM | [zai-glm-setup.md](zai-glm-setup.md) |
| Использовать интеграцию LangGraph | [langgraph-integration.md](langgraph-integration.md) |
| Операционный runbook (day-2) | [operations-runbook.md](operations-runbook.md) |
| Быстро устранить типовые проблемы | [troubleshooting.md](troubleshooting.md) |
| Установить одной командой | [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md) |
| Найти команды по задаче | [commands-reference.md](reference/cli/commands-reference.md) |
| Проверить ключи конфигурации и дефолты | [config-reference.md](reference/api/config-reference.md) |
| Подключить кастомный provider / endpoint | [custom-providers.md](contributing/custom-providers.md) |
| Настроить provider Z.AI / GLM | [zai-glm-setup.md](setup-guides/zai-glm-setup.md) |
| Использовать интеграцию LangGraph | [langgraph-integration.md](contributing/langgraph-integration.md) |
| Операционный runbook (day-2) | [operations-runbook.md](ops/operations-runbook.md) |
| Быстро устранить типовые проблемы | [troubleshooting.md](ops/troubleshooting.md) |
| Открыть общий TOC docs | [SUMMARY.md](SUMMARY.md) |
| Посмотреть snapshot PR/Issue | [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md) |
| Посмотреть snapshot PR/Issue | [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md) |
## Дерево решений на 10 секунд
- Нужна первая установка и быстрый старт → [getting-started/README.md](getting-started/README.md)
- Нужна первая установка и быстрый старт → [setup-guides/README.md](setup-guides/README.md)
- Нужны точные команды и ключи конфигурации → [reference/README.md](reference/README.md)
- Нужны операции/сервисный режим/деплой → [operations/README.md](operations/README.md)
- Есть ошибки, сбои или регрессии → [troubleshooting.md](troubleshooting.md)
- Нужны операции/сервисный режим/деплой → [ops/README.md](ops/README.md)
- Есть ошибки, сбои или регрессии → [troubleshooting.md](ops/troubleshooting.md)
- Нужны материалы по безопасности и roadmap → [security/README.md](security/README.md)
- Работаете с платами и периферией → [hardware/README.md](hardware/README.md)
- Нужны процессы вклада, ревью и CI → [contributing/README.md](contributing/README.md)
@ -35,53 +35,53 @@
## Навигация по категориям (рекомендуется)
- Старт и установка: [getting-started/README.md](getting-started/README.md)
- Старт и установка: [setup-guides/README.md](setup-guides/README.md)
- Справочники: [reference/README.md](reference/README.md)
- Операции и деплой: [operations/README.md](operations/README.md)
- Операции и деплой: [ops/README.md](ops/README.md)
- Безопасность: [security/README.md](security/README.md)
- Аппаратная часть: [hardware/README.md](hardware/README.md)
- Вклад и CI: [contributing/README.md](contributing/README.md)
- Снимки проекта: [project/README.md](project/README.md)
- Снимки проекта: [maintainers/README.md](maintainers/README.md)
## По ролям
### Пользователи / Операторы
- [commands-reference.md](commands-reference.md)
- [providers-reference.md](providers-reference.md)
- [channels-reference.md](channels-reference.md)
- [config-reference.md](config-reference.md)
- [custom-providers.md](custom-providers.md)
- [zai-glm-setup.md](zai-glm-setup.md)
- [langgraph-integration.md](langgraph-integration.md)
- [operations-runbook.md](operations-runbook.md)
- [troubleshooting.md](troubleshooting.md)
- [commands-reference.md](reference/cli/commands-reference.md)
- [providers-reference.md](reference/api/providers-reference.md)
- [channels-reference.md](reference/api/channels-reference.md)
- [config-reference.md](reference/api/config-reference.md)
- [custom-providers.md](contributing/custom-providers.md)
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md)
- [langgraph-integration.md](contributing/langgraph-integration.md)
- [operations-runbook.md](ops/operations-runbook.md)
- [troubleshooting.md](ops/troubleshooting.md)
### Контрибьюторы / Мейнтейнеры
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### Безопасность / Надёжность
> Примечание: часть документов в этом разделе относится к proposal/roadmap и может содержать гипотетические команды/конфигурации. Для текущего поведения сначала смотрите [config-reference.md](config-reference.md), [operations-runbook.md](operations-runbook.md), [troubleshooting.md](troubleshooting.md).
> Примечание: часть документов в этом разделе относится к proposal/roadmap и может содержать гипотетические команды/конфигурации. Для текущего поведения сначала смотрите [config-reference.md](reference/api/config-reference.md), [operations-runbook.md](ops/operations-runbook.md), [troubleshooting.md](ops/troubleshooting.md).
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [resource-limits.md](resource-limits.md)
- [audit-logging.md](audit-logging.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [resource-limits.md](ops/resource-limits.md)
- [audit-logging.md](security/audit-logging.md)
- [security-roadmap.md](security/security-roadmap.md)
## Инвентаризация и структура docs
- Единый TOC: [SUMMARY.md](SUMMARY.md)
- Карта структуры docs (язык/раздел/функция): [structure/README.md](structure/README.md)
- Инвентарь и классификация docs: [docs-inventory.md](docs-inventory.md)
- Карта структуры docs (язык/раздел/функция): [structure/README.md](maintainers/structure-README.md)
- Инвентарь и классификация docs: [docs-inventory.md](maintainers/docs-inventory.md)
## Другие языки

View File

@ -13,7 +13,7 @@ Hub bản địa hóa: [简体中文](README.zh-CN.md) · [日本語](README.ja.
| Tôi muốn… | Xem tài liệu |
| -------------------------------------------------- | ------------------------------------------------------------------------------ |
| Cài đặt và chạy nhanh | [README.vi.md (Khởi động nhanh)](../README.vi.md) / [../README.md](../README.md) |
| Cài đặt bằng một lệnh | [one-click-bootstrap.md](one-click-bootstrap.md) |
| Cài đặt bằng một lệnh | [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md) |
| Tìm lệnh theo tác vụ | [commands-reference.md](i18n/vi/commands-reference.md) |
| Kiểm tra giá trị mặc định và khóa cấu hình | [config-reference.md](i18n/vi/config-reference.md) |
| Kết nối provider / endpoint tùy chỉnh | [custom-providers.md](i18n/vi/custom-providers.md) |
@ -23,7 +23,7 @@ Hub bản địa hóa: [简体中文](README.zh-CN.md) · [日本語](README.ja.
| Khắc phục sự cố cài đặt/chạy/kênh | [troubleshooting.md](i18n/vi/troubleshooting.md) |
| Cấu hình Matrix phòng mã hóa (E2EE) | [matrix-e2ee-guide.md](i18n/vi/matrix-e2ee-guide.md) |
| Xem theo danh mục | [SUMMARY.md](i18n/vi/SUMMARY.md) |
| Xem bản chụp PR/Issue | [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md) |
| Xem bản chụp PR/Issue | [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md) |
## Tìm nhanh (10 giây)
@ -84,8 +84,8 @@ Hub bản địa hóa: [简体中文](README.zh-CN.md) · [日本語](README.ja.
## Quản lý tài liệu
- Mục lục thống nhất (TOC): [SUMMARY.md](i18n/vi/SUMMARY.md)
- Bản đồ cấu trúc docs (ngôn ngữ/phần/chức năng): [structure/README.md](structure/README.md)
- Danh mục và phân loại tài liệu: [docs-inventory.md](docs-inventory.md)
- Bản đồ cấu trúc docs (ngôn ngữ/phần/chức năng): [structure/README.md](maintainers/structure-README.md)
- Danh mục và phân loại tài liệu: [docs-inventory.md](maintainers/docs-inventory.md)
## Ngôn ngữ khác

View File

@ -11,23 +11,23 @@
| 我想要… | 建议阅读 |
|---|---|
| 快速安装并运行 | [../README.zh-CN.md](../README.zh-CN.md) / [../README.md](../README.md) |
| 一键安装与初始化 | [one-click-bootstrap.md](one-click-bootstrap.md) |
| 按任务找命令 | [commands-reference.md](commands-reference.md) |
| 快速查看配置默认值与关键项 | [config-reference.md](config-reference.md) |
| 接入自定义 Provider / endpoint | [custom-providers.md](custom-providers.md) |
| 配置 Z.AI / GLM Provider | [zai-glm-setup.md](zai-glm-setup.md) |
| 使用 LangGraph 工具调用集成 | [langgraph-integration.md](langgraph-integration.md) |
| 进行日常运维runbook | [operations-runbook.md](operations-runbook.md) |
| 快速排查安装/运行问题 | [troubleshooting.md](troubleshooting.md) |
| 一键安装与初始化 | [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md) |
| 按任务找命令 | [commands-reference.md](reference/cli/commands-reference.md) |
| 快速查看配置默认值与关键项 | [config-reference.md](reference/api/config-reference.md) |
| 接入自定义 Provider / endpoint | [custom-providers.md](contributing/custom-providers.md) |
| 配置 Z.AI / GLM Provider | [zai-glm-setup.md](setup-guides/zai-glm-setup.md) |
| 使用 LangGraph 工具调用集成 | [langgraph-integration.md](contributing/langgraph-integration.md) |
| 进行日常运维runbook | [operations-runbook.md](ops/operations-runbook.md) |
| 快速排查安装/运行问题 | [troubleshooting.md](ops/troubleshooting.md) |
| 统一目录导航 | [SUMMARY.md](SUMMARY.md) |
| 查看 PR/Issue 扫描快照 | [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md) |
| 查看 PR/Issue 扫描快照 | [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md) |
## 10 秒决策树(先看这个)
- 首次安装或快速启动 → [getting-started/README.md](getting-started/README.md)
- 首次安装或快速启动 → [setup-guides/README.md](setup-guides/README.md)
- 需要精确命令或配置键 → [reference/README.md](reference/README.md)
- 需要部署与服务化运维 → [operations/README.md](operations/README.md)
- 遇到报错、异常或回归 → [troubleshooting.md](troubleshooting.md)
- 需要部署与服务化运维 → [ops/README.md](ops/README.md)
- 遇到报错、异常或回归 → [troubleshooting.md](ops/troubleshooting.md)
- 查看安全现状与路线图 → [security/README.md](security/README.md)
- 接入板卡与外设 → [hardware/README.md](hardware/README.md)
- 参与贡献、评审与 CI → [contributing/README.md](contributing/README.md)
@ -35,53 +35,53 @@
## 按目录浏览(推荐)
- 入门文档: [getting-started/README.md](getting-started/README.md)
- 入门文档: [setup-guides/README.md](setup-guides/README.md)
- 参考手册: [reference/README.md](reference/README.md)
- 运维与部署: [operations/README.md](operations/README.md)
- 运维与部署: [ops/README.md](ops/README.md)
- 安全文档: [security/README.md](security/README.md)
- 硬件与外设: [hardware/README.md](hardware/README.md)
- 贡献与 CI [contributing/README.md](contributing/README.md)
- 项目快照: [project/README.md](project/README.md)
- 项目快照: [maintainers/README.md](maintainers/README.md)
## 按角色
### 用户 / 运维
- [commands-reference.md](commands-reference.md)
- [providers-reference.md](providers-reference.md)
- [channels-reference.md](channels-reference.md)
- [config-reference.md](config-reference.md)
- [custom-providers.md](custom-providers.md)
- [zai-glm-setup.md](zai-glm-setup.md)
- [langgraph-integration.md](langgraph-integration.md)
- [operations-runbook.md](operations-runbook.md)
- [troubleshooting.md](troubleshooting.md)
- [commands-reference.md](reference/cli/commands-reference.md)
- [providers-reference.md](reference/api/providers-reference.md)
- [channels-reference.md](reference/api/channels-reference.md)
- [config-reference.md](reference/api/config-reference.md)
- [custom-providers.md](contributing/custom-providers.md)
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md)
- [langgraph-integration.md](contributing/langgraph-integration.md)
- [operations-runbook.md](ops/operations-runbook.md)
- [troubleshooting.md](ops/troubleshooting.md)
### 贡献者 / 维护者
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### 安全 / 稳定性
> 说明:本分组内有 proposal/roadmap 文档,可能包含设想中的命令或配置。当前可执行行为请优先阅读 [config-reference.md](config-reference.md)、[operations-runbook.md](operations-runbook.md)、[troubleshooting.md](troubleshooting.md)。
> 说明:本分组内有 proposal/roadmap 文档,可能包含设想中的命令或配置。当前可执行行为请优先阅读 [config-reference.md](reference/api/config-reference.md)、[operations-runbook.md](ops/operations-runbook.md)、[troubleshooting.md](ops/troubleshooting.md)。
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [resource-limits.md](resource-limits.md)
- [audit-logging.md](audit-logging.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [resource-limits.md](ops/resource-limits.md)
- [audit-logging.md](security/audit-logging.md)
- [security-roadmap.md](security/security-roadmap.md)
## 文档治理与分类
- 统一目录TOC[SUMMARY.md](SUMMARY.md)
- 文档结构图(按语言/分区/功能):[structure/README.md](structure/README.md)
- 文档清单与分类:[docs-inventory.md](docs-inventory.md)
- 文档结构图(按语言/分区/功能):[structure/README.md](maintainers/structure-README.md)
- 文档清单与分类:[docs-inventory.md](maintainers/docs-inventory.md)
## 其他语言

View File

@ -8,7 +8,7 @@ Dernière mise à jour : **18 février 2026**.
## Points d'entrée par langue
- Carte de structure docs (langue/partie/fonction) : [structure/README.md](structure/README.md)
- Carte de structure docs (langue/partie/fonction) : [structure/README.md](maintainers/structure-README.md)
- README en anglais : [../README.md](../README.md)
- README en chinois : [../README.zh-CN.md](../README.zh-CN.md)
- README en japonais : [../README.ja.md](../README.ja.md)
@ -22,68 +22,68 @@ Dernière mise à jour : **18 février 2026**.
- Documentation en français : [README.fr.md](README.fr.md)
- Documentation en vietnamien : [i18n/vi/README.md](i18n/vi/README.md)
- Index de localisation : [i18n/README.md](i18n/README.md)
- Carte de couverture i18n : [i18n-coverage.md](i18n-coverage.md)
- Carte de couverture i18n : [i18n-coverage.md](maintainers/i18n-coverage.md)
## Catégories
### 1) Démarrage rapide
- [getting-started/README.md](getting-started/README.md)
- [one-click-bootstrap.md](one-click-bootstrap.md)
- [setup-guides/README.md](setup-guides/README.md)
- [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md)
### 2) Référence des commandes, configuration et intégrations
- [reference/README.md](reference/README.md)
- [commands-reference.md](commands-reference.md)
- [providers-reference.md](providers-reference.md)
- [channels-reference.md](channels-reference.md)
- [nextcloud-talk-setup.md](nextcloud-talk-setup.md)
- [config-reference.md](config-reference.md)
- [custom-providers.md](custom-providers.md)
- [zai-glm-setup.md](zai-glm-setup.md)
- [langgraph-integration.md](langgraph-integration.md)
- [commands-reference.md](reference/cli/commands-reference.md)
- [providers-reference.md](reference/api/providers-reference.md)
- [channels-reference.md](reference/api/channels-reference.md)
- [nextcloud-talk-setup.md](setup-guides/nextcloud-talk-setup.md)
- [config-reference.md](reference/api/config-reference.md)
- [custom-providers.md](contributing/custom-providers.md)
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md)
- [langgraph-integration.md](contributing/langgraph-integration.md)
### 3) Exploitation et déploiement
- [operations/README.md](operations/README.md)
- [operations-runbook.md](operations-runbook.md)
- [release-process.md](release-process.md)
- [troubleshooting.md](troubleshooting.md)
- [network-deployment.md](network-deployment.md)
- [mattermost-setup.md](mattermost-setup.md)
- [ops/README.md](ops/README.md)
- [operations-runbook.md](ops/operations-runbook.md)
- [release-process.md](contributing/release-process.md)
- [troubleshooting.md](ops/troubleshooting.md)
- [network-deployment.md](ops/network-deployment.md)
- [mattermost-setup.md](setup-guides/mattermost-setup.md)
### 4) Conception de la sécurité et propositions
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [resource-limits.md](resource-limits.md)
- [audit-logging.md](audit-logging.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [resource-limits.md](ops/resource-limits.md)
- [audit-logging.md](security/audit-logging.md)
- [security-roadmap.md](security/security-roadmap.md)
### 5) Matériel et périphériques
- [hardware/README.md](hardware/README.md)
- [hardware-peripherals-design.md](hardware-peripherals-design.md)
- [adding-boards-and-tools.md](adding-boards-and-tools.md)
- [nucleo-setup.md](nucleo-setup.md)
- [arduino-uno-q-setup.md](arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](datasheets/arduino-uno.md)
- [datasheets/esp32.md](datasheets/esp32.md)
- [hardware-peripherals-design.md](hardware/hardware-peripherals-design.md)
- [adding-boards-and-tools.md](contributing/adding-boards-and-tools.md)
- [nucleo-setup.md](hardware/nucleo-setup.md)
- [arduino-uno-q-setup.md](hardware/arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](hardware/datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](hardware/datasheets/arduino-uno.md)
- [datasheets/esp32.md](hardware/datasheets/esp32.md)
### 6) Contribution et CI
- [contributing/README.md](contributing/README.md)
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### 7) État du projet et instantanés
- [project/README.md](project/README.md)
- [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](docs-inventory.md)
- [maintainers/README.md](maintainers/README.md)
- [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](maintainers/docs-inventory.md)

View File

@ -8,7 +8,7 @@
## 言語別入口
- ドキュメント構造マップ(言語/カテゴリ/機能): [structure/README.md](structure/README.md)
- ドキュメント構造マップ(言語/カテゴリ/機能): [structure/README.md](maintainers/structure-README.md)
- 英語 README[../README.md](../README.md)
- 中国語 README[../README.zh-CN.md](../README.zh-CN.md)
- 日本語 README[../README.ja.md](../README.ja.md)
@ -22,68 +22,68 @@
- フランス語ドキュメントハブ:[README.fr.md](README.fr.md)
- ベトナム語ドキュメントハブ:[i18n/vi/README.md](i18n/vi/README.md)
- 国際化ドキュメント索引:[i18n/README.md](i18n/README.md)
- 国際化カバレッジマップ:[i18n-coverage.md](i18n-coverage.md)
- 国際化カバレッジマップ:[i18n-coverage.md](maintainers/i18n-coverage.md)
## カテゴリ
### 1) はじめに
- [getting-started/README.md](getting-started/README.md)
- [one-click-bootstrap.md](one-click-bootstrap.md)
- [setup-guides/README.md](setup-guides/README.md)
- [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md)
### 2) コマンド・設定リファレンスと統合
- [reference/README.md](reference/README.md)
- [commands-reference.md](commands-reference.md)
- [providers-reference.md](providers-reference.md)
- [channels-reference.md](channels-reference.md)
- [nextcloud-talk-setup.md](nextcloud-talk-setup.md)
- [config-reference.md](config-reference.md)
- [custom-providers.md](custom-providers.md)
- [zai-glm-setup.md](zai-glm-setup.md)
- [langgraph-integration.md](langgraph-integration.md)
- [commands-reference.md](reference/cli/commands-reference.md)
- [providers-reference.md](reference/api/providers-reference.md)
- [channels-reference.md](reference/api/channels-reference.md)
- [nextcloud-talk-setup.md](setup-guides/nextcloud-talk-setup.md)
- [config-reference.md](reference/api/config-reference.md)
- [custom-providers.md](contributing/custom-providers.md)
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md)
- [langgraph-integration.md](contributing/langgraph-integration.md)
### 3) 運用とデプロイ
- [operations/README.md](operations/README.md)
- [operations-runbook.md](operations-runbook.md)
- [release-process.md](release-process.md)
- [troubleshooting.md](troubleshooting.md)
- [network-deployment.md](network-deployment.md)
- [mattermost-setup.md](mattermost-setup.md)
- [ops/README.md](ops/README.md)
- [operations-runbook.md](ops/operations-runbook.md)
- [release-process.md](contributing/release-process.md)
- [troubleshooting.md](ops/troubleshooting.md)
- [network-deployment.md](ops/network-deployment.md)
- [mattermost-setup.md](setup-guides/mattermost-setup.md)
### 4) セキュリティ設計と提案
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [resource-limits.md](resource-limits.md)
- [audit-logging.md](audit-logging.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [resource-limits.md](ops/resource-limits.md)
- [audit-logging.md](security/audit-logging.md)
- [security-roadmap.md](security/security-roadmap.md)
### 5) ハードウェアと周辺機器
- [hardware/README.md](hardware/README.md)
- [hardware-peripherals-design.md](hardware-peripherals-design.md)
- [adding-boards-and-tools.md](adding-boards-and-tools.md)
- [nucleo-setup.md](nucleo-setup.md)
- [arduino-uno-q-setup.md](arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](datasheets/arduino-uno.md)
- [datasheets/esp32.md](datasheets/esp32.md)
- [hardware-peripherals-design.md](hardware/hardware-peripherals-design.md)
- [adding-boards-and-tools.md](contributing/adding-boards-and-tools.md)
- [nucleo-setup.md](hardware/nucleo-setup.md)
- [arduino-uno-q-setup.md](hardware/arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](hardware/datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](hardware/datasheets/arduino-uno.md)
- [datasheets/esp32.md](hardware/datasheets/esp32.md)
### 6) コントリビューションと CI
- [contributing/README.md](contributing/README.md)
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### 7) プロジェクト状況とスナップショット
- [project/README.md](project/README.md)
- [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](docs-inventory.md)
- [maintainers/README.md](maintainers/README.md)
- [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](maintainers/docs-inventory.md)

View File

@ -6,7 +6,7 @@ Last refreshed: **February 18, 2026**.
## Language Entry
- Docs Structure Map (language/part/function): [structure/README.md](structure/README.md)
- Docs Structure Map (language/part/function): [structure/README.md](maintainers/structure-README.md)
- English README: [../README.md](../README.md)
- Chinese README: [../README.zh-CN.md](../README.zh-CN.md)
- Japanese README: [../README.ja.md](../README.ja.md)
@ -20,69 +20,69 @@ Last refreshed: **February 18, 2026**.
- French Docs Hub: [README.fr.md](README.fr.md)
- Vietnamese Docs Hub: [i18n/vi/README.md](i18n/vi/README.md)
- i18n Docs Index: [i18n/README.md](i18n/README.md)
- i18n Coverage Map: [i18n-coverage.md](i18n-coverage.md)
- i18n Coverage Map: [i18n-coverage.md](maintainers/i18n-coverage.md)
## Collections
### 1) Getting Started
- [getting-started/README.md](getting-started/README.md)
- [getting-started/macos-update-uninstall.md](getting-started/macos-update-uninstall.md)
- [one-click-bootstrap.md](one-click-bootstrap.md)
- [setup-guides/README.md](setup-guides/README.md)
- [macos-update-uninstall.md](setup-guides/macos-update-uninstall.md)
- [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md)
### 2) Command/Config References & Integrations
- [reference/README.md](reference/README.md)
- [commands-reference.md](commands-reference.md)
- [providers-reference.md](providers-reference.md)
- [channels-reference.md](channels-reference.md)
- [nextcloud-talk-setup.md](nextcloud-talk-setup.md)
- [config-reference.md](config-reference.md)
- [custom-providers.md](custom-providers.md)
- [zai-glm-setup.md](zai-glm-setup.md)
- [langgraph-integration.md](langgraph-integration.md)
- [commands-reference.md](reference/cli/commands-reference.md)
- [providers-reference.md](reference/api/providers-reference.md)
- [channels-reference.md](reference/api/channels-reference.md)
- [nextcloud-talk-setup.md](setup-guides/nextcloud-talk-setup.md)
- [config-reference.md](reference/api/config-reference.md)
- [custom-providers.md](contributing/custom-providers.md)
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md)
- [langgraph-integration.md](contributing/langgraph-integration.md)
### 3) Operations & Deployment
- [operations/README.md](operations/README.md)
- [operations-runbook.md](operations-runbook.md)
- [release-process.md](release-process.md)
- [troubleshooting.md](troubleshooting.md)
- [network-deployment.md](network-deployment.md)
- [mattermost-setup.md](mattermost-setup.md)
- [ops/README.md](ops/README.md)
- [operations-runbook.md](ops/operations-runbook.md)
- [release-process.md](contributing/release-process.md)
- [troubleshooting.md](ops/troubleshooting.md)
- [network-deployment.md](ops/network-deployment.md)
- [mattermost-setup.md](setup-guides/mattermost-setup.md)
### 4) Security Design & Proposals
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [resource-limits.md](resource-limits.md)
- [audit-logging.md](audit-logging.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [resource-limits.md](ops/resource-limits.md)
- [audit-logging.md](security/audit-logging.md)
- [security-roadmap.md](security/security-roadmap.md)
### 5) Hardware & Peripherals
- [hardware/README.md](hardware/README.md)
- [hardware-peripherals-design.md](hardware-peripherals-design.md)
- [adding-boards-and-tools.md](adding-boards-and-tools.md)
- [nucleo-setup.md](nucleo-setup.md)
- [arduino-uno-q-setup.md](arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](datasheets/arduino-uno.md)
- [datasheets/esp32.md](datasheets/esp32.md)
- [hardware-peripherals-design.md](hardware/hardware-peripherals-design.md)
- [adding-boards-and-tools.md](contributing/adding-boards-and-tools.md)
- [nucleo-setup.md](hardware/nucleo-setup.md)
- [arduino-uno-q-setup.md](hardware/arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](hardware/datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](hardware/datasheets/arduino-uno.md)
- [datasheets/esp32.md](hardware/datasheets/esp32.md)
### 6) Contribution & CI
- [contributing/README.md](contributing/README.md)
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### 7) Project Status & Snapshot
- [project/README.md](project/README.md)
- [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](docs-inventory.md)
- [maintainers/README.md](maintainers/README.md)
- [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](maintainers/docs-inventory.md)

View File

@ -8,7 +8,7 @@
## Языковые точки входа
- Карта структуры docs (язык/раздел/функция): [structure/README.md](structure/README.md)
- Карта структуры docs (язык/раздел/функция): [structure/README.md](maintainers/structure-README.md)
- README на английском: [../README.md](../README.md)
- README на китайском: [../README.zh-CN.md](../README.zh-CN.md)
- README на японском: [../README.ja.md](../README.ja.md)
@ -22,68 +22,68 @@
- Документация на французском: [README.fr.md](README.fr.md)
- Документация на вьетнамском: [i18n/vi/README.md](i18n/vi/README.md)
- Индекс локализации: [i18n/README.md](i18n/README.md)
- Карта покрытия локализации: [i18n-coverage.md](i18n-coverage.md)
- Карта покрытия локализации: [i18n-coverage.md](maintainers/i18n-coverage.md)
## Разделы
### 1) Начало работы
- [getting-started/README.md](getting-started/README.md)
- [one-click-bootstrap.md](one-click-bootstrap.md)
- [setup-guides/README.md](setup-guides/README.md)
- [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md)
### 2) Справочник команд, конфигурации и интеграций
- [reference/README.md](reference/README.md)
- [commands-reference.md](commands-reference.md)
- [providers-reference.md](providers-reference.md)
- [channels-reference.md](channels-reference.md)
- [nextcloud-talk-setup.md](nextcloud-talk-setup.md)
- [config-reference.md](config-reference.md)
- [custom-providers.md](custom-providers.md)
- [zai-glm-setup.md](zai-glm-setup.md)
- [langgraph-integration.md](langgraph-integration.md)
- [commands-reference.md](reference/cli/commands-reference.md)
- [providers-reference.md](reference/api/providers-reference.md)
- [channels-reference.md](reference/api/channels-reference.md)
- [nextcloud-talk-setup.md](setup-guides/nextcloud-talk-setup.md)
- [config-reference.md](reference/api/config-reference.md)
- [custom-providers.md](contributing/custom-providers.md)
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md)
- [langgraph-integration.md](contributing/langgraph-integration.md)
### 3) Эксплуатация и развёртывание
- [operations/README.md](operations/README.md)
- [operations-runbook.md](operations-runbook.md)
- [release-process.md](release-process.md)
- [troubleshooting.md](troubleshooting.md)
- [network-deployment.md](network-deployment.md)
- [mattermost-setup.md](mattermost-setup.md)
- [ops/README.md](ops/README.md)
- [operations-runbook.md](ops/operations-runbook.md)
- [release-process.md](contributing/release-process.md)
- [troubleshooting.md](ops/troubleshooting.md)
- [network-deployment.md](ops/network-deployment.md)
- [mattermost-setup.md](setup-guides/mattermost-setup.md)
### 4) Проектирование безопасности и предложения
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [resource-limits.md](resource-limits.md)
- [audit-logging.md](audit-logging.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [resource-limits.md](ops/resource-limits.md)
- [audit-logging.md](security/audit-logging.md)
- [security-roadmap.md](security/security-roadmap.md)
### 5) Оборудование и периферия
- [hardware/README.md](hardware/README.md)
- [hardware-peripherals-design.md](hardware-peripherals-design.md)
- [adding-boards-and-tools.md](adding-boards-and-tools.md)
- [nucleo-setup.md](nucleo-setup.md)
- [arduino-uno-q-setup.md](arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](datasheets/arduino-uno.md)
- [datasheets/esp32.md](datasheets/esp32.md)
- [hardware-peripherals-design.md](hardware/hardware-peripherals-design.md)
- [adding-boards-and-tools.md](contributing/adding-boards-and-tools.md)
- [nucleo-setup.md](hardware/nucleo-setup.md)
- [arduino-uno-q-setup.md](hardware/arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](hardware/datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](hardware/datasheets/arduino-uno.md)
- [datasheets/esp32.md](hardware/datasheets/esp32.md)
### 6) Участие в проекте и CI
- [contributing/README.md](contributing/README.md)
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### 7) Состояние проекта и снимки
- [project/README.md](project/README.md)
- [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](docs-inventory.md)
- [maintainers/README.md](maintainers/README.md)
- [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](maintainers/docs-inventory.md)

View File

@ -8,7 +8,7 @@
## 语言入口
- 文档结构图(按语言/分区/功能):[structure/README.md](structure/README.md)
- 文档结构图(按语言/分区/功能):[structure/README.md](maintainers/structure-README.md)
- 英文 README[../README.md](../README.md)
- 中文 README[../README.zh-CN.md](../README.zh-CN.md)
- 日文 README[../README.ja.md](../README.ja.md)
@ -22,68 +22,68 @@
- 法文文档中心:[README.fr.md](README.fr.md)
- 越南文文档中心:[i18n/vi/README.md](i18n/vi/README.md)
- 国际化文档索引:[i18n/README.md](i18n/README.md)
- 国际化覆盖图:[i18n-coverage.md](i18n-coverage.md)
- 国际化覆盖图:[i18n-coverage.md](maintainers/i18n-coverage.md)
## 分类
### 1) 快速入门
- [getting-started/README.md](getting-started/README.md)
- [one-click-bootstrap.md](one-click-bootstrap.md)
- [setup-guides/README.md](setup-guides/README.md)
- [one-click-bootstrap.md](setup-guides/one-click-bootstrap.md)
### 2) 命令 / 配置参考与集成
- [reference/README.md](reference/README.md)
- [commands-reference.md](commands-reference.md)
- [providers-reference.md](providers-reference.md)
- [channels-reference.md](channels-reference.md)
- [nextcloud-talk-setup.md](nextcloud-talk-setup.md)
- [config-reference.md](config-reference.md)
- [custom-providers.md](custom-providers.md)
- [zai-glm-setup.md](zai-glm-setup.md)
- [langgraph-integration.md](langgraph-integration.md)
- [commands-reference.md](reference/cli/commands-reference.md)
- [providers-reference.md](reference/api/providers-reference.md)
- [channels-reference.md](reference/api/channels-reference.md)
- [nextcloud-talk-setup.md](setup-guides/nextcloud-talk-setup.md)
- [config-reference.md](reference/api/config-reference.md)
- [custom-providers.md](contributing/custom-providers.md)
- [zai-glm-setup.md](setup-guides/zai-glm-setup.md)
- [langgraph-integration.md](contributing/langgraph-integration.md)
### 3) 运维与部署
- [operations/README.md](operations/README.md)
- [operations-runbook.md](operations-runbook.md)
- [release-process.md](release-process.md)
- [troubleshooting.md](troubleshooting.md)
- [network-deployment.md](network-deployment.md)
- [mattermost-setup.md](mattermost-setup.md)
- [ops/README.md](ops/README.md)
- [operations-runbook.md](ops/operations-runbook.md)
- [release-process.md](contributing/release-process.md)
- [troubleshooting.md](ops/troubleshooting.md)
- [network-deployment.md](ops/network-deployment.md)
- [mattermost-setup.md](setup-guides/mattermost-setup.md)
### 4) 安全设计与提案
- [security/README.md](security/README.md)
- [agnostic-security.md](agnostic-security.md)
- [frictionless-security.md](frictionless-security.md)
- [sandboxing.md](sandboxing.md)
- [resource-limits.md](resource-limits.md)
- [audit-logging.md](audit-logging.md)
- [security-roadmap.md](security-roadmap.md)
- [agnostic-security.md](security/agnostic-security.md)
- [frictionless-security.md](security/frictionless-security.md)
- [sandboxing.md](security/sandboxing.md)
- [resource-limits.md](ops/resource-limits.md)
- [audit-logging.md](security/audit-logging.md)
- [security-roadmap.md](security/security-roadmap.md)
### 5) 硬件与外设
- [hardware/README.md](hardware/README.md)
- [hardware-peripherals-design.md](hardware-peripherals-design.md)
- [adding-boards-and-tools.md](adding-boards-and-tools.md)
- [nucleo-setup.md](nucleo-setup.md)
- [arduino-uno-q-setup.md](arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](datasheets/arduino-uno.md)
- [datasheets/esp32.md](datasheets/esp32.md)
- [hardware-peripherals-design.md](hardware/hardware-peripherals-design.md)
- [adding-boards-and-tools.md](contributing/adding-boards-and-tools.md)
- [nucleo-setup.md](hardware/nucleo-setup.md)
- [arduino-uno-q-setup.md](hardware/arduino-uno-q-setup.md)
- [datasheets/nucleo-f401re.md](hardware/datasheets/nucleo-f401re.md)
- [datasheets/arduino-uno.md](hardware/datasheets/arduino-uno.md)
- [datasheets/esp32.md](hardware/datasheets/esp32.md)
### 6) 贡献与 CI
- [contributing/README.md](contributing/README.md)
- [../CONTRIBUTING.md](../CONTRIBUTING.md)
- [pr-workflow.md](pr-workflow.md)
- [reviewer-playbook.md](reviewer-playbook.md)
- [ci-map.md](ci-map.md)
- [actions-source-policy.md](actions-source-policy.md)
- [pr-workflow.md](contributing/pr-workflow.md)
- [reviewer-playbook.md](contributing/reviewer-playbook.md)
- [ci-map.md](contributing/ci-map.md)
- [actions-source-policy.md](contributing/actions-source-policy.md)
### 7) 项目状态与快照
- [project/README.md](project/README.md)
- [project-triage-snapshot-2026-02-18.md](project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](docs-inventory.md)
- [maintainers/README.md](maintainers/README.md)
- [project-triage-snapshot-2026-02-18.md](maintainers/project-triage-snapshot-2026-02-18.md)
- [docs-inventory.md](maintainers/docs-inventory.md)

View File

Before

Width:  |  Height:  |  Size: 84 KiB

After

Width:  |  Height:  |  Size: 84 KiB

View File

@ -0,0 +1,832 @@
# ZeroClaw Architecture Diagrams
This document provides visual representations of ZeroClaw's architecture, execution modes, and data flows.
---
## 1. Execution Modes
**Ways ZeroClaw can be run:**
```mermaid
flowchart TD
Start[zeroclaw CLI] --> Onboard[onboard<br/>Setup wizard]
Start --> Agent[agent<br/>Interactive CLI]
Start --> Gateway[gateway<br/>HTTP server]
Start --> Daemon[daemon<br/>Long-running runtime]
Start --> Channel[channel<br/>Messaging platforms]
Start --> Service[service<br/>OS service mgmt]
Start --> Models[models<br/>Provider catalog]
Start --> Cron[cron<br/>Scheduled tasks]
Start --> Hardware[hardware<br/>Peripheral discovery]
Start --> Peripheral[peripheral<br/>Hardware management]
Start --> Status[status<br/>System overview]
Start --> Doctor[doctor<br/>Diagnostics]
Start --> Migrate[migrate<br/>Data import]
Start --> Skills[skills<br/>User capabilities]
Start --> Integrations[integrations<br/>Browse 50+ apps]
Agent --> AgentSingle[-m message<br/>One-shot]
Agent --> AgentInteractive[Interactive REPL<br/>stdin/stdout]
Daemon --> DaemonSupervised[Supervised runtime<br/>Gateway + Channels + Scheduler]
```
---
## 2. System Architecture Overview
**High-level component structure:**
```mermaid
flowchart TB
subgraph CLI[CLI Entry Point]
Main[main.rs]
end
subgraph Core[Core Subsystems]
Config[config/<br/>Configuration & Schema]
Agent[agent/<br/>Orchestration Loop]
Providers[providers/<br/>LLM Adapters]
Channels[channels/<br/>Messaging Platforms]
Tools[tools/<br/>Tool Execution]
Memory[memory/<br/>Storage Backends]
Security[security/<br/>Policy & Pairing]
Runtime[runtime/<br/>Execution Adapters]
Gateway[gateway/<br/>HTTP/Webhook Server]
Daemon[daemon/<br/>Supervised Runtime]
Peripherals[peripherals/<br/>Hardware Control]
Observability[observability/<br/>Telemetry & Metrics]
RAG[rag/<br/>Hardware Documentation]
Cron[cron/<br/>Scheduler]
Skills[skills/<br/>User Capabilities]
end
subgraph Integrations[Integrations]
Composio[Composio<br/>1000+ Apps]
Browser[Browser<br/>Brave Integration]
Tunnel[Tunnel<br/>Cloudflare/boringproxy]
end
Main --> Config
Main --> Agent
Main --> Gateway
Main --> Daemon
Main --> Channels
Agent --> Providers
Agent --> Tools
Agent --> Memory
Agent --> Security
Agent --> Runtime
Agent --> Peripherals
Agent --> RAG
Agent --> Skills
Channels --> Agent
Gateway --> Agent
Daemon --> Gateway
Daemon --> Channels
Daemon --> Cron
Daemon --> Observability
Tools --> Composio
Tools --> Browser
Gateway --> Tunnel
classDef coreComp fill:#4A90E2,stroke:#1E3A5F,color:#fff
classDef integComp fill:#50C878,stroke:#1E3A5F,color:#fff
classDef cliComp fill:#F5A623,stroke:#1E3A5F,color:#fff
class Config,Agent,Providers,Channels,Tools,Memory,Security,Runtime,Gateway,Daemon,Peripherals,Observability,RAG,Cron,Skills coreComp
class Composio,Browser,Tunnel integComp
class Main cliComp
```
---
## 3. Message Flow Through The System
**How a user message becomes a response:**
```mermaid
sequenceDiagram
participant User
participant Channel as Channel Layer
participant Dispatcher as Message Dispatcher
participant Agent as Agent Loop
participant Provider as LLM Provider
participant Tools as Tool Registry
participant Memory as Memory Backend
User->>Channel: Send message
Channel->>Dispatcher: ChannelMessage{id, sender, content}
Dispatcher->>Memory: Recall context
Memory-->>Dispatcher: Relevant memories
Dispatcher->>Agent: process_message()
Note over Agent: Build system prompt<br/>+ memory context
Agent->>Provider: chat_with_tools(history)
Provider-->>Agent: LLM response
alt Tool calls present
loop For each tool call
Agent->>Tools: execute(args)
Tools-->>Agent: ToolResult
end
Agent->>Provider: chat_with_tools(+ tool results)
Provider-->>Agent: Final response
end
Agent-->>Dispatcher: Response text
Dispatcher->>Memory: Store conversation
Dispatcher-->>Channel: SendMessage{content, recipient}
Channel-->>User: Reply
```
---
## 4. Agent Loop Execution Flow
**The core agent orchestration loop:**
```mermaid
flowchart TD
Start[[Start: User Message]] --> BuildContext[Build Context]
BuildContext --> MemoryRecall[Memory.recall<br/>Retrieve relevant entries]
BuildContext --> HardwareRAG{Hardware<br/>enabled?}
HardwareRAG -->|Yes| LoadDatasheets[Load Hardware RAG<br/>Pin aliases + chunks]
HardwareRAG -->|No| BuildPrompt[Build System Prompt]
LoadDatasheets --> BuildPrompt
MemoryRecall --> Enrich[Enrich Message<br/>memory + RAG context]
Enrich --> BuildPrompt
BuildPrompt --> InitHistory[Initialize History<br/>system + user message]
InitHistory --> ToolLoop{Tool Call Loop<br/>max 10 iterations}
ToolLoop --> LLMRequest[Provider.chat_with_tools<br/>or chat_with_history]
LLMRequest --> ParseResponse[Parse Response]
ParseResponse --> HasTools{Tool calls<br/>present?}
HasTools -->|No| SaveResponse[Push assistant response]
SaveResponse --> Return[[Return: Final Response]]
HasTools -->|Yes| Approval{Needs<br/>approval?}
Approval -->|Yes & Denied| DenyTool[Record denied]
DenyTool --> NextIteration
Approval -->|No / Approved| ExecuteTools[Execute Tools<br/>in parallel]
ExecuteTools --> ScrubResults[Scrub credentials<br/>from output]
ScrubResults --> AddResults[Add tool results<br/>to history]
AddResults --> NextIteration
DenyTool --> NextIteration[Increment iteration]
NextIteration --> MaxIter{Reached<br/>max 10?}
MaxIter -->|Yes| Error[[Error: Max iterations]]
MaxIter -->|No| ToolLoop
classDef contextStep fill:#E8F4FD,stroke:#4A90E2
classDef llmStep fill:#FFF4E6,stroke:#F5A623
classDef toolStep fill:#E8FDF5,stroke:#50C878
classDef errorStep fill:#FDE8E8,stroke:#D0021B
class BuildContext,MemoryRecall,HardwareRAG,LoadDatasheets,Enrich,BuildPrompt,InitHistory contextStep
class LLMRequest,ParseResponse llmStep
class ExecuteTools,ScrubResults,AddResults toolStep
class Error errorStep
```
---
## 5. Daemon Supervision Model
**How the daemon keeps components alive:**
```mermaid
flowchart TB
Start[[zeroclaw daemon]] --> SpawnComponents
SpawnComponents --> SpawnState[Spawn State Writer<br/>5s flush interval]
SpawnComponents --> SpawnGateway[Spawn Gateway Supervisor]
SpawnComponents --> SpawnChannels{Channels<br/>configured?}
SpawnComponents --> SpawnHeartbeat{Heartbeat<br/>enabled?}
SpawnComponents --> SpawnScheduler{Cron<br/>enabled?}
SpawnChannels -->|Yes| SpawnChannelSup[Spawn Channel Supervisor]
SpawnChannels -->|No| MarkChannelsOK[Mark channels OK<br/>disabled]
SpawnHeartbeat -->|Yes| SpawnHeartbeatWorker[Spawn Heartbeat Worker]
SpawnHeartbeat -->|No| MarkHeartbeatOK[Mark heartbeat OK<br/>disabled]
SpawnScheduler -->|Yes| SpawnSchedulerWorker[Spawn Cron Scheduler]
SpawnScheduler -->|No| MarkSchedulerOK[Mark scheduler OK<br/>disabled]
SpawnGateway --> GatewayLoop{Gateway Loop}
SpawnChannelSup --> ChannelLoop{Channel Loop}
SpawnHeartbeatWorker --> HeartbeatLoop{Heartbeat Loop}
SpawnSchedulerWorker --> SchedulerLoop{Scheduler Loop}
GatewayLoop --> GatewayRun[run_gateway]
GatewayRun --> GatewayExit{Exit OK?}
GatewayExit -->|No| GatewayError[Mark error + log]
GatewayExit -->|Yes| GatewayUnexpected[Mark: unexpected exit]
GatewayError --> GatewayBackoff[Wait with backoff]
GatewayUnexpected --> GatewayBackoff
GatewayBackoff --> GatewayLoop
ChannelLoop --> ChannelRun[start_channels]
ChannelRun --> ChannelExit{Exit OK?}
ChannelExit -->|No| ChannelError[Mark error + log]
ChannelExit -->|Yes| ChannelUnexpected[Mark: unexpected exit]
ChannelError --> ChannelBackoff[Wait with backoff]
ChannelUnexpected --> ChannelBackoff
ChannelBackoff --> ChannelLoop
HeartbeatLoop --> HeartbeatRun[Collect tasks + Agent runs]
HeartbeatRun --> HeartbeatExit{Exit OK?}
HeartbeatExit -->|No| HeartbeatError[Mark error + log]
HeartbeatExit -->|Yes| HeartbeatUnexpected[Mark: unexpected exit]
HeartbeatError --> HeartbeatBackoff[Wait with backoff]
HeartbeatUnexpected --> HeartbeatBackoff
HeartbeatBackoff --> HeartbeatLoop
SchedulerLoop --> SchedulerRun[cron::scheduler::run]
SchedulerRun --> SchedulerExit{Exit OK?}
SchedulerExit -->|No| SchedulerError[Mark error + log]
SchedulerExit -->|Yes| SchedulerUnexpected[Mark: unexpected exit]
SchedulerError --> SchedulerBackoff[Wait with backoff]
SchedulerUnexpected --> SchedulerBackoff
SchedulerBackoff --> SchedulerLoop
MarkChannelsOK --> Running[Daemon Running<br/>Ctrl+C to stop]
MarkHeartbeatOK --> Running
MarkSchedulerOK --> Running
SpawnState --> Running
Running --> StopRequest[Ctrl+C received]
StopRequest --> AbortAll[Abort all tasks]
AbortAll --> JoinAll[Wait for tasks]
JoinAll --> Done[[Daemon stopped]]
classDef supervisor fill:#FDE8E8,stroke:#D0021B
classDef running fill:#E8FDF5,stroke:#50C878
classDef component fill:#E8F4FD,stroke:#4A90E2
class SpawnGateway,SpawnChannelSup,SpawnHeartbeatWorker,SpawnSchedulerWorker,SpawnState supervisor
class Running running
class GatewayRun,ChannelRun,HeartbeatRun,SchedulerRun component
```
---
## 6. Gateway HTTP Endpoints
**The gateway's HTTP API structure:**
```mermaid
flowchart TB
Client[HTTP Client] --> Gateway[ZeroClaw Gateway]
Gateway --> PairPOST[POST /pair<br/>Exchange one-time code<br/>for bearer token]
Gateway --> HealthGET[GET /health<br/>Status check]
Gateway --> WebhookPOST[POST /webhook<br/>Main agent endpoint]
Gateway --> WAVerify[GET /whatsapp<br/>Meta verification]
Gateway --> WAMessage[POST /whatsapp<br/>WhatsApp webhook]
PairPOST --> PairLimiter[Rate Limiter<br/>pair req/min]
PairLimiter --> PairGuard[PairingGuard<br/>Code validation]
PairGuard --> PairResponse[{paired, token, persisted}]
WebhookPOST --> WebhookLimiter[Rate Limiter<br/>webhook req/min]
WebhookLimiter --> WebhookPairing{Pairing<br/>required?}
WebhookPairing -->|Yes| BearerAuth[Bearer token check]
WebhookPairing -->|No| WebhookSecret{Secret<br/>configured?}
WebhookSecret -->|Yes| SecretCheck[X-Webhook-Secret<br/>HMAC-SHA256 verify]
WebhookSecret -->|No| Idempotency[Idempotency check<br/>X-Idempotency-Key]
BearerAuth --> Idempotency
SecretCheck --> Idempotency
Idempotency --> MemoryStore[Auto-save to memory]
MemoryStore --> ProviderCall[Provider.simple_chat]
ProviderCall --> WebhookResponse[{response, model}]
WAVerify --> TokenCheck[verify_token check<br/>constant-time compare]
TokenCheck --> Challenge[Return hub.challenge]
WAMessage --> SignatureCheck[X-Hub-Signature-256<br/>HMAC-SHA256 verify]
SignatureCheck --> ParsePayload[Parse messages]
ParsePayload --> ForEach[For each message]
ForEach --> WAMemory[Auto-save to memory]
WAMemory --> WAProvider[Provider.simple_chat]
WAProvider --> WASend[WhatsAppChannel.send]
classDef auth fill:#FDE8E8,stroke:#D0021B
classDef processing fill:#E8F4FD,stroke:#4A90E2
classDef response fill:#E8FDF5,stroke:#50C878
class PairLimiter,PairGuard,BearerAuth,SecretCheck auth
class MemoryStore,ProviderCall,TokenCheck,ParsePayload,ForEach,WAMemory,WAProvider processing
class PairResponse,WebhookResponse,Challenge,WASend response
```
---
## 7. Channel Message Dispatch
**How channels route messages to the agent:**
```mermaid
flowchart TB
subgraph Channels[Channel Listeners]
TG[Telegram]
DC[Discord]
SL[Slack]
IM[iMessage]
MX[Matrix]
SIG[Signal]
WA[WhatsApp]
Email[Email]
IRC[IRC]
Lark[Lark]
DT[DingTalk]
QQ[QQ]
end
Channels --> MPSC[MPSC Channel<br/>100-buffer queue]
MPSC --> Semaphore[Semaphore<br/>Max in-flight limit]
Semaphore --> WorkerPool[Worker Pool<br/>JoinSet]
WorkerPool --> Process[process_channel_message]
Process --> LogReceive[Log: 💬 from user]
LogReceive --> MemoryRecall[build_memory_context]
MemoryRecall --> AutoSave[Auto-save if enabled]
AutoSave --> StartTyping[channel.start_typing]
StartTyping --> Timeout[300s timeout guard]
Timeout --> AgentCall[run_tool_call_loop<br/>silent mode]
AgentCall --> StopTyping[channel.stop_typing]
StopTyping --> Success{Success?}
Success -->|Yes| LogReply[Log: 🤖 Reply time]
Success -->|No| LogError[Log: ❌ LLM error]
Success -->|Timeout| LogTimeout[Log: ❌ Timeout]
LogReply --> SendReply[channel.send reply]
LogError --> SendError[channel.send error msg]
LogTimeout --> SendTimeout[channel.send timeout msg]
SendReply --> Done[Message complete]
SendError --> Done
SendTimeout --> Done
Done --> NextWorker[Join next worker]
NextWorker --> WorkerPool
classDef channel fill:#E8F4FD,stroke:#4A90E2
classDef queue fill:#FFF4E6,stroke:#F5A623
classDef process fill:#FDE8E8,stroke:#D0021B
classDef success fill:#E8FDF5,stroke:#50C878
class TG,DC,SL,IM,MX,SIG,WA,Email,IRC,Lark,DT,QQ channel
class MPSC,Semaphore,WorkerPool queue
class Process,LogReceive,MemoryRecall,AutoSave,StartTyping,Timeout,AgentCall,StopTyping process
class LogReply,SendReply,Done,NextWorker success
```
---
## 8. Memory System Architecture
**Storage backends and data flow:**
```mermaid
flowchart TB
subgraph Frontend[Memory Frontends]
AutoSave[Auto-save hooks<br/>user_msg, assistant_resp]
StoreTool[memory_store tool]
RecallTool[memory_recall tool]
ForgetTool[memory_forget tool]
GetTool[memory_get tool]
ListTool[memory_list tool]
CountTool[memory_count tool]
end
subgraph Backends[Memory Backends]
Sqlite[(sqlite<br/>Default, local file)]
Markdown[(markdown<br/>Daily .md files)]
Lucid[(lucid<br/>Cloud sync)]
None[(none<br/>In-memory only)]
end
subgraph Categories[Memory Categories]
Conv[Conversation<br/>Chat transcripts]
Daily[Daily<br/>Session summaries]
Core[Core<br/>Long-term facts]
end
AutoSave --> MemoryTrait[Memory trait]
StoreTool --> MemoryTrait
RecallTool --> MemoryTrait
ForgetTool --> MemoryTrait
GetTool --> MemoryTrait
ListTool --> MemoryTrait
CountTool --> MemoryTrait
MemoryTrait --> Factory[create_memory factory]
Factory -->|config.memory.backend| BackendSelect{Backend?}
BackendSelect -->|sqlite| Sqlite
BackendSelect -->|markdown| Markdown
BackendSelect -->|lucid| Lucid
BackendSelect -->|none| None
Sqlite --> Categories
Markdown --> Categories
Lucid --> Categories
Categories --> Storage[(Persistent Storage)]
RAG[Hardware RAG] -.->|load_chunks| Markdown
classDef frontend fill:#E8F4FD,stroke:#4A90E2
classDef backend fill:#FFF4E6,stroke:#F5A623
classDef category fill:#E8FDF5,stroke:#50C878
classDef storage fill:#FDE8E8,stroke:#D0021B
class AutoSave,StoreTool,RecallTool,ForgetTool,GetTool,ListTool,CountTool frontend
class Sqlite,Markdown,Lucid,None backend
class Conv,Daily,Core category
class Storage storage
```
---
## 9. Provider and Model Routing
**LLM provider abstraction and routing:**
```mermaid
flowchart TB
subgraph Providers[Supported Providers]
OR[OpenRouter]
Anth[Anthropic]
OAI[OpenAI]
OpenRouter[openrouter]
MiniMax[minimax]
DeepSeek[deepseek]
Kimi[kimi]
Custom[custom URL]
end
subgraph Routing[Model Routing]
Routes[model_routes config<br/>Pattern -> Provider]
end
subgraph Factory[Provider Factory]
Resilient[create_resilient_provider<br/>Retry + Timeout]
Routed[create_routed_provider<br/>Model-based routing]
end
subgraph Traits[Provider Trait]
ChatSystem[chat_with_system<br/>Simple chat]
ChatHistory[chat_with_history<br/>Multi-turn]
ChatTools[chat_with_tools<br/>Native function calling]
Warmup[warmup<br/>Connection pool warmup]
SupportsNative[supports_native_tools<br/>Capability check]
end
Providers --> Factory
Routes --> Factory
Factory --> Traits
ChatSystem --> LLM1[LLM API Call]
ChatHistory --> LLM2[LLM API Call]
ChatTools --> LLM3[LLM API Call + Functions]
LLM1 --> Response[ChatMessage<br/>text + role]
LLM2 --> Response
LLM3 --> ToolResponse[ChatMessage + ToolCalls<br/>id, name, arguments]
classDef provider fill:#E8F4FD,stroke:#4A90E2
classDef routing fill:#FFF4E6,stroke:#F5A623
classDef factory fill:#E8FDF5,stroke:#50C878
classDef trait fill:#FDE8E8,stroke:#D0021B
class OR,Anth,OAI,OpenRouter,MiniMax,DeepSeek,Kimi,Custom provider
class Routes routing
class Resilient,Routed factory
class ChatSystem,ChatHistory,ChatTools,Warmup,SupportsNative trait
```
---
## 10. Tool Execution Architecture
**Tool registry, execution, and security:**
```mermaid
flowchart TB
subgraph ToolCategories[Tool Categories]
Core[Core Tools<br/>shell, file_read, file_write]
Memory[Memory Tools<br/>store, recall, forget]
Schedule[Schedule Tools<br/>cron_add, cron_list, etc.]
Browser[Browser<br/>Brave integration]
Composio[Composio<br/>1000+ app actions]
Hardware[Hardware<br/>gpio_read, gpio_write,<br/>arduino_upload, etc.]
Delegate[Delegate<br/>Sub-agent routing]
Screenshot[screenshot<br/>Screen capture]
end
subgraph Registry[Tool Registry]
AllTools[all_tools_with_runtime<br/>Factory function]
DefaultTools[default_tools<br/>Base set]
PeripheralTools[create_peripheral_tools<br/>Hardware-specific]
end
subgraph Security[Security Policy]
AllowedCmds[allowed_commands<br/>Allowlist]
WorkspaceOnly[workspace_only<br/>Path restriction]
MaxActions[max_actions_per_hour<br/>Rate limit]
MaxCost[max_cost_per_day_cents<br/>Cost cap]
Approval[approval manager<br/>Supervised tools]
end
subgraph Execution[Tool Execution]
Validate[Input validation<br/>Schema check]
Approve{Approval<br/>needed?}
Execute[execute async]
Scrub[Scrub credentials<br/>from output]
Result[ToolResult<br/>success, output, error]
end
ToolCategories --> Registry
Registry --> Security
Security --> Execution
Validate --> Approve
Approve -->|Yes| Prompt[Prompt CLI]
Approve -->|No / Approved| Execute
Approve -->|Denied| Denied[Return denied]
Prompt --> UserChoice{User choice?}
UserChoice -->|Yes| Execute
UserChoice -->|No| Denied
Execute --> Scrub
Scrub --> Result
Result --> Return[Return to agent loop]
classDef tools fill:#E8F4FD,stroke:#4A90E2
classDef registry fill:#FFF4E6,stroke:#F5A623
classDef security fill:#FDE8E8,stroke:#D0021B
classDef exec fill:#E8FDF5,stroke:#50C878
class Core,Memory,Schedule,Browser,Composio,Hardware,Delegate,Screenshot tools
class AllTools,DefaultTools,PeripheralTools registry
class AllowedCmds,WorkspaceOnly,MaxActions,MaxCost,Approval security
class Validate,Approve,Prompt,Execute,Scrub,Result,Return exec
```
---
## 11. Configuration Loading
**How configuration is loaded and merged:**
```mermaid
flowchart TB
Start[Config::load_or_init] --> Exists{Config file<br/>exists?}
Exists -->|No| RunWizard[Run onboard wizard]
RunWizard --> Save[Save config.toml]
Save --> Load[Load from file]
Exists -->|Yes| Load
Load --> Parse[TOML parse]
Parse --> Defaults[Apply defaults<br/>Config::default]
Defaults --> EnvOverrides[apply_env_overrides<br/>ZEROCLAW_* env vars]
EnvOverrides --> Validate[Schema validation]
Validate --> Valid{Valid?}
Valid -->|No| Error[[Error: invalid config]]
Valid -->|Yes| Complete[Complete Config]
Complete --> Paths[Paths<br/>workspace_dir, config_path]
Complete --> Providers[default_provider,<br/>api_key, api_url]
Complete --> Model[default_model,<br/>default_temperature]
Complete --> Gateway[gateway config<br/>port, host, pairing]
Complete --> Channels[channels_config<br/>telegram, discord, etc.]
Complete --> Memory[memory config<br/>backend, auto_save]
Complete --> Security[autonomy config<br/>level, allowed_commands]
Complete --> Reliability[reliability config<br/>timeouts, retries]
Complete --> Observability[observability<br/>backend, metrics]
Complete --> Runtime[runtime config<br/>kind, exec]
Complete --> Peripherals[peripherals<br/>boards, datasheet_dir]
Complete --> Cron[cron config<br/>enabled, db_path]
Complete --> Composio[composio<br/>enabled, api_key]
Complete --> Browser[browser<br/>enabled, allowlist]
Complete --> Tunnel[tunnel<br/>provider, token]
classDef config fill:#E8F4FD,stroke:#4A90E2
classDef error fill:#FDE8E8,stroke:#D0021B
classDef section fill:#FFF4E6,stroke:#F5A623
class Load,Parse,Defaults,EnvOverrides,Validate,Complete config
class Error error
class Paths,Providers,Model,Gateway,Channels,Memory,Security,Reliability,Observability,Runtime,Peripherals,Cron,Composio,Browser,Tunnel section
```
---
## 12. Hardware Peripherals Integration
**Hardware board support and control:**
```mermaid
flowchart TB
subgraph Boards[Supported Boards]
Nucleo[Nucleo-F401RE<br/>STM32F401RETx]
Uno[Arduino Uno<br/>ATmega328P]
UnoQ[Uno Q<br/>ESP32 WiFi bridge]
RPi[RPi GPIO<br/>Native Linux]
ESP32[ESP32<br/>Direct serial]
end
subgraph Transport[Transport Layer]
Serial[Serial port<br/>/dev/ttyACM0, /dev/ttyUSB0]
USB[USB probe-rs<br/>ST-Link JTAG]
Native[Native GPIO<br/>Linux sysfs]
end
subgraph Peripherals[Peripheral System]
Create[create_peripheral_tools<br/>Factory function]
GPIO[gpio_read/write<br/>Digital I/O]
Upload[arduino_upload<br/>Sketch flash]
MemMap[hardware_memory_map<br/>Address ranges]
BoardInfo[hardware_board_info<br/>Chip identification]
MemRead[hardware_memory_read<br/>Register dump]
Capabilities[hardware_capabilities<br/>Pin enumeration]
end
subgraph RAG[Hardware RAG]
Datasheets[datasheet_dir<br/>.md documentation]
Chunks[Chunked embedding<br/>Semantic search]
PinAliases[Pin alias mapping<br/>red_led → 13]
end
Boards --> Transport
Transport --> Peripherals
RAG -.->|Context injection| Peripherals
Create --> ToolRegistry[Tool registry]
GPIO --> ToolRegistry
Upload --> ToolRegistry
MemMap --> ToolRegistry
BoardInfo --> ToolRegistry
MemRead --> ToolRegistry
Capabilities --> ToolRegistry
ToolRegistry --> Agent[Agent loop integration]
classDef board fill:#E8F4FD,stroke:#4A90E2
classDef transport fill:#FFF4E6,stroke:#F5A623
classDef peripheral fill:#E8FDF5,stroke:#50C878
classDef rag fill:#FDE8E8,stroke:#D0021B
class Nucleo,Uno,UnoQ,RPi,ESP32 board
class Serial,USB,Native transport
class Create,GPIO,Upload,MemMap,BoardInfo,MemRead,Capabilities,ToolRegistry peripheral
class Datasheets,Chunks,PinAliases rag
```
---
## 13. Observable Events
**Telemetry and observability flow:**
```mermaid
flowchart TB
subgraph Observers[Observer Backends]
Noop[NoopObserver<br/>No-op / testing]
Console[ConsoleObserver<br/>Stdout logging]
Metrics[MetricsObserver<br/>Prometheus format]
end
subgraph Events[Observable Events]
AgentStart[AgentStart<br/>provider, model]
LlmRequest[LlmRequest<br/>provider, model, msg_count]
LlmResponse[LlmResponse<br/>duration, success, error]
ToolCallStart[ToolCallStart<br/>tool name]
ToolCall[ToolCall<br/>tool, duration, success]
TurnComplete[TurnComplete<br/>end of agent loop]
AgentEnd[AgentEnd<br/>duration, tokens, cost]
end
subgraph Outputs[Outputs]
Stdout[stdout trace logs]
MetricsFile[metrics.json<br/>JSON lines]
Prometheus[Prometheus<br/>Text format]
end
Events --> Observers
Observers --> Outputs
AgentStart --> Record[record_event]
LlmRequest --> Record
LlmResponse --> Record
ToolCallStart --> Record
ToolCall --> Record
TurnComplete --> Record
AgentEnd --> Record
Record --> Dispatch[Dispatch to backend]
Dispatch --> Console
Dispatch --> Metrics
Console --> Stdout
Metrics --> MetricsFile
classDef observer fill:#E8F4FD,stroke:#4A90E2
classDef event fill:#FFF4E6,stroke:#F5A623
classDef output fill:#E8FDF5,stroke:#50C878
class Noop,Console,Metrics observer
class AgentStart,LlmRequest,LlmResponse,ToolCallStart,ToolCall,TurnComplete,AgentEnd,Record,Dispatch event
class Stdout,MetricsFile,Prometheus output
```
---
## Summary Diagram
**Quick reference overview:**
```mermaid
mindmap
root((ZeroClaw))
Modes
Agent CLI
Interactive
Single-shot
Gateway
HTTP API
Webhooks
Daemon
Supervised
Multi-component
Channels
12+ platforms
Components
Agent Loop
Tool calling
Memory aware
Providers
50+ LLMs
Model routing
Channels
Real-time
Supervised
Tools
30+ tools
Hardware control
Memory
4 backends
RAG-capable
Security
Pairing
Approval
Policy
Integrations
Composio
1000+ apps
Browser
Brave
Tunnel
Cloudflare
boringproxy
Hardware
STM32
Arduino
ESP32
RPi GPIO
```
---
*Generated for ZeroClaw v0.1.0 - Architecture Documentation*

View File

Before

Width:  |  Height:  |  Size: 23 KiB

After

Width:  |  Height:  |  Size: 23 KiB

View File

Before

Width:  |  Height:  |  Size: 1.6 MiB

After

Width:  |  Height:  |  Size: 1.6 MiB

View File

Before

Width:  |  Height:  |  Size: 1.1 MiB

After

Width:  |  Height:  |  Size: 1.1 MiB

View File

@ -5,10 +5,10 @@ For contributors, reviewers, and maintainers.
## Core Policies
- Contribution guide: [../../CONTRIBUTING.md](../../CONTRIBUTING.md)
- PR workflow rules: [../pr-workflow.md](../pr-workflow.md)
- Reviewer playbook: [../reviewer-playbook.md](../reviewer-playbook.md)
- CI map and ownership: [../ci-map.md](../ci-map.md)
- Actions source policy: [../actions-source-policy.md](../actions-source-policy.md)
- PR workflow rules: [./pr-workflow.md](./pr-workflow.md)
- Reviewer playbook: [./reviewer-playbook.md](./reviewer-playbook.md)
- CI map and ownership: [./ci-map.md](./ci-map.md)
- Actions source policy: [./actions-source-policy.md](./actions-source-policy.md)
## Suggested Reading Order

View File

@ -7,7 +7,7 @@ This document defines the current GitHub Actions source-control policy for this
- Repository Actions permissions: enabled
- Allowed actions mode: selected
Selected allowlist (all actions currently used across CI, Beta Release, and Promote Release workflows):
Selected allowlist (all actions currently used across Quality Gate, Release Beta, and Release Stable workflows):
| Action | Used In | Purpose |
|--------|---------|---------|
@ -33,9 +33,9 @@ Equivalent allowlist patterns:
| Workflow | File | Trigger |
|----------|------|---------|
| CI | `.github/workflows/ci.yml` | Pull requests to `master` |
| Beta Release | `.github/workflows/release.yml` | Push to `master` |
| Promote Release | `.github/workflows/promote-release.yml` | Manual `workflow_dispatch` |
| Quality Gate | `.github/workflows/checks-on-pr.yml` | Pull requests to `master` |
| Release Beta | `.github/workflows/release-beta-on-push.yml` | Push to `master` |
| Release Stable | `.github/workflows/release-stable-manual.yml` | Manual `workflow_dispatch` |
## Change Control
@ -62,6 +62,7 @@ gh api repos/zeroclaw-labs/zeroclaw/actions/permissions/selected-actions
## Change Log
- 2026-03-10: Renamed workflows — CI → Quality Gate (`checks-on-pr.yml`), Beta Release → Release Beta (`release-beta-on-push.yml`), Promote Release → Release Stable (`release-stable-manual.yml`). Added `lint` and `security` jobs to Quality Gate. Added Cross-Platform Build (`cross-platform-build-manual.yml`).
- 2026-03-05: Complete workflow overhaul — replaced 22 workflows with 3 (CI, Beta Release, Promote Release)
- Removed patterns no longer in use: `DavidAnson/markdownlint-cli2-action@*`, `lycheeverse/lychee-action@*`, `EmbarkStudios/cargo-deny-action@*`, `rustsec/audit-check@*`, `rhysd/actionlint@*`, `sigstore/cosign-installer@*`, `Checkmarx/vorpal-reviewdog-github-action@*`, `useblacksmith/*`
- Added: `Swatinem/rust-cache@*` (replaces `useblacksmith/*` rust-cache fork)

View File

@ -90,7 +90,7 @@ Place PDFs in the datasheet directory. They are extracted and chunked for RAG.
2. **Add to config**`zeroclaw peripheral add my-board /dev/ttyUSB0`
3. **Implement a peripheral** (optional) — For custom protocols, implement the `Peripheral` trait in `src/peripherals/` and register in `create_peripheral_tools`.
See `docs/hardware-peripherals-design.md` for the full design.
See [`docs/hardware/hardware-peripherals-design.md`](../hardware/hardware-peripherals-design.md) for the full design.
## Adding a Custom Tool

View File

@ -14,7 +14,7 @@ All measurements are clean `cargo +nightly build --release`. MIR-precise mode re
## CI Integration
The workflow [`.github/workflows/ci-build-fast.yml`](../.github/workflows/ci-build-fast.yml) runs an accelerated release build alongside the standard one. It triggers on Rust-code changes and workflow changes, does not gate merges, and runs in parallel as a non-blocking check.
The workflow `.github/workflows/ci-build-fast.yml` (not yet implemented) is intended to run an accelerated release build alongside the standard one. It triggers on Rust-code changes and workflow changes, does not gate merges, and runs in parallel as a non-blocking check.
CI uses a resilient two-path strategy:
- **Fast path**: install `cargo-slicer` plus the `rustc-driver` binaries and run the MIR-precise sliced build.

View File

@ -0,0 +1,53 @@
# Change Playbooks
Step-by-step guides for common extension and modification patterns in ZeroClaw.
## Adding a Provider
- Implement `Provider` in `src/providers/`.
- Register in `src/providers/mod.rs` factory.
- Add focused tests for factory wiring and error paths.
- Avoid provider-specific behavior leaks into shared orchestration code.
## Adding a Channel
- Implement `Channel` in `src/channels/`.
- Keep `send`, `listen`, `health_check`, typing semantics consistent.
- Cover auth/allowlist/health behavior with tests.
## Adding a Tool
- Implement `Tool` in `src/tools/` with strict parameter schema.
- Validate and sanitize all inputs.
- Return structured `ToolResult`; avoid panics in runtime path.
## Adding a Peripheral
- Implement `Peripheral` in `src/peripherals/`.
- Peripherals expose `tools()` — each tool delegates to the hardware (GPIO, sensors, etc.).
- Register board type in config schema if needed.
- See `docs/hardware/hardware-peripherals-design.md` for protocol and firmware notes.
## Security / Runtime / Gateway Changes
- Include threat/risk notes and rollback strategy.
- Add/update tests or validation evidence for failure modes and boundaries.
- Keep observability useful but non-sensitive.
- For `.github/workflows/**` changes, include Actions allowlist impact in PR notes and update `docs/contributing/actions-source-policy.md` when sources change.
## Docs System / README / IA Changes
- Treat docs navigation as product UX: preserve clear pathing from README -> docs hub -> SUMMARY -> category index.
- Keep top-level nav concise; avoid duplicative links across adjacent nav blocks.
- When runtime surfaces change, update related references in `docs/reference/`.
- Keep multilingual entry-point parity for all supported locales (`en`, `zh-CN`, `ja`, `ru`, `fr`, `vi`) when nav or key wording changes.
- When shared docs wording changes, sync corresponding localized docs in the same PR (or explicitly document deferral and follow-up PR).
## Architecture Boundary Rules
- Extend capabilities by adding trait implementations + factory wiring first; avoid cross-module rewrites for isolated features.
- Keep dependency direction inward to contracts: concrete integrations depend on trait/config/util layers, not on other concrete integrations.
- Avoid cross-subsystem coupling (e.g., provider code importing channel internals, tool code mutating gateway policy directly).
- Keep module responsibilities single-purpose: orchestration in `agent/`, transport in `channels/`, model I/O in `providers/`, policy in `security/`, execution in `tools/`.
- Introduce new shared abstractions only after repeated use (rule-of-three), with at least one real caller.
- For config/schema changes, treat keys as public contract: document defaults, compatibility impact, and migration/rollback path.

View File

@ -2,7 +2,7 @@
This document explains what each GitHub workflow does, when it runs, and whether it should block merges.
For event-by-event delivery behavior across PR, merge, push, and release, see [`.github/workflows/master-branch-flow.md`](../.github/workflows/master-branch-flow.md).
For event-by-event delivery behavior across PR, merge, push, and release, see [`.github/workflows/master-branch-flow.md`](../../.github/workflows/master-branch-flow.md).
## Merge-Blocking vs Optional
@ -102,14 +102,14 @@ Merge-blocking checks should stay small and deterministic. Optional checks are u
## Maintenance Rules
- Keep merge-blocking checks deterministic and reproducible (`--locked` where applicable).
- Follow `docs/release-process.md` for verify-before-publish release cadence and tag discipline.
- Follow [`docs/contributing/release-process.md`](./release-process.md) for verify-before-publish release cadence and tag discipline.
- Keep merge-blocking rust quality policy aligned across `.github/workflows/ci-run.yml`, `dev/ci.sh`, and `.githooks/pre-push` (`./scripts/ci/rust_quality_gate.sh` + `./scripts/ci/rust_strict_delta_gate.sh`).
- Use `./scripts/ci/rust_strict_delta_gate.sh` (or `./dev/ci.sh lint-delta`) as the incremental strict merge gate for changed Rust lines.
- Run full strict lint audits regularly via `./scripts/ci/rust_quality_gate.sh --strict` (for example through `./dev/ci.sh lint-strict`) and track cleanup in focused PRs.
- Keep docs markdown gating incremental via `./scripts/ci/docs_quality_gate.sh` (block changed-line issues, report baseline issues separately).
- Keep docs link gating incremental via `./scripts/ci/collect_changed_links.py` + lychee (check only links added on changed lines).
- Prefer explicit workflow permissions (least privilege).
- Keep Actions source policy restricted to approved allowlist patterns (see `docs/actions-source-policy.md`).
- Keep Actions source policy restricted to approved allowlist patterns (see [`docs/contributing/actions-source-policy.md`](./actions-source-policy.md)).
- Use path filters for expensive workflows when practical.
- Keep docs quality checks low-noise (incremental markdown + incremental added-link checks).
- Keep dependency update volume controlled (grouping + PR limits).

View File

@ -84,7 +84,7 @@ You represent that:
## 6. No Trademark Rights
This CLA does not grant you any rights to use the ZeroClaw name,
trademarks, service marks, or logos. See TRADEMARK.md for trademark policy.
trademarks, service marks, or logos. See [trademark.md](../maintainers/trademark.md) for trademark policy.
---

Some files were not shown because too many files have changed in this diff Show More