oris-skills 2.2.2 → 3.0.1

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));
-}