oris-skills 2.2.3 → 3.0.1

package/references/loop.schema.json

@@ -1,156 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://oris.dev/schemas/oris-loop-v2.json",
-  "title": "Oris Loop document front matter (v2)",
-  "type": "object",
-  "additionalProperties": true,
-  "required": [
-    "schemaVersion",
-    "kind",
-    "name",
-    "approved",
-    "phases",
-    "limits",
-    "permissions",
-    "verification"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "const": 2
-    },
-    "kind": {
-      "const": "oris-loop"
-    },
-    "name": {
-      "type": "string",
-      "pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
-      "minLength": 2,
-      "maxLength": 80
-    },
-    "approved": {
-      "type": "boolean",
-      "description": "true only after the user approved goal, scope, prompts, and limits"
-    },
-    "models": {
-      "type": "object",
-      "additionalProperties": true,
-      "description": "Per-role model: \"inherit\" (session model), an adapter alias, or a platform model id",
-      "properties": {
-        "default": { "$ref": "#/$defs/model" },
-        "executor": { "$ref": "#/$defs/model" },
-        "verifier": { "$ref": "#/$defs/model" },
-        "doctor": { "$ref": "#/$defs/model" },
-        "debriefer": { "$ref": "#/$defs/model" }
-      }
-    },
-    "improve": {
-      "type": "object",
-      "additionalProperties": true,
-      "properties": {
-        "mode": {
-          "enum": ["propose", "auto"],
-          "description": "auto lets the debriefer rewrite prompts/ between passes; propose requires user approval for every change"
-        }
-      }
-    },
-    "phases": {
-      "type": "array",
-      "minItems": 1,
-      "maxItems": 12,
-      "items": {
-        "type": "string",
-        "pattern": "^[a-z][a-z0-9-]*$"
-      }
-    },
-    "roles": {
-      "type": "array",
-      "description": "Active roles per pass. Default [executor, verifier]; opt in doctor and/or debriefer. Executor and verifier are always required.",
-      "minItems": 2,
-      "uniqueItems": true,
-      "items": {
-        "enum": ["executor", "verifier", "doctor", "debriefer"]
-      },
-      "allOf": [
-        { "contains": { "const": "executor" } },
-        { "contains": { "const": "verifier" } }
-      ]
-    },
-    "limits": {
-      "type": "object",
-      "required": [
-        "maxIterations",
-        "maxNoProgress"
-      ],
-      "additionalProperties": true,
-      "properties": {
-        "maxIterations": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 500
-        },
-        "maxNoProgress": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 50
-        },
-        "maxMinutes": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 1440
-        }
-      }
-    },
-    "permissions": {
-      "type": "object",
-      "required": [
-        "allowedPaths",
-        "forbiddenActions"
-      ],
-      "additionalProperties": true,
-      "properties": {
-        "allowedPaths": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "forbiddenActions": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        }
-      }
-    },
-    "verification": {
-      "type": "object",
-      "required": [
-        "commands",
-        "evidenceRequired"
-      ],
-      "additionalProperties": true,
-      "properties": {
-        "commands": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "evidenceRequired": {
-          "type": "boolean"
-        }
-      }
-    }
-  },
-  "$defs": {
-    "model": {
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 120
-    }
-  }
-}

package/references/repo-map.md

@@ -1,51 +0,0 @@
-# Oris Repository Map
-
-Setup map = the default project context for every Oris skill and loop. It exists so agents stop re-scanning and users stop repeating project facts.
-
-## Files
-
-| File | Scope | Purpose |
-|------|-------|---------|
-| `.oris-flow/manifest.json` | repo | compact index: section paths, freshness, confidence |
-| `.oris-flow/maps/**` | repo | short markdown maps: docs, stack, commands, code areas, tests |
-| `.oris-flow/adapter.json` | repo | loop adapter: paths, commands, model aliases |
-| `.oris-flow/settings.json` | repo | preferences: `responseStyle` + `artifactLanguage` (non-secret) |
-| `{tasksRoot}/{task}/…` | task | business artifacts only — `setup.tasksRoot` in the manifest, default `.oris-flow/tasks` (see `references/doc-policy.md`) |
-
-Manifest and maps are never task authority and NEVER hold secrets.
-
-## Manifest shape (v1)
-
-```json
-{
-  "$schema": "https://oris.dev/schemas/oris-flow-map-v1.json",
-  "schemaVersion": 1,
-  "repository": "",
-  "generatedAt": "",
-  "updatedAt": "",
-  "setup": { "versionControl": { "orisFlowMap": "commit" } },
-  "sections": {}
-}
-```
-
-- Small: only sections that exist for the detected stack; no placeholders.
-- Each section: file path, one-line summary, `confidence`, `lastScannedAt`, stale flag.
-- Confidence: `confirmed` (user/authoritative) | `detected` (strong scan evidence) | `inferred` (unverified) | `stale` (no longer matches).
-- `setup.versionControl.orisFlowMap`: `commit` | `gitignore` — applied via `npx oris-skills flow version-control --mode <choice>`.
-- Schema: `references/repo-map.schema.json`.
-
-## Map sections
-
-`.oris-flow/maps/`: `README.md`, `docs.md`, `stack.md`, `commands.md`, `code.md`, `tests.md`.
-Each section: purpose, authoritative paths, confirmed decisions, key commands/conventions, confidence + stale notes, pointers instead of copied content.
-
-## Consumption rules
-
-1. MANIFEST first, then only the relevant map sections — before any broad scan.
-2. VERIFY stale or high-risk facts against the repository before consequential actions.
-3. Loops: the orchestrator passes relevant setup-map facts into role prompts at craft time; users never repeat project facts per loop.
-4. SUGGEST `/oris-flow` → Setup refresh only when a stale gap materially affects the task.
-
-## Command surface
-
-In target repositories always use the installed CLI (`npx oris-skills flow scan|version-control|clean-runtime`, `npx oris-skills loop …`), never `node scripts/...` paths — those exist only in the OrisSkills source checkout.

package/references/repo-map.schema.json

@@ -1,213 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://oris.dev/schemas/oris-flow-map-v1.json",
-  "title": "Oris Flow Repository Map",
-  "type": "object",
-  "additionalProperties": false,
-  "required": [
-    "$schema",
-    "schemaVersion",
-    "repository",
-    "generatedAt",
-    "updatedAt",
-    "setup",
-    "sections"
-  ],
-  "properties": {
-    "$schema": {
-      "const": "https://oris.dev/schemas/oris-flow-map-v1.json"
-    },
-    "schemaVersion": {
-      "const": 1
-    },
-    "repository": {
-      "type": "string",
-      "minLength": 1
-    },
-    "generatedAt": {
-      "type": "string",
-      "format": "date-time"
-    },
-    "updatedAt": {
-      "type": "string",
-      "format": "date-time"
-    },
-    "headSha": {
-      "type": ["string", "null"],
-      "description": "Commit SHA the last scan was anchored to; null outside git. Freshness = headSha vs current HEAD."
-    },
-    "mapVersion": {
-      "type": "string",
-      "minLength": 1
-    },
-    "projectType": {
-      "$ref": "#/$defs/projectType"
-    },
-    "truncated": {
-      "type": "boolean"
-    },
-    "setup": {
-      "$ref": "#/$defs/setup"
-    },
-    "sections": {
-      "$ref": "#/$defs/sections"
-    },
-    "stacks": {
-      "type": "array",
-      "items": {
-        "$ref": "#/$defs/stack"
-      }
-    },
-    "commands": {
-      "type": "array",
-      "items": {
-        "$ref": "#/$defs/detectedCommand"
-      }
-    }
-  },
-  "$defs": {
-    "confidence": {
-      "type": "string",
-      "enum": ["confirmed", "detected", "inferred", "stale"]
-    },
-    "sectionPointer": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["path", "confidence"],
-      "properties": {
-        "path": {
-          "type": "string",
-          "pattern": "^\\.oris-flow/"
-        },
-        "confidence": {
-          "$ref": "#/$defs/confidence"
-        },
-        "lastScannedAt": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "stale": {
-          "type": "boolean"
-        },
-        "summary": {
-          "type": "string"
-        }
-      }
-    },
-    "sections": {
-      "type": "object",
-      "additionalProperties": {
-        "$ref": "#/$defs/sectionPointer"
-      },
-      "propertyNames": {
-        "pattern": "^[a-z][a-zA-Z0-9-]*$"
-      }
-    },
-    "setup": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["mode", "scanDepth"],
-      "properties": {
-        "mode": {
-          "type": "string",
-          "enum": ["create", "refresh", "review-stale", "update-area", "summary"]
-        },
-        "scanDepth": {
-          "type": "string",
-          "enum": ["fast", "balanced", "manual-summary"]
-        },
-        "tasksRoot": {
-          "type": "string",
-          "minLength": 1
-        },
-        "confirmedDecisions": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        "tradeOff": {
-          "type": "string"
-        },
-        "versionControl": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "orisFlowMap": {
-              "type": "string",
-              "enum": ["commit", "gitignore"]
-            }
-          }
-        }
-      }
-    },
-    "stack": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["id", "label", "evidence"],
-      "properties": {
-        "id": {
-          "type": "string",
-          "pattern": "^[a-z][a-z0-9-]*$"
-        },
-        "label": {
-          "type": "string",
-          "minLength": 1
-        },
-        "evidence": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    },
-    "detectedCommand": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["name", "cwd", "command", "evidence"],
-      "properties": {
-        "name": {
-          "type": "string",
-          "pattern": "^[a-z][a-z0-9-]*$"
-        },
-        "cwd": {
-          "type": "string"
-        },
-        "command": {
-          "type": "string"
-        },
-        "evidence": {
-          "type": "string"
-        },
-        "confidence": {
-          "$ref": "#/$defs/confidence"
-        }
-      }
-    },
-    "projectType": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["id", "label", "confidence"],
-      "properties": {
-        "id": {
-          "type": "string",
-          "enum": ["empty", "monorepo", "webapp", "api", "library", "cli", "unknown"]
-        },
-        "label": {
-          "type": "string",
-          "minLength": 1
-        },
-        "confidence": {
-          "$ref": "#/$defs/confidence"
-        },
-        "evidence": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    }
-  }
-}

package/scripts/flow/oris-flow-clean-runtime.mjs

@@ -1,182 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  ORIS_FLOW_ADAPTER,
-  ORIS_FLOW_LOOPS_ROOT,
-  ORIS_FLOW_MANIFEST,
-  ORIS_FLOW_MAPS_ROOT,
-  ORIS_FLOW_RUNTIME,
-} from "./oris-flow-layout.mjs";
-
-const DEFAULT_RUNTIME_RELATIVE = ORIS_FLOW_RUNTIME;
-
-function readJson(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  return JSON.parse(fs.readFileSync(filePath, "utf8"));
-}
-
-function assertSafeRelativePath(relativePath, label) {
-  const normalized = String(relativePath ?? "").replace(/\\/g, "/");
-  if (!normalized || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized)) {
-    throw new Error(`${label} must be a repository-relative path.`);
-  }
-  if (normalized.split("/").includes("..")) {
-    throw new Error(`${label} must not contain '..'.`);
-  }
-  return normalized;
-}
-
-function assertUnderRepository(repositoryRoot, targetPath) {
-  const root = path.resolve(repositoryRoot);
-  const resolved = path.resolve(targetPath);
-  const relative = path.relative(root, resolved);
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    throw new Error(`Refusing to clean path outside repository: ${targetPath}`);
-  }
-  return resolved;
-}
-
-export function resolveCleanTargets(repositoryRoot) {
-  const root = path.resolve(repositoryRoot);
-  const adapter = readJson(path.join(root, ORIS_FLOW_ADAPTER));
-  const runtimeRelative = assertSafeRelativePath(
-    adapter?.paths?.runtime ?? DEFAULT_RUNTIME_RELATIVE,
-    "paths.runtime",
-  );
-
-  if (runtimeRelative.replace(/\\/g, "/") === ORIS_FLOW_RUNTIME) {
-    return [assertUnderRepository(root, path.join(root, ...ORIS_FLOW_RUNTIME.split("/")))];
-  }
-
-  return [assertUnderRepository(root, path.join(root, ...runtimeRelative.split("/")))];
-}
-
-function listEntries(directoryPath) {
-  if (!fs.existsSync(directoryPath)) return [];
-  const entries = [];
-  const stack = [directoryPath];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-      const fullPath = path.join(current, entry.name);
-      entries.push(fullPath);
-      if (entry.isDirectory()) stack.push(fullPath);
-    }
-  }
-  return entries.sort();
-}
-
-function removeEntry(entryPath) {
-  if (!fs.existsSync(entryPath)) return;
-  const stat = fs.lstatSync(entryPath);
-  if (stat.isDirectory()) {
-    fs.rmSync(entryPath, { recursive: true, force: true });
-    return;
-  }
-  fs.rmSync(entryPath, { force: true });
-}
-
-export function cleanFlowRuntime(repositoryRoot, options = {}) {
-  const root = path.resolve(repositoryRoot);
-  const dryRun = Boolean(options.dryRun);
-  const targets = resolveCleanTargets(root);
-  const removed = [];
-  const preserved = [
-    ORIS_FLOW_MANIFEST,
-    `${ORIS_FLOW_MAPS_ROOT}/**`,
-    ORIS_FLOW_ADAPTER,
-    `${ORIS_FLOW_LOOPS_ROOT}/**`,
-    ".cursor/hooks.json",
-    ".cursor/hooks/oris-loop-stop.mjs",
-  ];
-
-  for (const target of targets) {
-    if (!fs.existsSync(target)) continue;
-    const stat = fs.lstatSync(target);
-    if (stat.isDirectory()) {
-      for (const entry of listEntries(target)) {
-        const relative = path.relative(root, entry).split(path.sep).join("/");
-        if (dryRun) {
-          removed.push(relative);
-        } else {
-          removeEntry(entry);
-          removed.push(relative);
-        }
-      }
-      if (dryRun) {
-        removed.push(path.relative(root, target).split(path.sep).join("/"));
-      } else {
-        removeEntry(target);
-        removed.push(path.relative(root, target).split(path.sep).join("/"));
-      }
-      continue;
-    }
-    const relative = path.relative(root, target).split(path.sep).join("/");
-    if (dryRun) {
-      removed.push(relative);
-    } else {
-      removeEntry(target);
-      removed.push(relative);
-    }
-  }
-
-  return {
-    repositoryRoot: root,
-    dryRun,
-    targets: targets.map((target) => path.relative(root, target).split(path.sep).join("/")),
-    removed,
-    preserved,
-    cleaned: removed.length > 0,
-  };
-}
-
-function parseArgs(argv) {
-  const options = {
-    repositoryRoot: process.cwd(),
-    dryRun: false,
-    json: false,
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const raw = argv[i];
-    if (raw === "--dry-run") options.dryRun = true;
-    else if (raw === "--json") options.json = true;
-    else if (raw.startsWith("--repository-root=")) options.repositoryRoot = raw.slice("--repository-root=".length);
-    else if (raw === "--repository-root" && argv[i + 1]) {
-      options.repositoryRoot = argv[i + 1];
-      i += 1;
-    } else if (!raw.startsWith("-")) {
-      options.repositoryRoot = raw;
-    }
-  }
-  return options;
-}
-
-export function printCleanReport(result) {
-  console.log(`Oris Flow runtime clean${result.dryRun ? " (dry run)" : ""}`);
-  console.log(`Repository: ${result.repositoryRoot}`);
-  console.log("");
-  console.log("Targets:");
-  for (const target of result.targets) console.log(`- ${target}`);
-  console.log("");
-  if (result.removed.length === 0) {
-    console.log("No ephemeral runtime files found.");
-    return;
-  }
-  console.log(`${result.dryRun ? "Would remove" : "Removed"} ${result.removed.length} path(s):`);
-  for (const entry of result.removed) console.log(`- ${entry}`);
-  console.log("");
-  console.log("Preserved by design:");
-  for (const entry of result.preserved) console.log(`- ${entry}`);
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
-  const options = parseArgs(process.argv.slice(2));
-  const result = cleanFlowRuntime(options.repositoryRoot, { dryRun: options.dryRun });
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    printCleanReport(result);
-  }
-  process.exit(0);
-}

package/scripts/install/generate-agent-adapters.mjs

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import path from "node:path";
-import process from "node:process";
-import { fileURLToPath } from "node:url";
-
-const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-const sourceRoot = path.join(repoRoot, "agents");
-
-function readAgent(filePath) {
-  const text = fs.readFileSync(filePath, "utf8");
-  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
-  if (!match) throw new Error(`Agent file is missing front matter: ${filePath}`);
-  const frontMatter = Object.fromEntries(
-    match[1]
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter(Boolean)
-      .map((line) => {
-        const index = line.indexOf(":");
-        if (index < 0) throw new Error(`Unsupported front matter line in ${filePath}: ${line}`);
-        return [line.slice(0, index).trim(), line.slice(index + 1).trim()];
-      }),
-  );
-  return { frontMatter, body: match[2].trim() };
-}
-
-function writeFile(filePath, content) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, `${content.trimEnd()}\n`, "utf8");
-}
-
-function renderMarkdownAgent(agent) {
-  return `---
-name: ${agent.frontMatter.name}
-description: ${agent.frontMatter.description}
-readonly: ${agent.frontMatter.readonly ?? "false"}
----
-
-${agent.body}
-`;
-}
-
-function renderCodexAgent(agent) {
-  const name = JSON.stringify(agent.frontMatter.name);
-  const description = JSON.stringify(agent.frontMatter.description);
-  const instructions = JSON.stringify(agent.body);
-  return `name = ${name}
-description = ${description}
-developer_instructions = ${instructions}
-`;
-}
-
-function readAgents() {
-  return fs.readdirSync(sourceRoot)
-    .filter((name) => name.endsWith(".md"))
-    .map((name) => ({ name, ...readAgent(path.join(sourceRoot, name)) }));
-}
-
-/**
- * Write adapters into repo-local .cursor/.claude/.codex dirs under root.
- * Development-only: the installer never copies these into user agent homes —
- * loop roles are internal and reach subagents via per-loop prompts/<role>.md files.
- */
-export function generateAgentAdapters(root = repoRoot) {
-  const agents = readAgents();
-  for (const agent of agents) {
-    writeFile(path.join(root, ".cursor", "agents", agent.name), renderMarkdownAgent(agent));
-    writeFile(path.join(root, ".claude", "agents", agent.name), renderMarkdownAgent(agent));
-    writeFile(path.join(root, ".codex", "agents", agent.name.replace(/\.md$/, ".toml")), renderCodexAgent(agent));
-  }
-  return agents.map((agent) => agent.frontMatter.name);
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
-  const rootArg = process.argv.find((arg) => arg.startsWith("--root="));
-  const root = rootArg ? path.resolve(rootArg.slice("--root=".length)) : repoRoot;
-  const generated = generateAgentAdapters(root);
-  console.log(JSON.stringify({ generated }, null, 2));
-}