@corelayer-ai/cli 0.4.5 → 0.5.1

package/dist/commands/install-skill.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, copyFileSync, unlinkSync, rmdirSync, } from "node:fs";
+import { existsSync, cpSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -7,11 +7,11 @@ const SKILL_NAME = "corelayer";
 function getSkillTargetDir() {
     return join(homedir(), ".claude", "skills", SKILL_NAME);
 }
-function getSkillSourcePath() {
+function getSkillSourceDir() {
     const thisFile = fileURLToPath(import.meta.url);
     const distDir = dirname(dirname(thisFile));
     const packageDir = dirname(distDir);
-    return join(packageDir, "skill", "SKILL.md");
+    return join(packageDir, "skill");
 }
 function printInstallHelp() {
     process.stdout
@@ -44,16 +44,15 @@ export async function runInstallSkill(args, ctx) {
         printInstallHelp();
         return;
     }
-    const source = getSkillSourcePath();
-    if (!existsSync(source)) {
-        fail("Skill file not found. The CLI package may be incomplete.");
+    const sourceDir = getSkillSourceDir();
+    if (!existsSync(join(sourceDir, "SKILL.md"))) {
+        fail("Skill files not found. The CLI package may be incomplete.");
     }
     const targetDir = getSkillTargetDir();
-    const targetFile = join(targetDir, "SKILL.md");
-    mkdirSync(targetDir, { recursive: true });
-    copyFileSync(source, targetFile);
+    rmSync(targetDir, { recursive: true, force: true });
+    cpSync(sourceDir, targetDir, { recursive: true });
     if (!ctx.quiet) {
-        process.stdout.write(`Corelayer skill installed to ${targetFile}\n`);
+        process.stdout.write(`Corelayer skill installed to ${targetDir}\n`);
     }
 }
 export async function runUninstallSkill(args, ctx) {
@@ -62,17 +61,10 @@ export async function runUninstallSkill(args, ctx) {
         return;
     }
     const targetDir = getSkillTargetDir();
-    const targetFile = join(targetDir, "SKILL.md");
-    if (!existsSync(targetFile)) {
+    if (!existsSync(targetDir)) {
         fail("Corelayer skill is not installed.");
     }
-    unlinkSync(targetFile);
-    try {
-        rmdirSync(targetDir);
-    }
-    catch {
-        // directory not empty or already removed
-    }
+    rmSync(targetDir, { recursive: true, force: true });
     if (!ctx.quiet) {
         process.stdout.write("Corelayer skill uninstalled.\n");
     }

package/dist/commands/issues.js

@@ -60,7 +60,7 @@ SUBCOMMANDS:
   get <id|slug>         Show details for one issue
   summary               Summarize issue health for a group
   diff                  Show issues new or changed since a timestamp
-  close <id>            Close an issue (write operation)
+  close <id|slug>       Close an issue (write operation)
   bulk-close            Close many issues in one request (write operation)
   reopen <id>           Reopen a closed issue (write operation)
   delete <id>           Delete an issue (write operation)
@@ -90,7 +90,7 @@ EXAMPLES:
   corelayer issues diff --group g_123 --since 2026-06-01T00:00:00Z
   corelayer issues diff --group g_123 --since 24hours
   corelayer issues diff --group g_123 --duration 2hours --limit 50
-  corelayer issues close i_456 --feedback "fixed in deploy 2026-04-07"
+  corelayer issues close corelayer-prod-engine-20260602-1 --feedback "fixed in deploy 2026-04-07"
   corelayer issues bulk-close --group g_123 --last-seen-before-or-on 14days --feedback "Not seen in two weeks"
   corelayer issues delete i_456 --yes
 `);
@@ -183,14 +183,18 @@ export async function runIssues(args, ctx) {
         return;
     }
     if (sub === "close") {
-        const issueId = commandArgs[0];
-        if (!issueId) {
-            fail('Usage: corelayer issues close <issueId> [--feedback "..."]');
+        const issueIdentifier = commandArgs[0];
+        if (!issueIdentifier) {
+            fail('Usage: corelayer issues close <issueId|slug> [--feedback "..."]');
         }
         const feedback = readFlag(args, "--feedback");
-        await client.closeIssue(issueId, feedback);
+        const issue = await client.getIssue(issueIdentifier);
+        if (!issue.id) {
+            fail("Could not resolve issue identifier to an issue ID.");
+        }
+        await client.closeIssue(issue.id, feedback);
         if (!ctx.quiet) {
-            process.stdout.write(`Issue ${issueId} closed.\n`);
+            process.stdout.write(`Issue ${issue.slug || issue.id} closed.\n`);
         }
         return;
     }

package/dist/commands/preflight.js

@@ -0,0 +1,137 @@
+import { execSync } from "node:child_process";
+import { CorelayerClient } from "../lib/api-client.js";
+import { resolveToken, resolveApiUrl } from "../lib/config.js";
+import { fail, printJson } from "../lib/output.js";
+const MAX_DIFF_CHARS = 12_000;
+function printHelp() {
+    process.stdout.write(`corelayer preflight - Check a change against org memory before you push
+
+Surfaces failure modes and things to double-check that your org has hit before for
+changes like this one. Run inside a git repo with no arguments and it derives the PR
+context from your branch; override any piece with the flags below.
+
+USAGE:
+  corelayer preflight [options]
+
+OPTIONS:
+  --title <text>         PR title (default: latest commit subject / branch name)
+  --description <text>   PR description (default: commits since base + changed files)
+  --repo <name>          Repository name (default: parsed from the git remote)
+  --base <ref>           Base branch to diff against (default: origin/HEAD, else main)
+  --diff                 Include the (truncated) code diff in what's sent
+  --json                 Output as JSON
+  -h, --help             Print help
+
+EXAMPLES:
+  corelayer preflight
+  corelayer preflight --diff
+  corelayer preflight --description "Add Redis cache to the payments worker" --repo payments-api
+`);
+}
+function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+function git(args) {
+    try {
+        return execSync(`git ${args}`, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function detectRepo() {
+    const url = git("config --get remote.origin.url");
+    if (!url)
+        return undefined;
+    const match = url.replace(/\.git$/, "").match(/([^/:]+)$/);
+    return match ? match[1] : undefined;
+}
+function detectBase() {
+    const head = git("rev-parse --abbrev-ref origin/HEAD"); // e.g. origin/main
+    if (head && head.startsWith("origin/"))
+        return head.slice("origin/".length);
+    for (const candidate of ["main", "master"]) {
+        if (git(`rev-parse --verify ${candidate}`))
+            return candidate;
+    }
+    return "main";
+}
+function severityColor(sev, noColor) {
+    const label = (sev || "n/a").toUpperCase();
+    if (noColor)
+        return label;
+    const code = sev === "critical" || sev === "high"
+        ? "31" // red
+        : sev === "medium"
+            ? "33" // yellow
+            : "90"; // grey
+    return `\x1b[${code}m${label}\x1b[0m`;
+}
+function printChecks(checks, noColor) {
+    checks.forEach((check, i) => {
+        process.stdout.write(`${i + 1}. ${check.advice}\n`);
+        const seen = check.occurrenceCount > 1 ? ` · seen ${check.occurrenceCount}×` : "";
+        const where = check.scope === "resource" ? check.anchorLabel : check.scope;
+        process.stdout.write(`   ${severityColor(check.severity, noColor)} · "${check.title}" · ${where}${seen}\n`);
+    });
+}
+export async function runPreflight(args, ctx) {
+    if (args.includes("--help") || args.includes("-h")) {
+        printHelp();
+        return;
+    }
+    const base = readFlag(args, "--base") || detectBase();
+    const commits = git(`log ${base}..HEAD --pretty=format:%s%n%b`) || "";
+    const files = git(`diff --name-only ${base}...HEAD`) || "";
+    const branch = git("rev-parse --abbrev-ref HEAD");
+    const repo = readFlag(args, "--repo") || detectRepo();
+    const title = readFlag(args, "--title") || commits.split("\n")[0]?.trim() || branch;
+    let description = readFlag(args, "--description");
+    if (!description) {
+        const parts = [];
+        if (commits.trim())
+            parts.push(commits.trim());
+        if (files.trim())
+            parts.push(`Changed files:\n${files.trim()}`);
+        description = parts.join("\n\n");
+    }
+    if (args.includes("--diff")) {
+        const diff = git(`diff ${base}...HEAD`);
+        if (diff)
+            description += `\n\nDiff:\n${diff.slice(0, MAX_DIFF_CHARS)}`;
+    }
+    if (!description.trim()) {
+        fail(`No PR context found. Run inside a git repo with commits ahead of "${base}", or pass --description.`);
+    }
+    const token = resolveToken();
+    if (!token) {
+        fail("Not authenticated. Set CORELAYER_API_KEY or run: corelayer login");
+    }
+    const apiUrl = resolveApiUrl(ctx.apiUrlOverride);
+    const client = new CorelayerClient(apiUrl, token);
+    const result = await client.preflight({
+        description,
+        title: title || undefined,
+        repo,
+    });
+    if (ctx.json) {
+        printJson(result);
+        return;
+    }
+    if (result.checks.length === 0) {
+        if (!ctx.quiet) {
+            process.stdout.write("✓ Preflight: nothing in org memory to double-check for this change.\n");
+        }
+        return;
+    }
+    if (!ctx.quiet) {
+        process.stdout.write(`Preflight — ${result.checks.length} thing(s) to double-check before you push:\n\n`);
+    }
+    printChecks(result.checks, ctx.noColor);
+}

package/dist/index.js

@@ -8,6 +8,7 @@ import { runIssues } from "./commands/issues.js";
 import { runInstallSkill, runUninstallSkill, } from "./commands/install-skill.js";
 import { runLogin } from "./commands/login.js";
 import { runLogout } from "./commands/logout.js";
+import { runPreflight } from "./commands/preflight.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 function printHelp() {
@@ -23,6 +24,7 @@ COMMANDS:
   api-keys           Create Corelayer API keys
   groups             List and inspect groups
   issues             List, inspect, and manage issues
+  preflight          Check a change against org memory before you push
   integrations       List integrations for a group
   config             Read and write local CLI config
   install-skill      Install the Corelayer agent skill
@@ -119,6 +121,9 @@ async function main() {
         case "integrations":
             await runIntegrations(rest, ctx);
             return;
+        case "preflight":
+            await runPreflight(rest, ctx);
+            return;
         case "config":
             await runConfig(rest, ctx);
             return;

package/dist/lib/api-client.js

@@ -64,6 +64,9 @@ export class CorelayerClient {
     async getIssue(issueId) {
         return this.request("GET", `/api/v1/issues/${issueId}`);
     }
+    async preflight(params) {
+        return this.request("POST", "/api/v1/preflight", params);
+    }
     async closeIssue(issueId, feedback) {
         await this.request("PATCH", `/api/v1/issues/${issueId}`, {
             status: "Closed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corelayer-ai/cli",
-  "version": "0.4.5",
+  "version": "0.5.1",
   "description": "Corelayer CLI",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
   "dependencies": {},
   "devDependencies": {
     "@types/node": "^20.17.57",
-    "tsx": "^4.19.4",
+    "tsx": "^4.22.4",
     "typescript": "^5.8.3"
   }
 }

package/skill/SKILL.md

@@ -5,7 +5,9 @@ description: >
   error analysis, root cause analysis, issue triage, Corelayer, or wants to
   check/manage/close/reopen production issues. Also use when the user says
   "check prod", "what's broken", "any errors", "issue summary", or references
-  the corelayer CLI.
+  the corelayer CLI. Also use before opening or pushing a pull request, or when
+  the user asks what could break, what to watch out for, or for a preflight /
+  pre-merge check on a change.
 user-invocable: true
 ---
 
@@ -54,10 +56,22 @@ corelayer issues diff --group <groupId> --duration 30m --json
 
 Returns issues that are new or changed since the given timestamp. Useful after PR merges/deploys to identify regressions or newly surfaced issues.
 
+### Preflight a change before you push
+
+```bash
+corelayer preflight            # derives PR context from the current git branch
+corelayer preflight --diff     # include the code diff in the check
+corelayer preflight --json
+```
+
+Returns failure modes and things to double-check that the org has hit before for a change
+like this; empty means memory has nothing to flag. See [references/preflight.md](references/preflight.md)
+for flags, how to read the output, and the `corelayer.preflight` MCP tool.
+
 ### Triage issues
 
 ```bash
-corelayer issues close <issueId> --feedback "Fixed in PR #123"
+corelayer issues close <issueId|slug> --feedback "Fixed in PR #123"
 corelayer issues bulk-close --group <groupId> --last-seen-before-or-on 14days --feedback "Not seen in two weeks"
 corelayer issues reopen <issueId>
 corelayer issues delete <issueId> --yes
@@ -115,7 +129,7 @@ Returns issues that are new or updated since the given point in time. Useful for
 
 Use `--json` for machine-readable output suitable for agent automation.
 
-### `corelayer issues close <issueId> [--feedback "..."]`
+### `corelayer issues close <issueId|slug> [--feedback "..."]`
 
 Close an issue. Optionally provide feedback (e.g., link to the fix).
 
@@ -131,6 +145,10 @@ Reopen a previously closed issue.
 
 Soft-delete an issue. Prompts for confirmation unless `--yes` is passed.
 
+### `corelayer preflight [--title <t>] [--description <d>] [--repo <name>] [--base <ref>] [--diff]`
+
+Check a pending change against the org's accumulated memory before opening a PR. With no flags it derives repo/title/description from the current git branch (commits + changed files since the base branch); any flag overrides its piece, and `--diff` includes the patch. Returns grounded, second-person reminders for this change, or nothing when no relevant lesson exists. Full guidance in [references/preflight.md](references/preflight.md).
+
 ### `corelayer groups list`
 
 List all groups in the organization.
@@ -165,6 +183,16 @@ corelayer issues list --severity critical
 corelayer issues get <issueId|slug> --json
 ```
 
+### Before you open a pull request
+
+```bash
+corelayer preflight
+```
+
+Run it once the change is ready, before pushing. Surface any returned checks to the user as
+reminders to double-check (they're advisory, not blockers); if it returns nothing, say memory
+had nothing to flag. See [references/preflight.md](references/preflight.md).
+
 ### Scripting and automation
 
 Use `--json` and `--quiet` flags for machine-readable output:

package/skill/references/preflight.md

@@ -0,0 +1,71 @@
+# Preflight — check a change against org memory before you push
+
+Preflight asks Corelayer's organizational brain: *"for a change like this, what has
+bitten this org before?"* It returns specific, second-person reminders grounded in past
+incidents, facts, decisions, and standing preferences for the services the change touches —
+e.g. an env-var flag that's broken prod deploys before, a packaging step a service has missed,
+a config that needs to be set in every environment. It returns nothing when no relevant lesson
+exists, so an empty result is a meaningful "all clear from memory."
+
+Run it after the work is done and before opening the PR, as a final review pass.
+
+## CLI
+
+Run inside the git repo with no arguments — it derives the PR context from the branch:
+
+```bash
+corelayer preflight
+```
+
+- **repo** ← parsed from the git remote (`origin`)
+- **title** ← the latest commit subject (falls back to the branch name)
+- **description** ← commit messages since the base branch + the list of changed files
+- **base** ← `origin/HEAD` (else `main`/`master`)
+
+Override any piece, or include the actual diff for a richer signal:
+
+```bash
+corelayer preflight --diff
+corelayer preflight --base develop
+corelayer preflight --title "Add Redis cache" --description "Caches payment lookups in the worker" --repo payments-api
+corelayer preflight --json          # machine-readable, for automation
+```
+
+If there are no commits ahead of the base branch (nothing to describe), pass `--description`
+explicitly.
+
+## Reading the output
+
+Each check is one reminder plus its grounding:
+
+```
+1. Double-check the prod env-var flags — deploys here have failed before when they were missing.
+   CRITICAL · "Missing/Incorrect Environment Variables in Deployments" · payments-api · seen 30×
+```
+
+- **severity** — `critical | high | medium | low` of the underlying lesson.
+- **"title"** — the lesson the reminder is grounded in (cite-and-verify; the wording is generated, the lesson is real).
+- **service / scope** — the service the lesson is anchored to, or `system` / `cross-cutting` for org-wide lessons.
+- **seen N×** — how many times the org has hit this; higher = more established.
+
+`--json` also returns `consideredCount` (lessons in the org's catalog) and `pulledCount`
+(lessons the judge read in full for this change).
+
+## How to act on it
+
+- Treat the checks as **reminders, not blockers** — preflight is advisory and fails open
+  (it never blocks a push). Surface them to the user and let them decide.
+- An **empty result is normal and useful** — it means nothing in memory maps to this change.
+  Don't manufacture concerns; say memory had nothing to flag.
+- Higher `seen N×` and `critical`/`high` severity deserve the most attention.
+
+## MCP equivalent
+
+If the Corelayer MCP server is connected, the same capability is the `corelayer.preflight`
+tool (read-only), taking `{ description, title?, repo? }`. Use it when you already have the
+PR text in context and don't need the CLI's git gathering.
+
+## Notes
+
+- Scoped to your organization via the API key — it only sees your org's memory.
+- Read-only; requires authentication (`corelayer login` or `CORELAYER_API_KEY`).