sam/obsidian-vault
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sam-4screen-desktop 2026-9-9:11:54:8

Browse Source
This commit is contained in:
Sam Rolfe
2026-09-09 11:54:08 +10:00
parent c120e56fef
commit 421c048602
8 changed files with 16 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
300 areas/350 AI/AI Design.md Normal file
View File

@@ -0,0 +1,100 @@
---
created: 2026-06-20 11:45
modified: 2026-06-20 11:52
type: reference
tags:
- ai-agents
- open-source
- automation
- ai
- tool
- tools
- design
- dev-ops
aliases:
- Agentic UI Pipeline
---
## 🛠️ The Local Stack
* **Visual Prototyping Engine**: **Penpot** (Self-hosted via local Docker container [Penpot]).
* **Visual Code Mutator**: **Onlook** (Reads/writes directly to local React components in place) [Onlook].
* **Headless Visuals**: **Chai Builder SDK** (Open-source developer React/Tailwind visual engine) [Chai Builder SDK].
* **Terminal Agent**: **Goose** (Block's autonomous developer agent run locally via terminal) [Goose].
* **Local Inference**: **Ollama** running `Qwen2.5-Coder` via Docker container [Ollama].
* **Sync Pipeline**: Shell script automation executing `rsync` to a target machine managed by **Caddy**.
---
## 🎨 The Plain-Text Design Engine (Google Stitch & DESIGN.md)
### 💡 Core Mechanics
* **Google Stitch Paradigm**: An open standard developed by Google Labs to feed design guidelines directly to AI agents [Google Stitch].
* **DESIGN.md Structure**: A standalone markdown file placed in your project root combining YAML design tokens with markdown prose explaining the visual rationale [DESIGN.md].
* **Penpot Integration**: Use Penpot's built-in Model Context Protocol (MCP) server [Penpot MCP] to connect your terminal agents. This translates your design shapes, tokens, and layouts straight into a machine-readable context file, bridging your visual wireframes with your coding engine.
### 🗂️ Scaling with Awesome-Design-MD
Instead of drafting schemas from scratch, pull standard markdown design sheets from **awesome-design-md** [awesome-design-md]:
* **Ready-Made Blueprints**: Features 55+ design languages reverse-engineered from platforms like Linear, Vercel, Stripe, and Supabase.
* **Drop-In Protocol**: Drop the curated markdown file into your project tree. Tell your agent pipeline: *"Review DESIGN.md and generate a settings view matching these visual guardrails"*.
---
## 🔄 Execution Flows
### Flow A: The Fully Terminal Pipeline (Goose + Ollama)
[User Pipeline / Pi Prompt] ----> [Goose CLI] ----> [Parses local DESIGN.md context]
|
v (Generates clean .tsx / Tailwind)
[Local Repo Workspace]
|
v
[rsync Script ----> VPS with Caddy]
### Flow B: The Visual/Agentic Hybrid (Onlook + Penpot Local)
[Visual Adjustment in Penpot/Onlook] ----> [Mutates local .tsx code file instantly]
|
v (Triggers local git tracking)
[Goose agent fixes states & connects backend logic]
|
v
[rsync Script ----> VPS with Caddy]
---
## 🚀 Terminal Extensions & Skills for Pi Agent
* **Penpot MCP Bridge**: Expose your self-hosted Penpot canvas variables locally by connecting the Penpot MCP server key to your terminal execution environments [Penpot MCP].
* **Automated Design Context**: Inject design constraints directly by aliasing Goose to parse your schema file on launch: `goose run --instruction "$(cat DESIGN.md)"`.
* **Instant Refresh Loop**: Use `watchexec` or `entr` to monitor your React source directory. The split second Onlook or Goose modifies a file, `rsync` triggers to push the payload to Caddy.
* **Ollama Endpoint Spoofing**: Map your agent pipelines natively to local Docker execution layers by swapping your base API routing address to `http://localhost:11434/v1` [Ollama].
## 🎨 Adding Local Text-to-Layout Design Features to Pi
### 1. Install the Local Canvas Viewport
Bridge your terminal with a live graphical preview window to see your layouts update in real time:
```bash npm install -g pi-canvas ```
* **Usage:** Run `pi-canvas` in a secondary terminal split to open a hot-reloaded browser window at `http://localhost:3000`.
### 2. Register the Design Skill
Create a custom agent skill to enforce structured layout rules, protect against unwanted UI design shifts, and handle local visual synchronization.
[!file] `~/.pi/agent/skills/ui-builder.skill`
```markdown > # UI Builder Skill > Enforces web-standard design rules and manages local visual canvas synchronization.
## Instructions
1. When creating UI layouts, always use semantic elements and modern layouts (Tailwind CSS, Flexbox, CSS Grid).
2. Isolate all visual tests inside the workspace's local `./preview.html` or a dedicated test harness file.
3. Read any local `tailwind.config.js` or token files before generation to match existing spacing and color systems.
4. Do not rewrite unaffected code blocks during layout adjustments; isolate updates strictly to the requested components.
```
### 3. Iteration Workflow
1. **Initialize Viewport:** Start `pi-canvas` in one terminal window, and run `pi` in another.
2. **Text to Layout:** `/skill ui-builder Create an isolated interactive Tailwind dashboard card in preview.html.`
3. **Change with Text:** *"The layout feels cramped. Make the card wider and change the primary button to a ghost variant."*
4. **Layout to Code:** The code changes update instantly in the local file and live browser window, ready for backend integration.

25
300 areas/350 AI/Pi Subagent Integration.md Normal file
View File

@@ -0,0 +1,25 @@
# Agent Integration Test
## Test Items
- [ ] Sub-agent spawns and returns result
- [ ] Widget shows agent activity
- [x] Background agent completes and notifies (2026-06-13)
- [x] /agents command shows agent types (2026-06-13)
## Pi-Subagents Architecture Analysis (2026-06-13)
The pi-subagents system is a multi-agent orchestration framework built on an RPC-based subagent protocol. It provides a structured execution environment where specialized agents can be spawned, steered, and composed into workflows. Below is an architectural breakdown of its core subsystems.
**Agent Types & Specialization.** The system maintains a roster of agent types — including `obsidian`, `Explore`, `research`, `coder`, `devops`, `general-purpose`, and `meta-subagent` — each with distinct model assignments and tool access profiles. Agent types are defined declaratively in the agent roster, specifying which model (e.g., `sonnet`, `haiku`, `4o-mini`) drives the agent and which tool subsets it can invoke. This allows the system to route tasks to appropriately-capable agents: lightweight types like `Explore` use faster, cheaper models for browsing, while `coder` and `devops` types get more capable reasoning models with development tool access.
**Background Execution Model.** Agents support two execution modes: foreground (sequential, caller blocks on result) and background (parallel, caller receives an agent ID immediately). Background agents are spawned via `task_spawn` and tracked by the subagent manager. The caller can poll for completion or await notification — this test note itself verified that background agents complete and signal their parent. The background model is critical for parallelizing independent work: data gathering, research, and code generation can proceed concurrently, with results merged later.
**Steering & Resumption.** A distinguishing feature is mid-execution steering. A running background agent receives new instructions via `steer_subagent`, allowing the parent to correct course, inject context, or redirect focus without restarting. Completed agents can also be resumed via the `resume` parameter, re-entering execution with fresh instructions while retaining prior context. This enables iterative refinement workflows — e.g., having an agent draft code, then resuming it to apply review feedback.
**Task List Integration.** The task system (TaskCreate/TaskUpdate/TaskList/TaskExecute) provides structured work management. Tasks carry status (pending/in_progress/completed/deleted), dependencies (blocks/blockedBy), owners, and optional agent type annotations. TaskExecute spawns matching pending tasks as subagents, enabling declarative workflow definition: create a task graph, then execute it and let the system resolve dependencies and dispatch agents automatically.
**Isolation Mode.** For file-modifying operations, agents can be launched with an isolation flag that creates a temporary git worktree. Each agent operates on its own sandboxed copy of the repository, making parallel edits safe. On completion, changes can be reviewed cleanly via diff before applying. The worktree is automatically cleaned up after the agent finishes, preventing accumulation of stale working directories.
**Memory & Context Persistence.** The memctx subsystem provides durable memory across sessions. Agents can save observations, decisions, actions, runbooks, and session summaries via `memctx_save` with appropriate type tags. Retrieval supports three modes: `keyword` (BM25, fast), `semantic` (embedding-based, ~2s), and `deep` (hybrid with reranking, ~10s). The Memory Gateway Brief mechanism injects relevant context at session start, and agents can search memory mid-execution to avoid repeating prior work.
**MCP Gateway.** External tool access is mediated through an MCP (Model Context Protocol) gateway. Agents can connect to MCP servers, list tools, describe parameters, and call tools with JSON arguments. This abstracts away the transport layer (stdio, HTTP, WebSocket) and provides a uniform interface to databases, browsers, filesystems, and other external services. The gateway supports lazy connection — servers are connected on first tool use — and auto-refreshes metadata.

128
300 areas/350 AI/Tools to try with AI.md Normal file
View File

@@ -0,0 +1,128 @@
---
created: 2026-06-27 12:17
modified: 2026-06-27 12:17
type: note
tags:
- ai
- ai-agents
- tool
- tools
aliases: []
---
# [[Tools to try with AI]]
| Repository / Project Name | GitHub Repository URL | Description |
| :--- | :--- | :--- |
| **OpenMontage** | [calesthio/OpenMontage](https://github.com) | Text-to-video AI editor |
| **codebase-memory-mcp** | [DeusData/codebase-memory-mcp](https://github.com) | Agent context memory |
| **timesfm** | [google-research/timesfm](https://github.com) | Time-series forecasting model |
| **Zapier MCP** | [zapier/zapier-mcp](https://github.com) | App integration gateway |
| **peerd** | [notasithlord/peerd](https://github.com) | Local browser agent |
| **FluidVoice** | [altic-dev/FluidVoice](https://github.com) | Local dictation tool |
| **birdclaw** | [steipete/birdclaw](https://github.com) | Clean X reader |
| **worldmonitor** | [koala73/worldmonitor](https://github.com) | Global event dashboard |
| **penpot** | [penpot/penpot](https://github.com) | Open-source Figma alternative |
| **voicebox** | [jamiepine/voicebox](https://github.com) | Local voice cloner |
| **system_prompts_leaks** | [asgeirtj/system_prompts_leaks](https://github.com) | AI prompt repository |
| **Agent-Reach** | [Panniantong/agent-reach](https://github.com) | Social media connector |
| **ai-berkshire** | [xbtlin/ai-berkshire](https://github.com/xbtlin/ai-berkshire) | Turn Claude Code into a value-investing research team. |
| **ponytail** | [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail) | Make AI coding agents solve tasks with the simplest code possible. |
| **inbox-zero** | [elie222/inbox-zero](https://github.com/elie222/inbox-zero) | A self-hostable AI email assistant for organizing and drafting replies. |
| **design.md** | [google-labs-code/design.md](https://github.com/google-labs-code/design.md) | Give AI agents a reusable design system so outputs match your brand. |
| **no-mistakes** | [kunchenguid/no-mistakes](https://github.com/kunchenguid/no-mistakes) | Add an AI safety gate before code reaches your team's repo. |
| **ai-website-cloner-template** | [JCodesMore/ai-website-cloner-template](https://github.com/JCodesMore/ai-website-cloner-template) | Rebuild an existing site as a clean modern codebase. |
| **lingbot-map** | [Robbyant/lingbot-map](https://github.com/Robbyant/lingbot-map) | Reconstruct a 3D scene from streaming camera frames. |
| **free-for-dev** | [ripienaar/free-for-dev](https://github.com/ripienaar/free-for-dev) | A huge maintained list of free developer tools and service tiers. |
| **orca** | [stablyai/orca](https://github.com/stablyai/orca) | Run multiple AI coding agents in parallel from one desktop environment. |
| **claude-video** | [bradautomates/claude-video](https://github.com/bradautomates/claude-video) | Give Claude the ability to watch any video. |
| **notebooklm-py** | [teng-lin/notebooklm-py](https://github.com/teng-lin/notebooklm-py) | Unofficial Python API and agentic skill for Google NotebookLM. |
| **obsidian-skills** | [kepano/obsidian-skills](https://github.com/kepano/obsidian-skills) | Agent skills for Obsidian — teach your agent to use Obsidian CLI and open formats. |
| **impeccable** | [pbakaus/impeccable](https://github.com/pbakaus/impeccable) | The design language that makes your AI harness better at design. |
| **pg_durable** | [microsoft.github.io/pg_durable](https://microsoft.github.io/pg_durable) | PostgreSQL crashproof functions. |
| **DuckDB** | [duckdb/duckdb](https://github.com/duckdb/duckdb) | Embedded analytical SQL database for high-performance data processing. |
| **BGS Stack** | [Obsidian note →](obsidian://open?vault=obsidian&file=200%20projects%2F210%20AI%20Resume%2FThe%20Modern%20Web%20Architecture%20Landscape%20Beyond%20the%20React%20Monopoly) | Go + HTMX + SQLite — the premier AI-friendly web architecture. |
| **last30days-skill** | [mvanhorn/last30days-skill](https://github.com/mvanhorn/last30days-skill) | AI agentic search tool for real-time social signals and community consensus. |
### pg_durable
pg_durable is a new open-source PostgreSQL extension that runs durable, crash-proof workflows right inside the database. The queue, worker, retry logic, and crash recovery you'd normally hand-build collapse into a few lines of SQL.
If you've been running Temporal, cron, or a background worker just for durable execution, watch this first.
📺 [pg_durable — Crashproof PostgreSQL workflows](https://www.youtube.com/watch?v=4Lmqvn_yz-c)
### DuckDB
DuckDB is an open-source, embedded analytical database that runs inside your application process — no server needed. It combines the lightweight simplicity of SQLite with the analytical speed of a cloud data warehouse like Snowflake.
**Key capabilities:**
- **Columnar storage** — reads only the columns you query, minimising disk and memory usage.
- **Vectorised execution** — processes data in CPU-cache-sized chunks (2,048 rows at a time) for maximum hardware efficiency.
- **Direct file querying** — queries Parquet, CSV, and JSON files directly on disk or in cloud storage (S3) without importing.
- **Rich integrations** — zero-copy data exchange with Pandas, Arrow, Polars, and R dataframes.
- **Advanced SQL** — Postgres-compatible dialect with window functions, complex joins, and nested data types.
### BGS Stack (Go + HTMX + SQLite)
The BGS Stack is the premier AI-friendly web architecture — a server-driven alternative to React SPAs built with **Go**, **HTMX**, and **SQLite**. It eliminates `node_modules`, build pipelines, and client-side state management, replacing them with a single linear backend loop that LLMs excel at generating.
Why it's optimised for AI coding:
- **Single-loop context** — one Go function reads from SQLite and returns HTML. No fragmented useState/useEffect/API layer to track across paradigms.
- **Deterministic HTML** — LLMs generate clean HTML and server routes far more reliably than complex React component hierarchies.
- **Fewer moving parts** — no Webpack, Vite, or bundle config for an AI agent to break. Bugs stay contained in one Go file or template.
📄 [Full breakdown — The Modern Web Architecture Landscape Beyond the React Monopoly](obsidian://open?vault=obsidian&file=200%20projects%2F210%20AI%20Resume%2FThe%20Modern%20Web%20Architecture%20Landscape%20Beyond%20the%20React%20Monopoly)
### last30days-skill
last30days-skill is an open-source AI agentic search tool for platforms like Claude Code and Cursor. It focuses on real-time social signals and community consensus over the past 30 days, aggregating data from Reddit, X, and YouTube to produce curated research briefs that bypass SEO-optimised content.
🔗 [mvanhorn/last30days-skill](https://github.com/mvanhorn/last30days-skill)
# AI Engineering Tools Overview
## 🛠️ Structured Data & Model Control
### Instructor (567-labs)
* **What it is:** A library that patches LLM clients (OpenAI, Anthropic, Gemini) to return strict Python data structures.
* **Why you need it:** Instead of asking an LLM for JSON and hoping it formats it correctly, you define a Pydantic schema. Instructor guarantees the model's output will match that schema perfectly, automatically retrying and feeding errors back to the LLM if validation fails.
* **URL:** https://useinstructor.com
### Outlines (dottxt-ai)
* **What it is:** A library that enforces strict structure at the token generation level for local and API-based LLMs.
* **Why you need it:** Unlike Instructor (which validates data after or during generation), Outlines guides the LLM dynamically. It alters the model's math so it physically cannot choose a token that violates your regex, schema, or choice list, resulting in 100% reliable structure with zero parsing errors.
* **URL:** https://github.com
---
## 🔌 Universal Integration & Routing
### LiteLLM
* **What it is:** A lightweight proxy and SDK that acts as a universal translator for over 100 different LLM APIs.
* **Why you need it:** Every AI provider has a slightly different code structure for API calls. LiteLLM lets you use the standard OpenAI format (`openai.chat.completions.create`) to talk to Anthropic, Bedrock, Cohere, or HuggingFace, while also handling fallbacks, load balancing, and spend tracking.
* **URL:** https://github.com
---
## 🧠 Programming & Optimizing Prompts
### DSPy (Stanford NLP)
* **What it is:** A framework that treats prompt engineering like programming rather than manual "prompt hacking."
* **Why you need it:** Instead of spending hours tweaking strings like "You are an expert...", you write Python modules (e.g., Chain-of-Thought, RAG). DSPy then compiles and automatically optimizes the prompts and few-shot examples based on your evaluation data, similar to how neural networks learn weights.
* **URL:** https://github.com
---
## 🕸️ Data Scraping & Preparation
### Crawl4AI
* **What it is:** An open-source web crawler designed specifically to scrape websites and convert them into data optimized for LLMs.
* **Why you need it:** Standard web scrapers pull raw, messy HTML full of ads and scripts. Crawl4AI extracts the core text, strips the noise, and outputs clean Markdown or structured JSON, making it perfect for feeding live web data into a RAG pipeline.
* **URL:** https://github.com
### Chonkie
* **What it is:** A highly optimized, lightweight text-chunking library designed for Retrieval-Augmented Generation (RAG).
* **Why you need it:** LLMs cannot ingest massive documents all at once; text must be broken down first. Chonkie focuses on speed and accuracy, splitting text intelligently (by tokens, sentences, or semantics) so context is never cut in half mid-sentence before being embedded.
* **URL:** https://github.com

96
300 areas/370 Family Home/basketball training.md Normal file
View File

@@ -0,0 +1,96 @@
---
created: 2026-07-29
modified: 2026-07-29
type: note
tags: []
aliases: []
---
# [[basketball training]]
## Game day
- First ten minutes decides game
- Harrass
- Defend from one end to the other
- Talls under the net
- Smalls cut in for fouls
- smalls on edge of key for rebound
- Smalls assist - Eddie throws
- No violence. No swearing. Smiling assassins
- "Don't cry"
- "Maybe take up ping pong"
- "Its just a game champ"
## Game day tactics
- Team split into 2 talls, 2 smalls, 1 mid.
- Mid floats as small-tall
- **Defense**
- Talls move fast on transition from offense to defense to man the rim.
- Smalls harrass ball carriers - no guarding.
- Push ball carrier back to edge of court to half way line.
- If carrier cornered. Mid to join.
- Force ball carrier to turn their back.
- Talls man on man on talls.
- If ball is passed to tall - force ball back to half court or reset to zone.
- If opposition playing aggressive in zone - reset to zone defense.
- **Offense**
- Smalls carry ball from defense and distribute to leading & cutting talls
- Smalls work as unit with mid - do not abandon in back half
- Smalls remain as unit coming in.
- Non ball carriers talls and mid make cuts - every two, to three seconds within 3 meters.
- If talls blocked shot, or failed shot - jelly fish back out. Reset.
## issues notices
- Repeated attempts under the rim, lack of pushing ball out, lack of body work, lack of one shot focus
- Lack of zone defense - ARMS UP
- Too much muck around - lack of drive.
-
## Focus areas
- Mid range shots. Between paint and 3 points.
- Zone defense with arms up.
## Drills
- Paint corner layup. Knock out.
- Bounces - so further out, 2 steps layup knockout.
- Silent Netball - no paint, shoot from outside paint inside 3 point. Everyone must go in to get loose ball and end up in paint.
- Jelly Fish Drive - shoot only in paint 3:5 - smalls must come in to receive, cross with talls and talls come back in smalls back out.
- Back slaps
- Free ball.
## Other drills
- 1 on 2
- Body positioning under the rim to push others out.
## NOTES on previous games
2026-08-01 vs Banyule U13 Boys 03
**Defense**
**1**
- Initially opposition small players were allowed to be free in space outside defensive players. Gave them time to shoot 3 pointers or pass to talls inside who scored.
- Responded with our smaller players harassing instead of guarding. Asked players to double or triple team them to block passes and shots and force turnover.
- Need to ask taller players left in key to zone defend as unit for loose pass.
- Talls must hard guard opponents in offense.
**2**
- Tall players to attack rebounds in defense as hard as offense. No second chances.
**Offense**
**1**
- Attack rim on fast break with all players
- When fast break fails set up, slow down. Round the world. Train lateral cuts across top of key.
- Repeated rebounds from under rim cost points.
- Talls under rim, rebounds to come out - "Jelly Fish"
- Smalls closer in, pressed 1-2 meter from key.
- Passing, bouncing. Bad, lazy passes into the key cost plenty.
- Take our time to find a good chance. Slow it. Use bounce.
- No wild shots.
**General**
- Selective passing. Favourite player passing - ignoring open players.
- No wild throws and hail marys. Better to hold the ball and do a slow build.
- Absolutely terrible shooting in the first.
**Notes**
- What matters more? That you have a ping, have a shot? Or the team scores?