tau-all-agent 0.1.0

package/skills/openscad/scripts/preview.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+# Generate a preview PNG from an OpenSCAD file
+# Usage: preview.sh input.scad output.png [options]
+#
+# Options:
+#   --camera=x,y,z,rx,ry,rz,dist  Camera position
+#   --size=WxH                     Image size (default: 800x600)
+#   -D 'var=value'                 Set parameter value
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+check_openscad
+
+if [ $# -lt 2 ]; then
+    echo "Usage: $0 input.scad output.png [--camera=...] [--size=WxH] [-D 'var=val']"
+    echo ""
+    echo "Camera format: x,y,z,rotx,roty,rotz,distance"
+    echo "Common cameras:"
+    echo "  Isometric: --camera=0,0,0,55,0,25,200"
+    echo "  Front:     --camera=0,0,0,90,0,0,200"
+    echo "  Top:       --camera=0,0,0,0,0,0,200"
+    exit 1
+fi
+
+INPUT="$1"
+OUTPUT="$2"
+shift 2
+
+# Defaults
+CAMERA="0,0,0,55,0,25,0"
+SIZE="800,600"
+DEFINES=()
+
+# Parse options
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --camera=*)
+            CAMERA="${1#--camera=}"
+            ;;
+        --size=*)
+            SIZE="${1#--size=}"
+            SIZE="${SIZE/x/,}"
+            ;;
+        -D)
+            shift
+            DEFINES+=("-D" "$1")
+            ;;
+        *)
+            echo "Unknown option: $1"
+            exit 1
+            ;;
+    esac
+    shift
+done
+
+# Ensure output directory exists
+mkdir -p "$(dirname "$OUTPUT")"
+
+# Run OpenSCAD
+echo "Rendering preview: $INPUT -> $OUTPUT"
+$OPENSCAD \
+    --camera="$CAMERA" \
+    --imgsize="${SIZE}" \
+    --colorscheme="Tomorrow Night" \
+    --autocenter \
+    --viewall \
+    "${DEFINES[@]}" \
+    -o "$OUTPUT" \
+    "$INPUT"
+
+echo "Preview saved to: $OUTPUT"

package/skills/openscad/scripts/render-with-params.sh

@@ -0,0 +1,91 @@
+#!/bin/bash
+# Render OpenSCAD with parameters from a JSON file
+# Usage: render-with-params.sh input.scad params.json output.stl|output.png
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+check_openscad
+
+if [ $# -lt 3 ]; then
+    echo "Usage: $0 input.scad params.json output.[stl|png]"
+    echo ""
+    echo "params.json format:"
+    echo '  {"width": 60, "height": 40, "include_lid": true}'
+    exit 1
+fi
+
+INPUT="$1"
+PARAMS_FILE="$2"
+OUTPUT="$3"
+
+if [ ! -f "$INPUT" ]; then
+    echo "Error: Input file not found: $INPUT"
+    exit 1
+fi
+
+if [ ! -f "$PARAMS_FILE" ]; then
+    echo "Error: Params file not found: $PARAMS_FILE"
+    exit 1
+fi
+
+# Build -D arguments from JSON
+DEFINES=()
+while IFS= read -r line; do
+    # Parse each key-value pair
+    key=$(echo "$line" | cut -d'=' -f1)
+    value=$(echo "$line" | cut -d'=' -f2-)
+    
+    if [ -n "$key" ]; then
+        DEFINES+=("-D" "$key=$value")
+    fi
+done < <(
+    # Use python or jq to parse JSON to key=value lines
+    if command -v python3 &> /dev/null; then
+        python3 -c "
+import json
+with open('$PARAMS_FILE') as f:
+    params = json.load(f)
+for k, v in params.items():
+    if isinstance(v, bool):
+        print(f'{k}={str(v).lower()}')
+    elif isinstance(v, str):
+        print(f'{k}=\"{v}\"')
+    else:
+        print(f'{k}={v}')
+"
+    elif command -v jq &> /dev/null; then
+        jq -r 'to_entries | .[] | "\(.key)=\(.value)"' "$PARAMS_FILE"
+    else
+        echo "Error: Requires python3 or jq to parse JSON"
+        exit 1
+    fi
+)
+
+echo "Rendering with parameters from: $PARAMS_FILE"
+echo "Parameters: ${DEFINES[*]}"
+
+# Determine output type and set appropriate options
+EXT="${OUTPUT##*.}"
+case "$EXT" in
+    stl|STL)
+        $OPENSCAD "${DEFINES[@]}" -o "$OUTPUT" "$INPUT"
+        ;;
+    png|PNG)
+        $OPENSCAD "${DEFINES[@]}" \
+            --camera="0,0,0,55,0,25,0" \
+            --imgsize="800,600" \
+            --colorscheme="Tomorrow Night" \
+            --autocenter --viewall \
+            -o "$OUTPUT" "$INPUT"
+        ;;
+    *)
+        echo "Unsupported output format: $EXT"
+        echo "Supported: stl, png"
+        exit 1
+        ;;
+esac
+
+echo "Output saved: $OUTPUT"

package/skills/openscad/scripts/validate.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# Validate an OpenSCAD file for syntax errors
+# Usage: validate.sh input.scad
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+check_openscad
+
+if [ $# -lt 1 ]; then
+    echo "Usage: $0 input.scad"
+    exit 1
+fi
+
+INPUT="$1"
+
+if [ ! -f "$INPUT" ]; then
+    echo "Error: File not found: $INPUT"
+    exit 1
+fi
+
+echo "Validating: $INPUT"
+
+# Create temp file for output
+TEMP_OUTPUT=$(mktemp /tmp/openscad_validate.XXXXXX.echo)
+trap "rm -f $TEMP_OUTPUT" EXIT
+
+# Run OpenSCAD with echo output (fastest way to check syntax)
+# Using --export-format=echo just parses and evaluates without rendering
+if $OPENSCAD -o "$TEMP_OUTPUT" --export-format=echo "$INPUT" 2>&1; then
+    echo "✓ Syntax OK"
+    
+    # Check for warnings in stderr
+    if [ -s "$TEMP_OUTPUT" ]; then
+        echo ""
+        echo "Echo output:"
+        cat "$TEMP_OUTPUT"
+    fi
+    
+    exit 0
+else
+    echo "✗ Validation failed"
+    exit 1
+fi

package/skills/oracle/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: oracle
+description: Get a second opinion by bundling a prompt + a curated file set, then asking a strong model from a different family through a separate Pi invocation.
+---
+
+# Oracle
+
+Use this skill when you want a second opinion from a capable model in a different family than the current session.
+
+The oracle workflow bundles selected files into a standalone prompt, selects an alternate model with `pi --list-models`, and sends the bundle to `pi -p --no-tools`. It is read-only by default because the oracle receives the selected context directly and does not get tools.
+
+## Model selection
+
+The `./scripts/oracle` wrapper chooses the strongest known model it can find in the first usable family from this order:
+
+| Current family     | Oracle preference                                     |
+| ------------------ | ----------------------------------------------------- |
+| OpenAI / Codex     | Claude / Anthropic → Gemini / Google → OpenAI / Codex |
+| Claude / Anthropic | OpenAI / Codex → Gemini / Google → Claude / Anthropic |
+| Gemini / Google    | OpenAI / Codex → Claude / Anthropic → Gemini / Google |
+| Unknown            | Claude / Anthropic → OpenAI / Codex → Gemini / Google |
+
+It prefers models listed in Pi's `enabledModels`, then falls back to the best matching model shown by `pi --list-models`. Override only when needed with `--model provider/model`.
+
+If the current model is not obvious to the script, pass it explicitly with `--current provider/model`. Otherwise it falls back to Pi's default model from `settings.json`.
+
+## Workflow
+
+1. Pick the smallest file set that contains the truth. Avoid secrets by default.
+2. Preview selected files before sending.
+3. Ask the oracle with a standalone prompt that states the task, constraints, and desired output format.
+4. Treat the result as advice, not authority. Reason from first principles before applying recommendations.
+
+## Commands
+
+Run commands from this skill directory:
+
+```bash
+# Preview selected files
+./scripts/oracle-bundle --dry-run -p "<task>" --file "src/**" --file "!**/*.test.*"
+
+# Preview the full bundle
+./scripts/oracle-bundle -p "<task>" --file "src/**" --file "!**/*.test.*"
+
+# Show which oracle model would be selected
+./scripts/oracle --list-models --current openai-codex/gpt-5.5
+
+# Ask the automatically selected oracle model
+./scripts/oracle --current openai-codex/gpt-5.5 \
+  -p "<task>" --file "src/**" --file "!**/*.test.*"
+
+# Override the oracle model when the automatic choice is wrong
+./scripts/oracle --model github-copilot/claude-opus-4.7 \
+  -p "<task>" --file "src/**" --file "!**/*.test.*"
+```
+
+## Tips
+
+- Prefer a minimal file set over the whole repo.
+- If you need diffs reviewed, paste the diff into the prompt or attach the diff file via `--file`.
+- Make the prompt completely standalone: include intent, goals, constraints, error text, and whether you want a plan, review, pros/cons, or patch guidance.
+- Never include secrets (`.env`, tokens, key files).
+- For general code review, ask for feedback on correctness, consistency with existing code, simplicity, maintainability, performance, security, and edge cases.
+- Oracle can be slow while it reasons. Allow it several minutes to process.

package/skills/oracle/scripts/oracle

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const THINKING_LEVEL = "xhigh";
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+const FAMILY_ORDER = {
+  openai: ["anthropic", "google", "openai"],
+  anthropic: ["openai", "google", "anthropic"],
+  google: ["openai", "anthropic", "google"],
+  unknown: ["anthropic", "openai", "google"],
+};
+
+const args = parseArgs(process.argv.slice(2));
+const settings = readSettings();
+const currentModel = args.currentModel ?? process.env.ORACLE_CURRENT_MODEL ?? defaultModel(settings);
+const currentFamily = modelFamily(currentModel ?? "") ?? "unknown";
+const availableModels = listPiModels();
+const enabledModels = new Set((settings.enabledModels ?? []).map(normalizeModelSpec));
+
+if (args.listModels) {
+  printModelPlan(availableModels, enabledModels, currentModel, currentFamily);
+  process.exit(0);
+}
+
+const oracleModel = args.model ?? selectOracleModel(availableModels, enabledModels, currentFamily);
+if (!oracleModel) {
+  die("Could not find a suitable oracle model from `pi --list-models`.");
+}
+
+console.error(
+  `[oracle] current=${currentModel ?? "unknown"} family=${currentFamily}; oracle=${oracleModel}`,
+);
+
+const bundle = run(path.join(SCRIPT_DIR, "oracle-bundle"), args.bundleArgs, {
+  cwd: repoRoot(),
+  encoding: "utf8",
+  maxBuffer: 64 * 1024 * 1024,
+});
+
+if (bundle.status !== 0) {
+  process.stderr.write(bundle.stderr ?? "");
+  process.exit(bundle.status ?? 1);
+}
+
+const pi = spawnSync("pi", ["-p", "--no-tools", "--model", oracleModel, "--thinking", THINKING_LEVEL], {
+  cwd: repoRoot(),
+  input: bundle.stdout,
+  stdio: ["pipe", "inherit", "inherit"],
+});
+
+if (pi.error) die(pi.error.message);
+process.exit(pi.status ?? 1);
+
+function parseArgs(argv) {
+  const bundleArgs = [];
+  let currentModel;
+  let model;
+  let listModels = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--current" || arg === "--current-model") {
+      currentModel = requireValue(argv, (index += 1), arg);
+    } else if (arg === "--model" || arg === "--oracle-model") {
+      model = normalizeModelSpec(requireValue(argv, (index += 1), arg));
+    } else if (arg === "--list-models") {
+      listModels = true;
+    } else {
+      bundleArgs.push(arg);
+    }
+  }
+
+  return { bundleArgs, currentModel: currentModel ? normalizeModelSpec(currentModel) : undefined, model, listModels };
+}
+
+function requireValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value) die(`${flag} requires a value`);
+  return value;
+}
+
+function readSettings() {
+  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(homedir(), ".pi", "agent");
+  const settingsPath = path.join(agentDir, "settings.json");
+  if (!existsSync(settingsPath)) return {};
+
+  try {
+    return JSON.parse(readFileSync(settingsPath, "utf8"));
+  } catch (error) {
+    console.error(`[oracle] warning: failed to parse ${settingsPath}: ${error.message}`);
+    return {};
+  }
+}
+
+function defaultModel(settings) {
+  if (!settings.defaultProvider || !settings.defaultModel) return undefined;
+  return normalizeModelSpec(`${settings.defaultProvider}/${settings.defaultModel}`);
+}
+
+function listPiModels() {
+  const result = run("pi", ["--list-models"], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+  if (result.error) die(result.error.message);
+  if (result.status !== 0) die(result.stderr || "pi --list-models failed");
+
+  const models = [];
+  const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  for (const line of output.split("\n")) {
+    const match = line.match(/^(\S+)\s+(\S+)\s+/);
+    if (!match || match[1] === "provider") continue;
+    models.push({ provider: match[1], model: match[2], spec: `${match[1]}/${match[2]}` });
+  }
+  return models;
+}
+
+function selectOracleModel(models, enabledModels, currentFamily) {
+  for (const family of FAMILY_ORDER[currentFamily] ?? FAMILY_ORDER.unknown) {
+    const best = bestModelForFamily(models, enabledModels, family);
+    if (best) return best.spec;
+  }
+  return undefined;
+}
+
+function bestModelForFamily(models, enabledModels, family) {
+  return models
+    .map((model) => ({ model, score: scoreModel(model, enabledModels, family) }))
+    .filter((entry) => entry.score >= 0)
+    .sort((a, b) => b.score - a.score || a.model.spec.localeCompare(b.model.spec))[0]?.model;
+}
+
+function scoreModel(entry, enabledModels, targetFamily) {
+  if (modelFamily(entry.spec) !== targetFamily) return -1;
+
+  let score = enabledModels.has(normalizeModelSpec(entry.spec)) ? 10_000 : 0;
+  score += providerScore(entry.provider, targetFamily);
+  score += nameScore(entry.model, targetFamily);
+  return score;
+}
+
+function providerScore(provider, family) {
+  const normalized = provider.toLowerCase();
+  if (family === "openai") {
+    if (normalized === "openai-codex") return 700;
+    if (normalized === "openai") return 600;
+    if (normalized === "github-copilot") return 500;
+    if (normalized.includes("azure")) return 450;
+    if (normalized === "openrouter") return 300;
+    return 100;
+  }
+
+  if (family === "anthropic") {
+    if (normalized === "github-copilot") return 700;
+    if (normalized === "anthropic") return 600;
+    if (normalized === "amazon-bedrock") return 450;
+    if (normalized === "openrouter") return 300;
+    return 100;
+  }
+
+  if (family === "google") {
+    if (normalized === "google-gemini-cli") return 700;
+    if (normalized === "google") return 600;
+    if (normalized === "github-copilot") return 500;
+    if (normalized.includes("vertex")) return 450;
+    if (normalized === "openrouter") return 300;
+    return 100;
+  }
+
+  return 0;
+}
+
+function nameScore(model, family) {
+  const normalized = model.toLowerCase();
+
+  if (family === "openai") {
+    if (/gpt-5\.5/.test(normalized)) return 1_000;
+    if (/gpt-5\.4/.test(normalized)) return 950;
+    if (/gpt-5\.3.*codex/.test(normalized)) return 925;
+    if (/gpt-5\.3/.test(normalized)) return 900;
+    if (/gpt-5\.2/.test(normalized)) return 850;
+    if (/gpt-5\.1/.test(normalized)) return 800;
+    if (/gpt-5/.test(normalized)) return 750;
+    if (/gpt-4\.1/.test(normalized)) return 500;
+    return 100;
+  }
+
+  if (family === "anthropic") {
+    if (/claude[-_.]opus[-_.]4[-_.]7/.test(normalized)) return 1_000;
+    if (/claude[-_.]opus[-_.]4[-_.]6/.test(normalized)) return 950;
+    if (/claude[-_.]opus[-_.]4[-_.]5/.test(normalized)) return 900;
+    if (/claude[-_.]opus[-_.]4[-_.]1/.test(normalized)) return 850;
+    if (/claude[-_.]opus[-_.]4/.test(normalized)) return 800;
+    if (/claude[-_.]sonnet[-_.]4[-_.]6/.test(normalized)) return 700;
+    if (/claude[-_.]sonnet[-_.]4[-_.]5/.test(normalized)) return 650;
+    if (/claude[-_.]sonnet[-_.]4/.test(normalized)) return 600;
+    return 100;
+  }
+
+  if (family === "google") {
+    if (/gemini[-_.]3\.1[-_.]pro/.test(normalized)) return 1_000;
+    if (/gemini[-_.]3[-_.]pro/.test(normalized)) return 950;
+    if (/gemini[-_.]2\.5[-_.]pro/.test(normalized)) return 800;
+    return 100;
+  }
+
+  return 0;
+}
+
+function modelFamily(spec) {
+  const normalized = normalizeModelSpec(spec).toLowerCase();
+  if (!normalized) return undefined;
+  if (/(anthropic|claude)/.test(normalized)) return "anthropic";
+  if (/(google|gemini)/.test(normalized)) return "google";
+  if (/(openai|gpt|codex)/.test(normalized)) return "openai";
+  return undefined;
+}
+
+function normalizeModelSpec(spec) {
+  return String(spec).trim().replace(/:(off|minimal|low|medium|high|xhigh)$/i, "");
+}
+
+function printModelPlan(models, enabledModels, currentModel, currentFamily) {
+  console.log(`Current model: ${currentModel ?? "unknown"}`);
+  console.log(`Current family: ${currentFamily}`);
+  console.log(`Family order: ${(FAMILY_ORDER[currentFamily] ?? FAMILY_ORDER.unknown).join(" -> ")}`);
+  console.log("");
+
+  for (const family of ["anthropic", "openai", "google"]) {
+    const best = bestModelForFamily(models, enabledModels, family);
+    console.log(`${family}: ${best?.spec ?? "not found"}`);
+  }
+}
+
+function repoRoot() {
+  const result = run("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" });
+  return result.status === 0 ? result.stdout.trim() : process.cwd();
+}
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, { ...options });
+}
+
+function die(message) {
+  console.error(`oracle: ${message}`);
+  process.exit(1);
+}