npm - @jnyross/code-factory - Versions diffs - 1.0.0 → 1.1.1 - Mend

@jnyross/code-factory 1.0.0 → 1.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/README.md CHANGED Viewed

@@ -1,88 +1,119 @@
 # Code Factory Template
-A private-first template for running Ryan Carson-style "Ralph" autonomous loops with local CLI tooling and flat-rate subscriptions.
-## Zero-API Cost Principle
-This template is built to avoid extra API token costs:
-- Use local CLI agents (Claude Code CLI, Cursor Ultra agent mode, Antigravity, GLM coding plan, Minimax coding plan, ChatGPT Pro workflows).
-- Do not add direct token-billed API calls in repository scripts.
-- Keep all automation in repo-native shell scripts and CI.
+Code Factory is a repo control-plane for autonomous coding + deterministic review.
+This template implements the full pattern:
+- one machine-readable contract
+- risk-policy gate before expensive CI fanout
+- current-head SHA review discipline
+- canonical rerun comment dedupe
+- bot-only thread auto-resolve after clean rerun
+- browser evidence verification for UI/user-flow changes
+- incident -> harness-gap loop with weekly metrics
+## Contract (single source of truth)
+All control-plane policy lives in `ARCHITECTURE.yaml` under `control_plane`:
+- `riskTierRules`
+- `mergePolicy`
+- `docsDriftRules`
+- `reviewAgent`
+- `browserEvidence`
+- `harnessGapLoop`
+## Workflow Order
+`Control Plane` workflow (`.github/workflows/preflight.yml`) runs jobs in this order:
+1. `risk-policy-gate`
+2. fanout: `CI Pipeline`, `harness-smoke`, `Browser Evidence`
+3. `risk-policy-finalize`
+For `high` tier changes, the gate auto-applies the PR label `high-risk`.
+`Code Review Agent` workflow (`.github/workflows/auto-review.yml`) runs in parallel and is enforced by SHA-aware policy checks.
+## SHA Discipline and Reruns
+`scripts/control-plane/risk-policy-gate.mjs` enforces:
+- review check must be for current PR head SHA
+- stale review state is rejected
+- actionable findings in review summary comment fail the gate
+- canonical rerun request comment is deduped by marker + `sha:<head>`
+## Browser Evidence
+For UI-sensitive paths, `Browser Evidence` requires a valid manifest:
+- path: `harness/browser-evidence/manifest.json`
+- freshness window and required flows defined in `ARCHITECTURE.yaml`
+Generate/update evidence manifest:
+```bash
+npm run harness:ui:capture-browser-evidence
+npm run harness:ui:verify-browser-evidence
+```
-## Core Loop Files
-- `ARCHITECTURE.yaml`: Machine-readable architecture contract.
-- `AGENTS.md`: Shared autonomous loop policy.
-- `prd.json`: Task queue for agents.
-- `progress.txt`: Append-only execution journal.
+## Harness Gap Loop
+`harness-gap-loop` workflow:
+- creates a `harness-gap` issue when a `production-regression` issue appears
+- runs weekly metrics (`npm run harness:weekly-metrics`)
-## Tool Rule Files
-- `.cursorrules`: Cursor Ultra native behavior.
-- `CLAUDE.md`: Claude Code CLI behavior.
-- `.agent/rules/CodeFactory.md`: Antigravity/GLM/Minimax behavior.
-- `prompt_template.txt`: ChatGPT Pro project-manager prompt.
-## Local Runner
-`ralph.sh` is rewritten to use local CLI tools only.
-Runner behavior:
-1. Reads next open task from `prd.json`.
-2. Invokes a local agent CLI for implementation (`codex` by default).
-3. Runs preflight checks:
-   - `npm run typecheck`
-   - `npm run lint`
-   - `npm test`
-4. Appends progress to `progress.txt`.
-5. Marks task done only when preflight passes.
-Engine selection:
-- Default: `codex` (`AGENT_ENGINE=codex`).
-- Claude: `AGENT_ENGINE=claude`.
-- OpenCode: `AGENT_ENGINE=opencode` (defaults to `minimax-coding-plan/MiniMax-M2.5`).
-- Custom CLI: `AGENT_ENGINE=custom AGENT_CMD='<your command>'`.
-Examples:
+## Local Command Set
 ```bash
-./ralph.sh --once
-AGENT_ENGINE=claude ./ralph.sh --once
-AGENT_ENGINE=opencode ./ralph.sh --once
-OPENCODE_MODEL=minimax-coding-plan/MiniMax-M2.5 AGENT_ENGINE=opencode ./ralph.sh --once
-AGENT_ENGINE=custom AGENT_CMD='your-cli --non-interactive -' ./ralph.sh --once
+npm run typecheck
+npm test
+npm run build:ci --if-present
+npm run harness:legal-chat:smoke
+npm run harness:ui:pre-pr
+npm run harness:ui:capture-browser-evidence
+npm run harness:ui:verify-browser-evidence
+npm run harness:risk-tier
+npm run harness:weekly-metrics
 ```
-Preflight directory selection:
-- First choice: repository root.
-- Fallback: `flowchart/` (included in this base template).
-- Override with `PROJECT_DIR=/path/to/app`.
-## CI Safety Layer
-- `.github/workflows/preflight.yml`
-  - Labels risky PRs as `high-risk` when touching paths like `db/`, `auth/`, or `infra/`.
-  - Runs typecheck/lint/tests in root or fallback `flowchart/`.
-- `.github/workflows/auto-review.yml`
-  - Adds or updates a secondary agent-review comment on PRs.
+## Agent Loop Files
+- `ARCHITECTURE.yaml`
+- `AGENTS.md`
+- `prd.json`
+- `progress.txt`
-## New Project Bootstrap
-Use the CLI to create a fresh repo from this template with clean git history.
+## Tool Rule Files
+- `.cursorrules`
+- `CLAUDE.md`
+- `.agent/rules/CodeFactory.md`
+- `prompt_template.txt`
+- `chatgpt_architecture_prd_prompt.txt`
+- `chatgpt_prd_format_prompt.txt`
+## CLI Install
+```bash
+npm install -g @jnyross/code-factory
+```
-Example:
+## Create a New Project
+Local only:
 ```bash
 code-factory my-next-app ~/Projects
 ```
-Global install:
+Create + push GitHub repo in one command:
 ```bash
-npm install -g @jnyross/code-factory
+code-factory my-next-app ~/Projects --github --private
+```
+Examples:
+```bash
+code-factory my-next-app --github --owner my-org --repo my-org/my-next-app --public
 ```
 Compatibility alias:
 - `new-project` points to the same CLI command as `code-factory`.
-## Suggested Working Loop
-1. Copy `prd.json.example` to `prd.json` (already present in this template).
-2. Add real tasks to `prd.json`.
-3. Run `./ralph.sh --once` for a single task cycle or `./ralph.sh` for looped operation.
-4. Review `progress.txt` after each run.
-5. Open PR and require preflight workflow success before merge.
+## Ralph Runner
+`ralph.sh` supports:
+- `codex` (default)
+- `claude`
+- `opencode` (default model `minimax-coding-plan/MiniMax-M2.5`)
+- `custom`
-## Notes
-- This template assumes a Node/TypeScript project with `typecheck`, `lint`, and `test` scripts.
-- If you use different commands, update `ralph.sh`, `ARCHITECTURE.yaml`, and workflow files together.
+Examples:
+```bash
+./ralph.sh --once
+AGENT_ENGINE=claude ./ralph.sh --once
+AGENT_ENGINE=opencode ./ralph.sh --once
+```

package/bin/code-factory.mjs CHANGED Viewed

@@ -5,62 +5,184 @@ import { existsSync, rmSync } from "node:fs";
 import { resolve } from "node:path";
 import process from "node:process";
-const TEMPLATE_URL =
+const DEFAULT_TEMPLATE_URL =
   process.env.CODE_FACTORY_TEMPLATE_URL ??
   "https://github.com/jnyross/code-factory-template.git";
 function usage(exitCode = 0) {
   console.log(`Usage:
-  code-factory <project-name> [destination-directory]
-  code-factory new <project-name> [destination-directory]
+  code-factory <project-name> [destination-directory] [options]
+  code-factory new <project-name> [destination-directory] [options]
+Options:
+  --github              Create and push a new GitHub repo via gh CLI
+  --public              Use public visibility for --github
+  --private             Use private visibility for --github (default)
+  --owner <owner>       GitHub owner/org for --github (defaults to gh auth user)
+  --repo <name|owner/name>
+                        GitHub repo name override (default: slugified project name)
+  --template-url <url>  Override template repository URL for this run
+  -h, --help            Show help
 Examples:
   code-factory my-app
   code-factory "Youth Reg Response Platform" ~/Software_Projects
-Environment:
-  CODE_FACTORY_TEMPLATE_URL  Override template repository URL
+  code-factory my-app ~/Software_Projects --github --private
+  code-factory my-app --github --owner my-org --repo my-org/my-app
 `);
   process.exit(exitCode);
 }
-function run(cmd, args) {
-  execFileSync(cmd, args, { stdio: "inherit" });
+function run(cmd, args, cwd) {
+  execFileSync(cmd, args, { stdio: "inherit", cwd });
 }
-const rawArgs = process.argv.slice(2);
-if (rawArgs.length === 0 || rawArgs.includes("-h") || rawArgs.includes("--help")) {
-  usage(0);
+function runCapture(cmd, args, cwd) {
+  return execFileSync(cmd, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    cwd,
+    encoding: "utf8"
+  }).trim();
 }
-let args = rawArgs;
-if (args[0] === "new") {
-  args = args.slice(1);
+function slugify(name) {
+  return name
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-{2,}/g, "-")
+    .slice(0, 80);
 }
-if (args.length < 1 || args.length > 2) {
-  usage(1);
+function parseArgs(rawArgs) {
+  const options = {
+    github: false,
+    visibility: "private",
+    owner: null,
+    repo: null,
+    templateUrl: DEFAULT_TEMPLATE_URL
+  };
+  let args = [...rawArgs];
+  if (args[0] === "new") {
+    args = args.slice(1);
+  }
+  const positional = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--github") {
+      options.github = true;
+      continue;
+    }
+    if (arg === "--public") {
+      options.visibility = "public";
+      continue;
+    }
+    if (arg === "--private") {
+      options.visibility = "private";
+      continue;
+    }
+    if (arg === "--owner") {
+      options.owner = args[index + 1] ?? null;
+      index += 1;
+      continue;
+    }
+    if (arg === "--repo") {
+      options.repo = args[index + 1] ?? null;
+      index += 1;
+      continue;
+    }
+    if (arg === "--template-url") {
+      options.templateUrl = args[index + 1] ?? DEFAULT_TEMPLATE_URL;
+      index += 1;
+      continue;
+    }
+    if (arg === "-h" || arg === "--help") {
+      usage(0);
+    }
+    if (arg.startsWith("--")) {
+      console.error(`Unknown option: ${arg}`);
+      usage(1);
+    }
+    positional.push(arg);
+  }
+  if (positional.length < 1 || positional.length > 2) {
+    usage(1);
+  }
+  return {
+    projectName: positional[0],
+    destinationDir: positional[1] ?? process.cwd(),
+    options
+  };
 }
-const projectName = args[0];
-const destinationDir = args[1] ?? process.cwd();
-const targetPath = resolve(destinationDir, projectName);
+function deriveGitHubRepo(projectName, options) {
+  if (options.repo && options.repo.includes("/")) {
+    const [owner, repo] = options.repo.split("/");
+    return { owner, repo };
+  }
-if (existsSync(targetPath)) {
-  console.error(`Target already exists: ${targetPath}`);
-  process.exit(1);
+  const repo = options.repo ?? slugify(projectName);
+  if (!repo) {
+    throw new Error("Could not derive GitHub repository name from project name.");
+  }
+  const owner = options.owner ?? runCapture("gh", ["api", "user", "-q", ".login"]);
+  if (!owner) {
+    throw new Error("Unable to determine GitHub owner. Pass --owner.");
+  }
+  return { owner, repo };
 }
-try {
-  run("git", ["clone", TEMPLATE_URL, targetPath]);
+function createProject(projectName, destinationDir, options) {
+  const targetPath = resolve(destinationDir, projectName);
+  if (existsSync(targetPath)) {
+    throw new Error(`Target already exists: ${targetPath}`);
+  }
+  run("git", ["clone", options.templateUrl, targetPath]);
   rmSync(resolve(targetPath, ".git"), { recursive: true, force: true });
   run("git", ["-C", targetPath, "init", "-q"]);
   run("git", ["-C", targetPath, "add", "."]);
   run("git", ["-C", targetPath, "commit", "-q", "-m", "Initial commit from Code Factory template"]);
+  if (options.github) {
+    const { owner, repo } = deriveGitHubRepo(projectName, options);
+    const fullRepo = `${owner}/${repo}`;
+    const visibilityFlag = options.visibility === "public" ? "--public" : "--private";
+    run("gh", ["repo", "create", fullRepo, visibilityFlag, "--source", targetPath, "--remote", "origin", "--push"]);
+    console.log(`GitHub repo created: https://github.com/${fullRepo}`);
+  }
   console.log("Your new Code Factory project is ready!");
   console.log(`Path: ${targetPath}`);
+}
+try {
+  const rawArgs = process.argv.slice(2);
+  if (rawArgs.length === 0) {
+    usage(0);
+  }
+  const { projectName, destinationDir, options } = parseArgs(rawArgs);
+  createProject(projectName, destinationDir, options);
 } catch (error) {
   const message = error instanceof Error ? error.message : String(error);
   console.error(`code-factory failed: ${message}`);

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@jnyross/code-factory",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Bootstrap new repos from the Code Factory template.",
   "type": "module",
   "license": "MIT",
@@ -24,11 +24,22 @@
     "code-factory": "bin/code-factory.mjs",
     "new-project": "bin/code-factory.mjs"
   },
+  "scripts": {
+    "harness:risk-tier": "node scripts/control-plane/risk-tier.mjs",
+    "harness:legal-chat:smoke": "node scripts/control-plane/harness-smoke.mjs",
+    "harness:ui:capture-browser-evidence": "node scripts/control-plane/capture-browser-evidence.mjs",
+    "harness:ui:verify-browser-evidence": "node scripts/control-plane/verify-browser-evidence.mjs",
+    "harness:ui:pre-pr": "npm run harness:ui:capture-browser-evidence && npm run harness:ui:verify-browser-evidence",
+    "harness:weekly-metrics": "node scripts/control-plane/weekly-metrics.mjs"
+  },
   "files": [
     "bin",
     "README.md",
     "LICENSE"
   ],
+  "dependencies": {
+    "yaml": "^2.8.1"
+  },
   "engines": {
     "node": ">=18"
   },