oris-skills 2.0.0

package/scripts/loop/oris-loop-bootstrap.mjs

@@ -0,0 +1,383 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ensureGitignoreEntries, ORIS_LOOP_GITIGNORE_ENTRY } from "../flow/oris-gitignore.mjs";
+import {
+  ORIS_FLOW_ADAPTER,
+  ORIS_FLOW_LOOPS_ROOT,
+  ORIS_FLOW_MANIFEST,
+  ORIS_FLOW_RUNTIME,
+  ORIS_LOOP_SCHEMA,
+  ORIS_LOOP_SCHEMA_VERSION,
+} from "../flow/oris-flow-layout.mjs";
+
+export const HOOK_PLATFORMS = ["cursor", "claude"];
+
+/** Repo-local wrapper: resolves the installed bundle and forwards stdin. */
+export function stopHookWrapperSource(platform) {
+  return `#!/usr/bin/env node
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+
+function resolveStopHook() {
+  const candidates = [];
+  if (process.env.ORIS_SKILLS_SCRIPTS_ROOT) {
+    const scriptsRoot = path.resolve(process.env.ORIS_SKILLS_SCRIPTS_ROOT);
+    candidates.push(path.join(scriptsRoot, "loop", "oris-loop-stop.mjs"));
+    candidates.push(path.join(scriptsRoot, "oris-loop-stop.mjs"));
+  }
+  candidates.push(path.join(os.homedir(), ".oris", "oris-skills", "scripts", "loop", "oris-loop-stop.mjs"));
+  candidates.push(path.join(os.homedir(), ".cursor", "oris-skills", "scripts", "loop", "oris-loop-stop.mjs"));
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  process.stderr.write("Oris Loop stop hook not found. Run: npx oris-skills install\\n");
+  process.exit(1);
+}
+
+const result = childProcess.spawnSync(process.execPath, [resolveStopHook(), "--platform", "${platform}"], {
+  stdio: "inherit",
+  env: process.env,
+});
+process.exit(result.status ?? 1);
+`;
+}
+
+const CURSOR_STOP_COMMAND = "node .cursor/hooks/oris-loop-stop.mjs";
+const CLAUDE_STOP_COMMAND = "node .claude/hooks/oris-loop-stop.mjs";
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function listFiles(dir, depth = 0, maxDepth = 4, matches = []) {
+  if (depth > maxDepth || !fs.existsSync(dir)) return matches;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isFile() && /^playwright\.config\.(ts|js|mjs|cjs)$/.test(entry.name)) {
+      matches.push(full);
+    } else if (entry.isDirectory()) {
+      listFiles(full, depth + 1, maxDepth, matches);
+    }
+  }
+  return matches;
+}
+
+function toPosixRelative(root, absolutePath) {
+  return path.relative(root, absolutePath).split(path.sep).join("/");
+}
+
+export function detectPlaywrightRoot(repositoryRoot) {
+  const configs = listFiles(repositoryRoot);
+  const preferred = configs.sort((a, b) => a.length - b.length)[0];
+  if (!preferred) return null;
+  const configDir = path.dirname(preferred);
+  const text = fs.readFileSync(preferred, "utf8");
+  const match = text.match(/testDir:\s*['"]([^'"]+)['"]/);
+  if (match && match[1] !== ".") {
+    return toPosixRelative(repositoryRoot, path.resolve(configDir, match[1]));
+  }
+  return toPosixRelative(repositoryRoot, configDir);
+}
+
+function detectRepositoryName(repositoryRoot) {
+  const flowManifest = readJson(path.join(repositoryRoot, ORIS_FLOW_MANIFEST));
+  if (flowManifest?.repository) return String(flowManifest.repository);
+  return path.basename(repositoryRoot);
+}
+
+function detectPackageManagerCommand(repositoryRoot, testDir) {
+  const packageJsonPath = path.join(repositoryRoot, testDir, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return null;
+  const pkg = readJson(packageJsonPath);
+  const scripts = pkg?.scripts ?? {};
+  const packageRoot = path.dirname(packageJsonPath);
+  const manager = fs.existsSync(path.join(packageRoot, "pnpm-lock.yaml"))
+    ? "pnpm"
+    : fs.existsSync(path.join(packageRoot, "yarn.lock"))
+      ? "yarn"
+      : "npm";
+  const executable = process.platform === "win32" ? `${manager}.cmd` : manager;
+  const runArgs = manager === "yarn" ? [] : ["run"];
+  if (scripts.check) {
+    return {
+      name: "e2e-check",
+      command: { executable, args: [...runArgs, "check"], cwd: testDir },
+    };
+  }
+  if (scripts.test) {
+    return {
+      name: "e2e-target",
+      command: { executable, args: [...runArgs, "test", "--", "--project=chromium"], cwd: testDir },
+    };
+  }
+  return null;
+}
+
+function detectProtectedPaths(repositoryRoot) {
+  const paths = [".git"];
+  for (const candidate of ["azure-pipelines.yml", ".github/workflows", ".gitlab-ci.yml", "NuGet.config"]) {
+    if (fs.existsSync(path.join(repositoryRoot, candidate))) paths.push(candidate);
+  }
+  return paths;
+}
+
+export function buildAdapterDraft(repositoryRoot, hints = {}) {
+  const repository = hints.repository ?? detectRepositoryName(repositoryRoot);
+  const testDir = hints.testDir ?? detectPlaywrightRoot(repositoryRoot);
+  const allowed = new Set([
+    ORIS_FLOW_LOOPS_ROOT,
+    ".oris-flow/maps",
+    ...(Array.isArray(hints.allowed) ? hints.allowed : []),
+  ]);
+  for (const optionalPath of ["docs", "docs/tasks", "specs", "src", "test", "tests"]) {
+    if (fs.existsSync(path.join(repositoryRoot, optionalPath))) allowed.add(optionalPath);
+  }
+  if (testDir) allowed.add(testDir);
+
+  const commands = {
+    verify: {
+      executable: process.execPath,
+      args: ["--version"],
+      cwd: ".",
+    },
+  };
+  const npmCommand = testDir ? detectPackageManagerCommand(repositoryRoot, testDir) : null;
+  if (npmCommand) commands[npmCommand.name] = npmCommand.command;
+
+  const adapter = {
+    $schema: ORIS_LOOP_SCHEMA,
+    schemaVersion: ORIS_LOOP_SCHEMA_VERSION,
+    repository,
+    paths: {
+      taskRoots: fs.existsSync(path.join(repositoryRoot, "docs", "tasks")) ? ["docs/tasks"] : [],
+      runtime: ORIS_FLOW_RUNTIME,
+      loops: ORIS_FLOW_LOOPS_ROOT,
+      allowed: [...allowed],
+      protected: detectProtectedPaths(repositoryRoot),
+    },
+    commands,
+    models: {},
+    profile: {
+      required: false,
+      defaultRole: "testing",
+      mappings: [],
+    },
+    preflight: {
+      minFreeDiskGiB: 5,
+    },
+  };
+  if (testDir) adapter.paths.testDir = testDir;
+  return adapter;
+}
+
+function hookFiles(platform, root) {
+  if (platform === "claude") {
+    return {
+      registrationPath: path.join(root, ".claude", "settings.json"),
+      wrapperPath: path.join(root, ".claude", "hooks", "oris-loop-stop.mjs"),
+    };
+  }
+  return {
+    registrationPath: path.join(root, ".cursor", "hooks.json"),
+    wrapperPath: path.join(root, ".cursor", "hooks", "oris-loop-stop.mjs"),
+  };
+}
+
+function hookRegistered(platform, registrationPath) {
+  const data = readJson(registrationPath);
+  if (!data) return false;
+  if (platform === "claude") {
+    return JSON.stringify(data?.hooks?.Stop ?? []).includes("oris-loop-stop");
+  }
+  const stops = data?.hooks?.stop ?? [];
+  return stops.some((entry) => String(entry?.command ?? "").includes("oris-loop-stop"));
+}
+
+export function assessLoopReadiness(repositoryRoot, platforms = HOOK_PLATFORMS) {
+  const root = path.resolve(repositoryRoot);
+  const adapterPath = path.join(root, ORIS_FLOW_ADAPTER);
+  const missing = [];
+  if (!fs.existsSync(adapterPath)) missing.push(ORIS_FLOW_ADAPTER);
+  for (const platform of platforms) {
+    const { registrationPath, wrapperPath } = hookFiles(platform, root);
+    if (!hookRegistered(platform, registrationPath)) {
+      missing.push(`${toPosixRelative(root, registrationPath)} stop registration for Oris Loop`);
+    }
+    if (!fs.existsSync(wrapperPath)) missing.push(toPosixRelative(root, wrapperPath));
+  }
+  return {
+    ready: missing.length === 0,
+    missing,
+    paths: { adapterPath },
+  };
+}
+
+function ensureGitignore(repositoryRoot, dryRun) {
+  return ensureGitignoreEntries(repositoryRoot, [ORIS_LOOP_GITIGNORE_ENTRY], dryRun);
+}
+
+export function writeStopHookWrapper(repositoryRoot, platform = "cursor") {
+  const { wrapperPath } = hookFiles(platform, path.resolve(repositoryRoot));
+  fs.mkdirSync(path.dirname(wrapperPath), { recursive: true });
+  fs.writeFileSync(wrapperPath, stopHookWrapperSource(platform), "utf8");
+  return wrapperPath;
+}
+
+export function writeHooksRegistration(repositoryRoot, platform = "cursor") {
+  const root = path.resolve(repositoryRoot);
+  const { registrationPath } = hookFiles(platform, root);
+  fs.mkdirSync(path.dirname(registrationPath), { recursive: true });
+  const existing = readJson(registrationPath) ?? (platform === "claude" ? {} : { version: 1, hooks: {} });
+  if (platform === "claude") {
+    existing.hooks ??= {};
+    const stops = Array.isArray(existing.hooks.Stop) ? existing.hooks.Stop : [];
+    if (!JSON.stringify(stops).includes("oris-loop-stop")) {
+      stops.push({ hooks: [{ type: "command", command: CLAUDE_STOP_COMMAND }] });
+    }
+    existing.hooks.Stop = stops;
+  } else {
+    existing.version ??= 1;
+    existing.hooks ??= {};
+    const stops = Array.isArray(existing.hooks.stop) ? existing.hooks.stop : [];
+    if (!stops.some((entry) => String(entry?.command ?? "").includes("oris-loop-stop"))) {
+      stops.push({ command: CURSOR_STOP_COMMAND, loop_limit: null });
+    }
+    existing.hooks.stop = stops;
+  }
+  fs.writeFileSync(registrationPath, `${JSON.stringify(existing, null, 2)}\n`, "utf8");
+  return registrationPath;
+}
+
+function ensureHookPlatform(repositoryRoot, platform, dryRun, actions) {
+  const root = path.resolve(repositoryRoot);
+  const { registrationPath, wrapperPath } = hookFiles(platform, root);
+  if (hookRegistered(platform, registrationPath)) {
+    actions.push({ action: "present", path: registrationPath });
+  } else if (dryRun) {
+    actions.push({ action: fs.existsSync(registrationPath) ? "merge" : "create", path: registrationPath });
+  } else {
+    actions.push({ action: "registered", path: writeHooksRegistration(root, platform) });
+  }
+  if (fs.existsSync(wrapperPath)) {
+    actions.push({ action: "present", path: wrapperPath });
+  } else if (dryRun) {
+    actions.push({ action: "create", path: wrapperPath });
+  } else {
+    actions.push({ action: "created", path: writeStopHookWrapper(root, platform) });
+  }
+}
+
+export function bootstrapLoop(repositoryRoot, options = {}) {
+  const root = path.resolve(repositoryRoot);
+  const dryRun = Boolean(options.dryRun);
+  const platforms = Array.isArray(options.platforms) && options.platforms.length > 0
+    ? options.platforms.filter((platform) => HOOK_PLATFORMS.includes(platform))
+    : HOOK_PLATFORMS;
+  const assessment = assessLoopReadiness(root, platforms);
+  if (assessment.ready) {
+    return {
+      repositoryRoot: root,
+      dryRun,
+      platforms,
+      before: assessment,
+      after: assessment,
+      actions: [],
+      ready: true,
+    };
+  }
+  const actions = [];
+
+  if (!fs.existsSync(path.join(root, ORIS_FLOW_ADAPTER))) {
+    const adapterPath = path.join(root, ORIS_FLOW_ADAPTER);
+    if (dryRun) {
+      actions.push({ action: "create", path: adapterPath, detail: "adapter draft" });
+    } else {
+      const adapter = buildAdapterDraft(root, options);
+      fs.mkdirSync(path.dirname(adapterPath), { recursive: true });
+      fs.writeFileSync(adapterPath, `${JSON.stringify(adapter, null, 2)}\n`, "utf8");
+      actions.push({ action: "created", path: adapterPath });
+    }
+  } else {
+    actions.push({ action: "present", path: path.join(root, ORIS_FLOW_ADAPTER) });
+  }
+
+  for (const platform of platforms) {
+    ensureHookPlatform(root, platform, dryRun, actions);
+  }
+
+  actions.push(ensureGitignore(root, dryRun));
+
+  const after = dryRun ? assessment : assessLoopReadiness(root, platforms);
+  return {
+    repositoryRoot: root,
+    dryRun,
+    platforms,
+    before: assessment,
+    after,
+    actions,
+    ready: after.ready,
+  };
+}
+
+function parseArgs(argv) {
+  const options = {
+    repositoryRoot: process.cwd(),
+    dryRun: false,
+    json: false,
+    platforms: [],
+  };
+  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("--platforms=")) options.platforms = raw.slice("--platforms=".length).split(",").map((value) => value.trim()).filter(Boolean);
+    else if (raw === "--platforms" && argv[i + 1]) {
+      options.platforms = argv[i + 1].split(",").map((value) => value.trim()).filter(Boolean);
+      i += 1;
+    } 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 printBootstrapReport(result) {
+  console.log(`Oris Loop bootstrap${result.dryRun ? " (dry run)" : ""}`);
+  console.log(`Repository: ${result.repositoryRoot}`);
+  console.log(`Hook platforms: ${result.platforms.join(", ")}`);
+  console.log("");
+  if (result.before.ready) {
+    console.log("Loop readiness: already configured.");
+    return;
+  }
+  console.log(`Loop readiness before: missing ${result.before.missing.length} item(s)`);
+  for (const item of result.before.missing) console.log(`- ${item}`);
+  console.log("");
+  console.log("Planned actions:");
+  for (const action of result.actions) {
+    console.log(`- ${action.action}: ${action.path}${action.detail ? ` (${action.detail})` : ""}`);
+  }
+  console.log("");
+  console.log(result.ready ? "Loop readiness: complete." : "Loop readiness: incomplete.");
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
+  const options = parseArgs(process.argv.slice(2));
+  const result = bootstrapLoop(options.repositoryRoot, { dryRun: options.dryRun, platforms: options.platforms });
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    printBootstrapReport(result);
+  }
+  process.exit(result.ready || result.dryRun ? 0 : 1);
+}

package/scripts/loop/oris-loop-bundle.mjs

@@ -0,0 +1,22 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** Resolve the OrisSkills scripts directory for bundled loop helpers. */
+export function resolveScriptsRoot(fromImportMetaUrl) {
+  if (process.env.ORIS_SKILLS_SCRIPTS_ROOT) {
+    return path.resolve(process.env.ORIS_SKILLS_SCRIPTS_ROOT);
+  }
+  const local = path.dirname(fileURLToPath(fromImportMetaUrl));
+  if (fs.existsSync(path.join(local, "oris-loop-stop.mjs"))) {
+    return local;
+  }
+  const installed = path.join(os.homedir(), ".oris", "oris-skills", "scripts", "loop");
+  if (fs.existsSync(installed)) return installed;
+  return path.join(os.homedir(), ".cursor", "oris-skills", "scripts", "loop");
+}
+
+export function scriptPath(fromImportMetaUrl, fileName) {
+  return path.join(resolveScriptsRoot(fromImportMetaUrl), fileName);
+}