semvec/pypi-packages huggingface dataset:
skill-manager-mcp 0.1.8
Self-steering skill management MCP with RAG-based prediction matching
Requires Python: >=3.10
Keywords: mcp, skills, rag, self-steering, claude-code, compound-intelligence

# Skill Manager

Self-steering skill management MCP with RAG-based prediction matching.

Part of the [GNOSYS](https://github.com/sancovp/gnosys) compound intelligence ecosystem.

## Features

- Create/manage skills compatible with Claude Code's skill format
- Skillsets for grouping related skills
- RAG-based skill search using ChromaDB
- SkillLog prediction matching for self-steering

## Usage

```bash
pip install skill-manager-mcp
```

Add to your MCP config:
```json
{
  "skill-manager": {
    "command": "skill-manager"
  }
}
```

## Tools

- `list_skills` - List all available skills
- `get_skill` - Get full skill content
- `create_skill` - Create a new skill
- `search_skills` - Semantic search for skills
- `match_skilllog` - Match SkillLog predictions
- `list_skillsets` - List skill groups
- `create_skillset` - Create skill group
- `activate_skillset` - Load all skills in a group
- `add_to_skillset` - Add skill to group
asset-db 0.0.3
A Python implementation of the asset Database.
Requires Python: >=3.10

# Open Asset Database

This package is a Python implementation of the
[Asset Database](https://github.com/owasp-amass/asset-db) from
the [OWASP Amass Project](https://github.com/owasp-amass/asset-db).

## Install

```bash
pip install asset-db
```

## Exemple

```python
from asset_db.repository.neo4j import NeoRepository
from asset_db.types import Edge
from asset_db.types import Entity
from oam import FQDN
from oam import IPAddress, IPAddressType
from oam import BasicDNSRelation
from oam import DNSRecordProperty
from oam import SourceProperty

uri = "neo4j://localhost"
auth = ("neo4j", "password")

with NeoRepository(uri, auth) as db:
    fqdn = db.create_asset(FQDN("owasp.org"))
    
    ip = db.create_entity(
        Entity(
            asset = IPAddress("104.20.44.163", IPAddressType.IPv4)))
    
    a_record  = db.create_edge(
        Edge(
            relation    = BasicDNSRelation("dns_record", rrtype=1),
            from_entity = fqdn,
            to_entity   = ip))
    
    txt_record = db.create_entity_property(
        fqdn,
        DNSRecordProperty("dns_record", "token=awes0me", 16))
    
    source = db.create_edge_property(
        a_record,
        SourceProperty("myscript", 100))
```

## Differences from upstream

In its current state, this repository only implements a Neo4j backend.

There is no :
- support for PostgreSQL or SQLite
- caching mechanism
- triple query interface

## License

This code is licensed under the Apache License version 2.0.

See the LICENSE file for details.
py-parry3d 0.0.1
Python bindings for parry3d collision detection, optimized for batch operations
Requires Python: >=3.11

# py-parry3d

Python bindings for [parry3d](https://parry.rs/) collision detection, optimized for batch operations with NumPy.

## Features

- **Batch-first**: Process millions of collision queries with minimal Python overhead
- **NumPy native**: Zero-copy data exchange using contiguous arrays
- **Parallel**: Automatic multi-threading via Rayon
- **Serializable**: Cache collision worlds with pre-built BVHs

## Installation

```bash
pip install py-parry3d
```

## Quick Start

```python
import numpy as np
import py_parry3d as pp

# Define collision shapes
robot_link = pp.CollisionGroup("robot", [pp.Capsule(half_height=0.4, radius=0.08)])
obstacle = pp.CollisionGroup("obstacle", [pp.Box(half_extents=[0.3, 0.3, 0.3])],
                              static=True, transform=np.eye(4))

# Create world
world = pp.CollisionWorld([robot_link, obstacle])

# Check collisions for 1000 robot poses
N = 1000
transforms = {"robot": np.random.rand(N, 4, 4)}  # Your actual transforms here
pairs = [("robot", "obstacle", 0.0)]  # (group_a, group_b, min_distance)

collisions = world.check(transforms, pairs)  # (N, 1) bool array
print(f"Collisions: {collisions.sum()} / {N}")
```

## Shapes

```python
# Primitives
pp.Box(half_extents=[0.5, 0.3, 0.2])
pp.Sphere(radius=0.1)
pp.Capsule(half_height=0.5, radius=0.1)  # Z-axis aligned
pp.Cylinder(half_height=0.5, radius=0.1)  # Z-axis aligned

# Meshes
pp.TriMesh(vertices, faces)  # (N,3) float64, (M,3) uint32
pp.TriMesh.from_trimesh(mesh)  # From trimesh object

# Convex hull (faster than TriMesh)
pp.ConvexHull_from_trimesh(mesh)
```

### Solid vs Hollow

| Shape | Type | Inside Detection |
|-------|------|------------------|
| Box, Sphere, Capsule, Cylinder, ConvexHull | **Solid** | Detects objects inside |
| TriMesh | **Hollow** | Surface contact only |

## API

### Groups and World

```python
# Dynamic group - transform provided at check time
robot = pp.CollisionGroup("robot", [shape1, shape2])

# Static group - fixed transform
env = pp.CollisionGroup("env", [shape], static=True, transform=tf)

# World
world = pp.CollisionWorld([robot, env])
```

### Collision Checking

```python
# Batch check
result = world.check(transforms, pairs)  # (N, n_pairs) bool array

# Early-exit (stops at first collision)
idx = world.check_any(transforms, pairs)  # int or None
```

### Pair Helpers

```python
# All pairs between groups
pairs = pp.all_pairs(["l1", "l2", "l3"], skip_adjacent=1)

# Groups vs target
pairs = pp.pairs_vs(["l1", "l2"], "obstacle", min_distance=0.05)
```

### Threading

```python
pp.set_num_threads(8)  # Default: all cores
```

### Serialization

```python
data = world.to_bytes()
world = pp.CollisionWorld.from_bytes(data)
# Pickle also supported
```

## Documentation

- [DESIGN.md](DESIGN.md) - Architecture and concepts
- [EXAMPLES.md](EXAMPLES.md) - Detailed usage examples

## License

MIT
belt-on 0.0.0
Throughput calculations for factory games.
Requires Python: >=3.14
Keywords: automation, games, factory

# belt-on 🔁
Throughput calculations for factory games. 

📘 **[Roadmap](./ROADMAP.md)** · 📝 **[Release Notes](https://github.com/apathetic-tools/belt-on/releases)**

**Automate your automations.**
*Throughput calculations for factory games.*

> [!NOTE]
> This project is largely AI-written and minimally polished. I rely on it, but I haven't reviewed every detail.
> Expect rough edges. Thoughtful issue reports are appreciated.

---

### ⚖️ License
- [MIT-a-NOAI License](LICENSE)

You’re free to use, copy, and modify the script under the standard MIT terms.  
The additional rider simply requests that this project not be used to train or fine-tune AI/ML systems until the author deems fair compensation frameworks exist.  
Normal use, packaging, and redistribution for human developers are unaffected.

---

> ✨ *AI was used to help draft language, formatting, and code — plus we just love em dashes.*

<p align="center">
  <sub>😐 <a href="https://apathetic-tools.github.io/">Apathetic Tools</a> © <a href="./LICENSE">MIT-a-NOAI</a></sub>
</p>