semvec/pypi-packages huggingface dataset:
mcpt-pathway 0.1.2
Learning-aware journey state model
Requires Python: >=3.11
Keywords: append-only, branching, event-sourcing, journey, learning, mcp, state-management, undo-as-navigation

# Pathway Core v0.1

**Pathway Core is an append-only journey engine where undo never erases learning.**

Undo is navigation. Learning persists.

## Philosophy

Traditional undo rewrites history. Pathway doesn't.

When you backtrack in Pathway, you create a new event pointing backward—the original path remains. When you learn something on a failed path, that knowledge persists. Your mistakes teach you; they don't disappear.

This makes Pathway fundamentally honest about what happened.

## Features

- **Append-only event log**: Events are never edited or deleted
- **Undo = pointer move**: Backtracking creates a new event and moves head
- **Learning persists**: Knowledge survives across backtracking and branches
- **Branching is first-class**: Git-like implicit divergence on new work after backtrack

## Quick Start

```bash
# Install
pip install -e ".[dev]"

# Initialize database
python -m pathway.cli init

# Import sample session
python -m pathway.cli import sample_session.jsonl

# View derived state
python -m pathway.cli state sess_001

# Start API server
python -m pathway.cli serve
```

## API Endpoints

- `POST /events` - Append an event
- `GET /session/{id}/state` - Get derived state (JourneyView, LearnedView, ArtifactView)
- `GET /session/{id}/events` - Get raw events
- `GET /sessions` - List all sessions
- `GET /event/{id}` - Get single event

## Event Types

14 event types covering the full journey lifecycle:

| Type | Purpose |
|------|---------|
| IntentCreated | User's goal and context |
| TrailVersionCreated | The learning path/map |
| WaypointEntered | Navigation through trail |
| ChoiceMade | User makes a branching decision |
| StepCompleted | User completes a waypoint |
| Blocked | User hits friction |
| Backtracked | User goes back (undo) |
| Replanned | Trail is revised |
| Merged | Branches converge |
| ArtifactCreated | Output produced |
| ArtifactSuperseded | Old output replaced |
| PreferenceLearned | How user likes to learn |
| ConceptLearned | What user understands |
| ConstraintLearned | User's environment facts |

## Derived Views

The system computes three views from events:

1. **JourneyView**: Current position, branches, visited waypoints
2. **LearnedView**: Preferences, concepts, constraints with confidence scores
3. **ArtifactView**: All outputs with supersedence tracking

## Security

- **API key**: Set `PATHWAY_API_KEY` env var to protect write endpoints
- **Payload limit**: 1MB default (configure via `PATHWAY_MAX_PAYLOAD_SIZE`)
- **Session ID validation**: Alphanumeric + underscore/hyphen, max 128 chars

## Testing

```bash
pytest  # 73 tests covering invariants, API, reducers, store
```

## Architecture

```
pathway/
├── models/         # Pydantic models for events and views
├── store/          # SQLite event store + JSONL import/export
├── reducers/       # Compute derived views from events
├── api/            # FastAPI endpoints
└── cli.py          # Command-line tools
```
roly 0.1.0
Add your description here
Requires Python: >=3.12

<p align="center">
  <img src="assets/logo_wordmark_trebus.svg" alt="Roly logo" width="640">
</p>

<h1 align="center">Roly</h1>

<p align="center">
  Deterministic role assembly for coding-agent workflows.
</p>

Roly helps build reusable role instructions that are composable, reviewable, and predictable.
No hidden merges. No implicit magic. Just a clean CLI flow from role definition to generated output.

## Quick Start

Run from source:

```bash
uv sync
uv run roly list --no-color
```

Assemble your first role output:

```bash
uv run roly assemble \
  --role code-review \
  --role project-audit \
  --name reviewer-ad-hoc \
  --no-color
```

Prefer config-based assembly:

```bash
uv run roly assemble --config examples/roly.config --user-role reviewer-default --no-color
```

## Why Roly

- Deterministic every time: one top-level role plus ordered sub-roles, assembled in a fixed order.
- Scope-aware by default: project, user, and built-in roles with explicit precedence.
- Safe review workflow: proposed sub-role edits go through interactive accept/reject approval.
- Explicit promotion model: project-local edits only become user-level when you promote them.

## What You Can Do

List available roles:

```bash
uv run roly list --no-color
```

Compare project-local vs user-level role definitions:

```bash
uv run roly diff --role code-review --no-color
```

Promote a project-local role to user-level:

```bash
uv run roly promote --role code-review --yes --no-color
```

Run interactive review + apply flow:

```bash
uv run roly review --target-sub-role code-review --target-sub-role project-audit --changes-file changes.toml --no-color
```

Create/setup review skill assets:

```bash
uv run roly setup --agent none --yes --no-color
```

## How It Works

1. Define roles as markdown files with TOML front matter.
2. Select ordered role slugs; dependency top-level role is auto-inserted for each sub-role.
3. Assemble deterministic output artifacts from role content + output definitions.
4. Keep experimental edits project-local, then promote only when ready.

## Example Use Cases

- Standardize engineering review prompts across repositories.
- Layer domain overlays (security, compliance, architecture) without copy-paste.
- Run repeatable role updates with human approval in the loop.
- Keep team prompts versioned, diffable, and shareable.

## Docs For Contributors

Development setup, lint/test commands, and contributor workflows are in `README_DEV.md`.
ptestx 1.1.0
综合测试框架 - 用于管理测试环境、测试对象和测试用例的完整生命周期
Requires Python: >=3.12

# ptest - 综合测试框架

ptest是一个全面的测试框架，用于管理测试环境、测试对象和测试用例。

## 📚 完整文档

完整的文档请访问 [docs/](../docs/) 目录：

- **[用户指南](./docs/user-guide/README.md)** - 快速开始和使用说明
- **[架构文档](./docs/architecture/)** - 系统设计和架构说明  
- **[使用指南](./docs/guides/)** - 详细的使用指南
- **[开发文档](./docs/development/)** - 开发规范和贡献指南
- **[API文档](./docs/api/)** - 接口和数据格式说明

## 🚀 快速开始

### 安装
```bash
pip install .
```

### 初始化测试环境
```bash
ptest init --path /home/test/
```

### 管理测试对象
以Mysql为例
```bash
# 安装MySQL对象
ptest obj install mysql my_mysql_db --version 9.9.9

# 启动MySQL对象
ptest obj start my_mysql_db

# 列出所有对象
ptest obj list
```

### 管理测试用例
```bash
# 添加测试用例
ptest case add mysql_connection_test '{"type": "connection", "description": "Test MySQL connection"}'

# 运行特定测试用例
ptest case run mysql_connection_test

# 运行所有测试用例
ptest run all
```

### 生成报告
```bash
# 生成HTML报告
ptest report --format html

# 生成JSON报告
ptest report --format json
```

### 查看状态
```bash
ptest status
```

### 命令别名
同时提供了```p```作为简写命令：
```bash
p init --path /home/test/
p obj install mysql my_mysql_db
p run all
```

## 📖 更多信息

查看 [docs/](../docs/) 目录获取完整的文档，包括：

- 详细的架构设计文档
- 数据库配置和使用指南
- 测试执行引擎说明
- 开发规范和贡献指南
- API 接口文档

---

*ptest - 综合测试框架，让测试变得简单而强大！*
jlabx 0.2.2
Launch JupyterLab with extensions — no install, no config, just go
Requires Python: >=3.10
Keywords: extensions, jupyter, jupyterlab, uv

# jlabx

Launch JupyterLab with extensions — without touching your project's dependencies. Works with both **uv** and **pixi** projects.

```bash
uv tool install jlabx
jlabx
```

## Why?

You're working in a repo with a `pyproject.toml` or `pixi.toml`, but you want JupyterLab with vim bindings, LSP, collaboration, and other extensions. You can't (or don't want to) add them as project dependencies. jlabx manages extensions separately and injects them at launch time — auto-detecting whether you're in a uv or pixi environment.

## Quick start

```bash
# Install
uv tool install jlabx
```

In a project with a `pyproject.toml` or `pixi.toml`:

```bash
jlabx
```

Launch a single notebook — imports are auto-detected and mapped to PyPI packages:

```bash
jlabx analysis.ipynb
```

```bash
# Persist auto-detected deps as PEP 723 metadata in the notebook
jlabx notebook.ipynb --init-deps

# Force uv even in a pixi project
jlabx --uv

# Manage extensions
jlabx list                  # Show configured extensions
jlabx add jupyterlab-vim    # Add an extension
jlabx remove jupyterlab-vim # Remove an extension
```

## Core extensions (always included)

- jupyterlab
- jupyter-collaboration
- jupyter-lsp
- python-lsp-server

## Environment detection

jlabx auto-detects your environment:

| Files in cwd | Mode | How it launches |
|---|---|---|
| `pixi.toml` / `pixi.lock` | Pixi | `pixi run jupyter-lab` |
| `pyproject.toml` | Python project | `uv run --with <extensions> jupyter-lab` |
| Neither | Standalone | `uvx --from jupyterlab --with <extensions> jupyter-lab` |

## Config

Extensions are stored in `~/.config/jlabx/config.toml` (or `$XDG_CONFIG_HOME/jlabx/config.toml`). Created automatically on first run.

## Documentation

**Full docs: https://ianhi.github.io/jlabx/**

## License

MIT
codebatch 0.1.0
Content-addressed batch execution engine
Requires Python: >=3.10
Keywords: batch, content-addressed, deterministic, execution

# CodeBatch

Content-addressed batch execution engine with deterministic sharding and queryable outputs.

## Overview

CodeBatch provides a filesystem-based execution substrate for running deterministic transformations over codebases. It captures inputs as immutable snapshots, executes work in isolated shards, and indexes all semantic outputs for efficient querying—without requiring a database.

## Documentation

- **[SPEC.md](./SPEC.md)** — Full storage and execution specification
- **[CHANGELOG.md](./CHANGELOG.md)** — Version history

## Spec Versioning

The specification uses semantic versioning with draft/stable markers. Each version is tagged in git (e.g., `spec-v1.0-draft`). Breaking changes increment the major version. Implementations should declare which spec version they target and tolerate unknown fields for forward compatibility.

## Project Structure

```
schemas/      JSON Schema definitions for all record types
src/          Core implementation
tests/        Test suites and fixtures
examples/     Usage examples
.github/      CI/CD workflows
```

## Quick Start

```bash
# Create a snapshot of a directory
codebatch snapshot ./my-project --store ./store

# Initialize a batch with a pipeline
codebatch batch init --snapshot <id> --pipeline parse

# Run a shard
codebatch run-shard --batch <id> --task 01_parse --shard ab

# Query results
codebatch query diagnostics --batch <id> --task 01_parse
```

## License

MIT
topydo 0.16
A powerful todo.txt application for the console

topydo - a powerful todo.txt application
========================================

[![Build Status](https://travis-ci.org/topydo/topydo.svg?branch=master)](https://travis-ci.org/topydo/topydo) [![codecov.io](https://codecov.io/github/topydo/topydo/coverage.svg?branch=master)](https://codecov.io/github/topydo/topydo?branch=master) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/2957b80fffa0460bbb0e1ff7948f0ee7)](https://www.codacy.com/app/bram85/topydo?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=bram85/topydo&amp;utm_campaign=Badge_Grade) [![PyPI version](https://badge.fury.io/py/topydo.svg)](https://badge.fury.io/py/topydo)

topydo is a powerful todo list application using the [todo.txt format][1].

It has three user interfaces:

* Command Line Interface (CLI) - originally inspired by the [todo.txt CLI][2]
  by Gina Trapani.
* Prompt mode - a convenience mode for the CLI. Launch with `topydo prompt`.
* Column mode - a text based user interface (TUI) with customizable columns and
  vim-like bindings. Launch with `topydo columns`.

![png][6]

Features
--------

Feature-wise, the todo.txt format is quite limited, but can be extended using
tags. topydo natively supports some of these tags to implement:

* **Due** and **start dates**;
* Maintain **dependencies** between todo items;
* **recurring** todo items;

topydo also offers:

* Fine-grained control on **sorting** and **grouping** items;
* Customizable output;
* Some conveniences when adding new items (e.g. adding creation date and use
  **relative dates**);
* Additional output formats to iCalendar, JSON and Graphviz Dot;
* Aliases for frequently used commands.
* Text based todo identifiers, which are more stable and convenient than
  line-based todo identifiers.

Yet, topydo is fully todo.txt compliant. The text file can be processed by
other todo.txt tools (but they may not interpret the tags properly).

The documentation on [the TiddlyWiki][4] provides more information about the
features and how to use topydo.

Installation
------------

Simply install with:

    pip3 install topydo

If you wish to use column mode: install additional dependencies with:

    pip3 install topydo[columns]

Similarly, for prompt mode you can install additional dependencies with:

    pip3 install topydo[prompt]

Demo
----

CLI mode:

![gif][5]

[1]: https://github.com/ginatrapani/todo.txt-cli/wiki/The-Todo.txt-Format
[2]: https://github.com/ginatrapani/todo.txt-cli
[3]: https://github.com/bram85/todo.txt-tools
[4]: https://topydo.org/
[5]: https://raw.githubusercontent.com/topydo/topydo/master/docs/topydo.gif
[6]: https://raw.githubusercontent.com/topydo/topydo/master/docs/columns.png