runshift 0.0.2 → 0.0.4

package/src/context/collector.ts

@@ -0,0 +1,205 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { RepoContext } from "../types.js";
+import { getGitState } from "./git.js";
+
+const IGNORE_DIRS = new Set([
+  "node_modules", ".git", "dist", ".next", ".vercel", ".turbo",
+  "__pycache__", ".cache", "coverage", ".nyc_output", "build",
+]);
+
+const CONFIG_PATTERNS = [
+  "next.config.ts", "next.config.js", "next.config.mjs",
+  "tailwind.config.ts", "tailwind.config.js",
+  "supabase/config.toml",
+  "vercel.json",
+  "prisma/schema.prisma",
+  "drizzle.config.ts",
+  ".eslintrc.json", ".eslintrc.js", "eslint.config.js", "eslint.config.mjs",
+  ".prettierrc", ".prettierrc.json",
+  "jest.config.ts", "jest.config.js",
+  "vitest.config.ts", "vitest.config.js",
+  "playwright.config.ts",
+];
+
+function readJsonSafe(filePath: string): Record<string, unknown> | null {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function readFileSafe(filePath: string): string | null {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function getDirectoryTree(root: string, maxDepth: number = 2): string[] {
+  const entries: string[] = [];
+
+  function walk(dir: string, depth: number, prefix: string) {
+    if (depth > maxDepth) return;
+
+    let items: fs.Dirent[];
+    try {
+      items = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const item of items) {
+      if (IGNORE_DIRS.has(item.name)) continue;
+      if (item.name.startsWith(".") && depth === 0 && item.isDirectory()) continue;
+
+      const relative = prefix ? `${prefix}/${item.name}` : item.name;
+
+      if (item.isDirectory()) {
+        entries.push(`${relative}/`);
+        walk(path.join(dir, item.name), depth + 1, relative);
+      } else if (depth <= 1) {
+        entries.push(relative);
+      }
+    }
+  }
+
+  walk(root, 0, "");
+  return entries;
+}
+
+function getRootConfigs(root: string): string[] {
+  const configPatterns = [
+    /^\..*rc$/,
+    /^\..*rc\.json$/,
+    /^\..*rc\.js$/,
+    /^\..*rc\.yml$/,
+    /^\..*rc\.yaml$/,
+    /\.config\.(ts|js|mjs|cjs)$/,
+    /^tsconfig.*\.json$/,
+    /^docker-compose.*\.ya?ml$/,
+    /^Dockerfile/,
+    /^Makefile$/,
+    /^\.env\.example$/,
+  ];
+
+  try {
+    const items = fs.readdirSync(root);
+    return items.filter((item) => {
+      return configPatterns.some((p) => p.test(item));
+    });
+  } catch {
+    return [];
+  }
+}
+
+export function collectRepoContext(root: string): RepoContext {
+  // ── package.json ──
+  const pkgJson = readJsonSafe(path.join(root, "package.json"));
+  const packageJson = pkgJson
+    ? {
+        name: pkgJson.name as string | undefined,
+        description: pkgJson.description as string | undefined,
+        dependencies: (pkgJson.dependencies ?? {}) as Record<string, string>,
+        devDependencies: (pkgJson.devDependencies ?? {}) as Record<string, string>,
+        scripts: (pkgJson.scripts ?? {}) as Record<string, string>,
+        workspaces: pkgJson.workspaces as string[] | { packages: string[] } | undefined,
+      }
+    : { dependencies: {}, devDependencies: {}, scripts: {} };
+
+  // ── tsconfig.json ──
+  const tsconfig = readJsonSafe(path.join(root, "tsconfig.json"));
+
+  // ── Directory tree ──
+  const directoryTree = getDirectoryTree(root);
+
+  // ── .env.example — key names only ──
+  const envKeys: string[] = [];
+  const envContent = readFileSafe(path.join(root, ".env.example"));
+  if (envContent) {
+    for (const line of envContent.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        const key = trimmed.split("=")[0].trim();
+        if (key) envKeys.push(key);
+      }
+    }
+  }
+
+  // ── Config files ──
+  const configFiles: Record<string, string> = {};
+  for (const pattern of CONFIG_PATTERNS) {
+    const fullPath = path.join(root, pattern);
+    const content = readFileSafe(fullPath);
+    if (content) {
+      // Cap config file content at 5000 chars
+      configFiles[pattern] = content.slice(0, 5000);
+    }
+  }
+
+  // ── Existing rules ──
+  const existingRules: Record<string, string> = {};
+
+  // .cursor/rules/
+  const cursorRulesDir = path.join(root, ".cursor", "rules");
+  try {
+    const ruleFiles = fs.readdirSync(cursorRulesDir);
+    for (const file of ruleFiles) {
+      const content = readFileSafe(path.join(cursorRulesDir, file));
+      if (content) {
+        existingRules[`.cursor/rules/${file}`] = content;
+      }
+    }
+  } catch {
+    // no existing rules
+  }
+
+  // CLAUDE.md
+  const claudeMd = readFileSafe(path.join(root, "CLAUDE.md"));
+  if (claudeMd) {
+    existingRules["CLAUDE.md"] = claudeMd;
+  }
+
+  // ── Migrations ──
+  let migrationCount = 0;
+  let migrationNames: string[] = [];
+  const migrationsDir = path.join(root, "supabase", "migrations");
+  try {
+    const migFiles = fs.readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"));
+    migrationCount = migFiles.length;
+    migrationNames = migFiles;
+  } catch {
+    // no migrations
+  }
+
+  // ── Root configs ──
+  const rootConfigs = getRootConfigs(root);
+
+  // ── Git state ──
+  const git = getGitState();
+  const gitState = git.isGitRepo ? { branch: git.branch, isDirty: git.isDirty } : null;
+
+  return {
+    packageJson,
+    tsconfig,
+    directoryTree,
+    envKeys,
+    configFiles,
+    existingRules,
+    migrationCount,
+    migrationNames,
+    rootConfigs,
+    gitState,
+  };
+}
+
+export function addFileToContext(root: string, filePath: string, context: RepoContext): boolean {
+  const fullPath = path.resolve(root, filePath);
+  const content = readFileSafe(fullPath);
+  if (!content) return false;
+  context.configFiles[filePath] = content.slice(0, 5000);
+  return true;
+}

package/src/context/git.ts

@@ -0,0 +1,36 @@
+import { execSync } from "node:child_process";
+
+export interface GitState {
+  isGitRepo: boolean;
+  branch: string;
+  isDirty: boolean;
+}
+
+export function getGitState(): GitState {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { stdio: "pipe" });
+  } catch {
+    return { isGitRepo: false, branch: "", isDirty: false };
+  }
+
+  let branch = "";
+  try {
+    branch = execSync("git branch --show-current", { stdio: "pipe" })
+      .toString()
+      .trim();
+  } catch {
+    branch = "unknown";
+  }
+
+  let isDirty = false;
+  try {
+    const status = execSync("git status --porcelain", { stdio: "pipe" })
+      .toString()
+      .trim();
+    isDirty = status.length > 0;
+  } catch {
+    isDirty = false;
+  }
+
+  return { isGitRepo: true, branch, isDirty };
+}

package/src/index.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import { init } from "./commands/init.js";
+
+const args = process.argv.slice(2);
+const command = args[0] ?? "init";
+
+switch (command) {
+  case "init":
+    init(args.slice(1)).catch((err) => {
+      console.error(err.message ?? err);
+      process.exit(1);
+    });
+    break;
+  case "--version":
+  case "-v":
+    console.log("runshift 0.0.3");
+    break;
+  case "--help":
+  case "-h":
+    console.log(`
+  runshift — the control plane for agents, wherever they run.
+
+  Usage:
+    npx runshift init [options]   Read your repo, generate governance rules
+
+  Options:
+    --version, -v                 Show version
+    --help, -h                    Show this help
+
+  Init options:
+    --dry-run                     Preview changes without writing files
+    --branch <name>               Run on a new branch (default: relay-init)
+`);
+    break;
+  default:
+    console.error(`Unknown command: ${command}\nRun "runshift --help" for usage.`);
+    process.exit(1);
+}

package/src/types.ts

@@ -0,0 +1,44 @@
+// ── Shared types mirroring the API contract ──
+
+export interface RepoContext {
+  packageJson: {
+    name?: string;
+    description?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    workspaces?: string[] | { packages: string[] };
+  };
+  tsconfig: Record<string, unknown> | null;
+  directoryTree: string[];
+  envKeys: string[];
+  configFiles: Record<string, string>;
+  existingRules: Record<string, string>;
+  migrationCount: number;
+  migrationNames: string[];
+  rootConfigs: string[];
+  gitState: {
+    branch: string;
+    isDirty: boolean;
+  } | null;
+}
+
+export interface GeneratedFile {
+  path: string;
+  content: string;
+  action: "create" | "update";
+}
+
+export interface Findings {
+  blastRadius: string[];
+  securityGaps: string[];
+  agentFailurePatterns: string[];
+  parallelizationBoundaries: string[];
+  deprecatedPatterns: string[];
+}
+
+export interface InitResponse {
+  files: GeneratedFile[];
+  findings: Findings;
+  summary: string;
+}

package/src/ui/display.ts

@@ -0,0 +1,184 @@
+import chalk from "chalk";
+import figlet from "figlet";
+import type { Findings, GeneratedFile, RepoContext } from "../types.js";
+
+const amber = chalk.hex("#f5a623");
+const muted = chalk.hex("#6b6b7b");
+const dim = chalk.dim;
+const divider = muted("  " + "─".repeat(45));
+
+export function showBanner(): void {
+  const banner = figlet.textSync("runshift", {
+    font: "Standard",
+    horizontalLayout: "default",
+  });
+  console.log(amber(banner));
+  console.log(muted("  v0.0.3"));
+  console.log(muted("  the control plane for agents, wherever they run."));
+  console.log(dim("  usage: npx runshift init [--dry-run] [--branch <name>]\n"));
+  console.log(divider + "\n");
+}
+
+export function showNotGitRepo(): void {
+  console.log(amber("  this directory is not a git repository."));
+  console.log(dim("  run runshift init from a project root with git initialized.\n"));
+}
+
+export function showDirtyWarning(): void {
+  console.log(muted("  ⚠ uncommitted changes detected\n"));
+}
+
+export function showBranchInfo(branch: string): void {
+  console.log(dim(`  on branch ${amber(branch)}\n`));
+}
+
+export function showScanResults(context: RepoContext): void {
+  console.log(amber("  relay scanned your repository:\n"));
+
+  const deps: Record<string, string> = {
+    ...context.packageJson.dependencies,
+    ...context.packageJson.devDependencies,
+  };
+
+  const detections: string[] = [];
+
+  if (context.packageJson.name) {
+    const stack: string[] = [];
+    if (deps["next"]) stack.push("Next.js");
+    if (deps["@supabase/supabase-js"] || deps["@supabase/ssr"]) stack.push("Supabase");
+    if (deps["tailwindcss"]) stack.push("Tailwind");
+    if (deps["prisma"] || deps["@prisma/client"]) stack.push("Prisma");
+    if (deps["drizzle-orm"]) stack.push("Drizzle");
+    if (deps["stripe"]) stack.push("Stripe");
+    const label = stack.length > 0 ? stack.join(", ") + " detected" : "detected";
+    detections.push(`package.json — ${label}`);
+  }
+
+  if (context.envKeys.length > 0) {
+    detections.push(`.env.example — ${context.envKeys.length} environment variable${context.envKeys.length === 1 ? "" : "s"} found`);
+  }
+
+  if (context.migrationCount > 0) {
+    detections.push(`supabase/migrations/ — ${context.migrationCount} migration file${context.migrationCount === 1 ? "" : "s"} found`);
+  }
+
+  const existingRuleKeys = Object.keys(context.existingRules);
+  const cursorRules = existingRuleKeys.filter((k) => k.startsWith(".cursor/rules/"));
+  if (cursorRules.length > 0) {
+    detections.push(`.cursor/rules/ — ${cursorRules.length} existing file${cursorRules.length === 1 ? "" : "s"} detected`);
+  }
+
+  if (existingRuleKeys.includes("CLAUDE.md")) {
+    detections.push("existing CLAUDE.md detected");
+  }
+
+  if (context.tsconfig) {
+    detections.push("tsconfig.json detected");
+  }
+
+  const configCount = Object.keys(context.configFiles).length;
+  if (configCount > 0) {
+    detections.push(`${configCount} config file${configCount === 1 ? "" : "s"} found`);
+  }
+
+  for (const d of detections) {
+    console.log(dim("  ✓ ") + d);
+  }
+  console.log();
+}
+
+export function showFindings(findings: Findings): void {
+  const sections: [string, string[]][] = [
+    ["blast radius", findings.blastRadius],
+    ["security gaps", findings.securityGaps],
+    ["agent failure patterns", findings.agentFailurePatterns],
+    ["parallelization boundaries", findings.parallelizationBoundaries],
+    ["deprecated patterns", findings.deprecatedPatterns],
+  ];
+
+  const hasFindings = sections.some(([, items]) => items.length > 0);
+  if (!hasFindings) return;
+
+  console.log(amber("  relay found issues in your codebase:\n"));
+
+  for (const [title, items] of sections) {
+    if (items.length === 0) continue;
+    console.log(amber(`  ${title}`));
+    for (const item of items) {
+      console.log(dim(`  → ${item}`));
+    }
+    console.log();
+  }
+}
+
+export function showFileList(files: GeneratedFile[]): void {
+  console.log(amber(`  relay will write ${files.length} file${files.length === 1 ? "" : "s"}:\n`));
+  for (const file of files) {
+    const prefix = file.action === "create" ? amber("+") : amber("~");
+    const action = file.action === "create" ? dim("(create)") : dim("(update — existing file)");
+    console.log(`  ${prefix} ${file.path}  ${action}`);
+  }
+  console.log(dim("\n  + = create, ~ = update existing file\n"));
+}
+
+export function showWriting(filePath: string): void {
+  console.log(dim("  ✓ ") + filePath);
+}
+
+export function showCommit(): void {
+  console.log(dim("  ✓ ") + "committed");
+}
+
+export function showSummary(summary: string): void {
+  console.log(muted(`  ${summary.replace(/\n/g, "\n  ")}\n`));
+}
+
+export function showSuccess(): void {
+  console.log("\n" + divider + "\n");
+  console.log(amber("  ✓ relay is installed in your development workflow\n"));
+  console.log(muted("  next steps:"));
+  console.log(dim("  → open Claude Code and type /validate to run your first check"));
+  console.log(dim("  → type /runshift-update to refresh rules as your stack evolves\n"));
+  console.log(muted("  connect to the runshift control plane: ") + amber("runshift.ai"));
+  console.log("\n" + divider + "\n");
+}
+
+export function showDataPolicy(): void {
+  console.log(amber("  relay will send to runshift.ai:\n"));
+  console.log(dim("  ✓ package.json (dependencies and scripts only)"));
+  console.log(dim("  ✓ directory structure (top 2 levels, folder names only)"));
+  console.log(dim("  ✓ .env.example (key names only — values are never read)"));
+  console.log(dim("  ✓ existing CLAUDE.md (if present)"));
+  console.log(dim("  ✓ existing .cursor/rules/ (if present)"));
+  console.log(dim("  ✓ migration file names (no file contents)"));
+  console.log(dim("\n  no source code is sent."));
+  console.log(dim("  no secret values are ever read.\n"));
+}
+
+export function showDryRunComplete(): void {
+  console.log("\n" + divider + "\n");
+  console.log(amber("  dry run complete — no files written."));
+  console.log(dim("  run npx runshift init to install.\n"));
+  console.log(divider + "\n");
+}
+
+export function showError(type: "network" | "rate-limit" | "validation" | "server", message?: string): void {
+  console.log();
+  switch (type) {
+    case "network":
+      console.log(amber("  could not reach relay."));
+      console.log(dim("  check your connection and try again.\n"));
+      break;
+    case "rate-limit":
+      console.log(amber("  relay rate limit reached — try again in 1 hour.\n"));
+      break;
+    case "validation":
+      console.log(amber("  relay could not read this repository."));
+      if (message) console.log(dim(`  ${message}\n`));
+      break;
+    case "server":
+      console.log(amber("  relay encountered an error — try again or visit runshift.ai."));
+      if (message) console.log(dim(`  ${message}\n`));
+      break;
+  }
+}

package/src/ui/prompt.ts

@@ -0,0 +1,33 @@
+import * as readline from "node:readline";
+
+function ask(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export async function confirm(question: string): Promise<boolean> {
+  const answer = await ask(question);
+  const normalized = answer.toLowerCase();
+  return normalized === "y" || normalized === "yes";
+}
+
+export async function promptChoice(question: string): Promise<"y" | "a" | "n"> {
+  const answer = await ask(question);
+  const normalized = answer.toLowerCase();
+  if (normalized === "a" || normalized === "add") return "a";
+  if (normalized === "y" || normalized === "yes") return "y";
+  return "n";
+}
+
+export async function promptFilePath(question: string): Promise<string> {
+  return ask(question);
+}

package/src/writer.ts

@@ -0,0 +1,37 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import type { GeneratedFile } from "./types.js";
+import { showWriting, showCommit } from "./ui/display.js";
+
+export function writeFiles(root: string, files: GeneratedFile[]): void {
+  for (const file of files) {
+    const fullPath = path.join(root, file.path);
+    const dir = path.dirname(fullPath);
+
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(fullPath, file.content, "utf-8");
+    showWriting(file.path);
+  }
+}
+
+export function commitFiles(root: string, files: GeneratedFile[]): boolean {
+  try {
+    const filePaths = files.map((f) => `"${f.path}"`).join(" ");
+
+    execSync(`git add ${filePaths}`, {
+      cwd: root,
+      stdio: "pipe",
+    });
+
+    execSync(
+      'git commit -m "chore: install runshift agent governance rules"',
+      { cwd: root, stdio: "pipe" },
+    );
+
+    showCommit();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/index.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-console.log("runshift");