@nexrall/code-core 1.4.76 → 1.4.78

package/dist/ui/deployPanel.js

@@ -0,0 +1,442 @@
+"use strict";
+// The pure half of /deploy + the confirm-word rules (spec §74). Moved to core
+// from the CLI's ui/deployPanel.ts (2026-10-04) so the VS Code panel gates and
+// runs deploys under the same rules; the CLI module keeps the ANSI formatters
+// and re-exports everything else.
+// Spec §74 — deployment UX: what `/deploy` shows, and what it refuses to do.
+//
+// WHY: a deploy is the one command where "which target, which environment, and did anyone
+// check the tests?" all matter before anything runs — and the project already knows the
+// answers (the script in package.json, the vercel.json, the checks this session ran). So
+// `/deploy` reads them out instead of asking the user to remember them.
+//
+// Two rules run through the whole file:
+//   • We never GUESS an environment. When the evidence is silent the target is `unknown`,
+//     and `unknown` is gated exactly like production — being wrong the other way is a live
+//     deploy nobody approved.
+//   • An override can raise the gate but never lower it: `/deploy --env staging` on a
+//     production target is still a production deploy, and the panel says so.
+//
+// Detection only. The command that comes out goes through runUserCmd, i.e. the same
+// permission rules, --readonly gate, output caps and transcript record as `!cmd`.
+//
+// Pure-ish (fs reads for detection only, no console, no Ink) — see test/deployPanel.test.ts.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPLOY_USAGE = exports.ENV_LABELS = exports.ENV_RANK = void 0;
+exports.strictestEnv = strictestEnv;
+exports.envFromFlags = envFromFlags;
+exports.inferEnv = inferEnv;
+exports.detectDeployTargets = detectDeployTargets;
+exports.parseDeployArgs = parseDeployArgs;
+exports.deployGate = deployGate;
+exports.confirmPrompt = confirmPrompt;
+exports.confirmMatches = confirmMatches;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const projectCommands_1 = require("../project/projectCommands");
+/** How strict a gate is. `unknown` sits WITH production, not below it. */
+exports.ENV_RANK = { local: 0, staging: 1, unknown: 2, production: 3 };
+exports.ENV_LABELS = {
+    local: 'local',
+    staging: 'staging',
+    production: 'production',
+    unknown: 'unknown',
+};
+/** The strictest of two environments — the rule that stops an override lowering a gate. */
+function strictestEnv(a, b) {
+    return exports.ENV_RANK[b] > exports.ENV_RANK[a] ? b : a;
+}
+// ─── environment inference ───────────────────────────────────────────────────
+const PROD_WORDS = new Set(['prod', 'production', 'live', 'release']);
+const STAGING_WORDS = new Set(['staging', 'stage', 'stg', 'preview', 'uat', 'qa', 'canary', 'beta']);
+const LOCAL_WORDS = new Set(['local', 'dev', 'development', 'sandbox', 'emulator']);
+const words = (s) => s
+    .toLowerCase()
+    .split(/[\s:._/\\-]+/)
+    .map((w) => w.replace(/^[^a-z0-9]+/, ''))
+    .filter(Boolean);
+/**
+ * Every environment word in `text`, strictest first. Used on the script NAME (`deploy:prod`)
+ * and on explicit flags only — never on the command body, where `/dev/null` would read as
+ * "local" and `--release` on some tool would read as production.
+ */
+function envWords(text) {
+    const found = [];
+    for (const w of words(text)) {
+        if (PROD_WORDS.has(w))
+            found.push('production');
+        else if (STAGING_WORDS.has(w))
+            found.push('staging');
+        else if (LOCAL_WORDS.has(w))
+            found.push('local');
+    }
+    return found.sort((a, b) => exports.ENV_RANK[b] - exports.ENV_RANK[a]);
+}
+/** `--env production`, `--environment=staging`, `--stage prod` — the tool's own flag. */
+const ENV_FLAG_RE = /--(?:env|environment|stage|target)(?:[=\s]+)([A-Za-z][\w-]*)/g;
+/** Bare `--prod` / `--production`: vercel, netlify and friends spell it with no value. */
+const PROD_FLAG_RE = /(?:^|\s)--(?:prod|production|live)(?![\w-])/;
+function envFromFlags(command) {
+    const hits = [];
+    for (const m of command.matchAll(ENV_FLAG_RE)) {
+        const hit = envWords(m[1])[0];
+        if (hit)
+            hits.push(hit);
+    }
+    if (PROD_FLAG_RE.test(command))
+        hits.push('production');
+    return hits.sort((a, b) => exports.ENV_RANK[b] - exports.ENV_RANK[a])[0];
+}
+/** The environment a target runs against, and the sentence that justifies it. */
+function inferEnv(name, command) {
+    const fromName = envWords(name)[0];
+    const fromFlag = envFromFlags(command);
+    const picked = [fromName, fromFlag].filter(Boolean);
+    const env = picked.sort((a, b) => exports.ENV_RANK[b] - exports.ENV_RANK[a])[0];
+    if (!env) {
+        return { env: 'unknown', why: 'nothing in the name or the command says which environment — gated like production' };
+    }
+    const where = fromName && fromFlag && fromName !== fromFlag
+        ? `the name says ${exports.ENV_LABELS[fromName]}, the flags say ${exports.ENV_LABELS[fromFlag]} — the stricter one wins`
+        : fromName
+            ? `the name says ${exports.ENV_LABELS[fromName]}`
+            : `the command passes ${exports.ENV_LABELS[fromFlag]}`;
+    return { env, why: where };
+}
+// ─── detection ───────────────────────────────────────────────────────────────
+/** Script names (or script body words) that mean "this ships something". */
+const DEPLOY_WORDS = new Set(['deploy', 'deployment', 'deploys', 'release', 'publish', 'ship', 'upload', 'promote']);
+/** Tools whose presence in a script body is enough to call it a deploy. */
+const DEPLOY_TOOLS = new Set([
+    'vercel',
+    'netlify',
+    'flyctl',
+    'firebase',
+    'wrangler',
+    'sst',
+    'serverless',
+    'sls',
+    'surge',
+    'gh-pages',
+    'pages',
+    'gcloud',
+    'kubectl',
+    'helm',
+    'terraform',
+    'kamal',
+    'cap',
+    'eb',
+    'ansible-playbook',
+    'sam',
+    'cdk',
+    'pulumi',
+    'ebctl',
+    'now',
+]);
+const MAX_READ_BYTES = 256 * 1024;
+function readText(file) {
+    try {
+        const st = node_fs_1.default.statSync(file);
+        if (!st.isFile() || st.size > MAX_READ_BYTES)
+            return null;
+        return node_fs_1.default.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function isFile(file) {
+    try {
+        return node_fs_1.default.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isDir(file) {
+    try {
+        return node_fs_1.default.statSync(file).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** package.json scripts that look like deploys, by name or by the tool they call. */
+function scriptsFrom(workDir) {
+    const raw = readText(node_path_1.default.join(workDir, 'package.json'));
+    if (raw === null)
+        return [];
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const scripts = json?.scripts;
+    if (!scripts || typeof scripts !== 'object')
+        return [];
+    const pm = (0, projectCommands_1.packageManager)(workDir);
+    const out = [];
+    for (const [name, body] of Object.entries(scripts)) {
+        if (typeof body !== 'string')
+            continue;
+        const nameHit = words(name).some((w) => DEPLOY_WORDS.has(w));
+        const bodyHit = words(body).some((w) => DEPLOY_TOOLS.has(w));
+        if (!nameHit && !bodyHit)
+            continue;
+        const { env, why } = inferEnv(name, body);
+        out.push({ name, command: `${pm} run ${name}`, source: 'package.json', env, why });
+    }
+    return out;
+}
+/** Column-0 `deploy…:` rules in a Makefile / justfile. */
+function recipeTargets(file, kind) {
+    const raw = readText(file);
+    if (raw === null)
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const line of raw.split('\n')) {
+        const m = kind === 'make'
+            ? /^([A-Za-z0-9][\w.-]*)\s*:(?!=)/.exec(line)
+            : /^([A-Za-z_][\w-]*)(\s[^:]*)?\s*:(?!=)/.exec(line);
+        if (!m)
+            continue;
+        const name = m[1];
+        if (seen.has(name) || !words(name).some((w) => DEPLOY_WORDS.has(w)))
+            continue;
+        seen.add(name);
+        const command = `${kind} ${name}`;
+        const { env, why } = inferEnv(name, command);
+        out.push({ name, command, source: node_path_1.default.basename(file), env, why });
+    }
+    return out;
+}
+/**
+ * Config-file evidence: the tool is set up here, and its own default is what says which
+ * environment a bare invocation hits. Tools that default to a LIVE target are listed as
+ * production; the two that default to a preview build are listed as such, next to the
+ * `--prod` form a user would otherwise have to remember.
+ */
+const CONFIG_TARGETS = [
+    {
+        files: ['vercel.json', '.vercel/project.json'],
+        name: 'vercel',
+        command: 'vercel deploy',
+        env: 'staging',
+        why: 'vercel deploy without --prod builds a preview deployment',
+    },
+    {
+        files: ['vercel.json', '.vercel/project.json'],
+        name: 'vercel-prod',
+        command: 'vercel deploy --prod',
+        env: 'production',
+        why: '--prod ships to the live domain',
+    },
+    {
+        files: ['netlify.toml', '.netlify/state.json'],
+        name: 'netlify',
+        command: 'netlify deploy',
+        env: 'staging',
+        why: 'netlify deploy without --prod publishes a draft',
+    },
+    {
+        files: ['netlify.toml', '.netlify/state.json'],
+        name: 'netlify-prod',
+        command: 'netlify deploy --prod',
+        env: 'production',
+        why: '--prod publishes the live site',
+    },
+    {
+        files: ['fly.toml'],
+        name: 'fly',
+        command: 'fly deploy',
+        env: 'production',
+        why: 'fly deploy updates the app\u2019s live machines',
+    },
+    {
+        files: ['firebase.json'],
+        name: 'firebase',
+        command: 'firebase deploy',
+        env: 'production',
+        why: 'firebase deploy targets the live project',
+    },
+    {
+        files: ['wrangler.toml', 'wrangler.jsonc', 'wrangler.json'],
+        name: 'workers',
+        command: 'wrangler deploy',
+        env: 'production',
+        why: 'wrangler deploy publishes the live Worker',
+    },
+    {
+        files: ['serverless.yml', 'serverless.yaml', 'serverless.ts'],
+        name: 'serverless',
+        command: 'serverless deploy',
+        env: 'unknown',
+        why: 'the stage comes from the config or --stage — check before running',
+    },
+    {
+        files: ['sst.config.ts', 'sst.config.js'],
+        name: 'sst',
+        command: 'sst deploy --stage production',
+        env: 'production',
+        why: 'the command asks for the production stage explicitly',
+    },
+    {
+        files: ['app.yaml'],
+        name: 'appengine',
+        command: 'gcloud app deploy',
+        env: 'production',
+        why: 'gcloud app deploy ships the default service',
+    },
+];
+function configTargets(workDir) {
+    const out = [];
+    for (const t of CONFIG_TARGETS) {
+        if (!t.files.some((f) => isFile(node_path_1.default.join(workDir, f))))
+            continue;
+        out.push({
+            name: t.name,
+            command: t.command,
+            source: t.files.find((f) => isFile(node_path_1.default.join(workDir, f))),
+            env: t.env,
+            why: t.why,
+        });
+    }
+    return out;
+}
+/** `kubectl apply` / `terraform apply`: real deploys whose target lives OUTSIDE the repo. */
+function infraTargets(workDir) {
+    const out = [];
+    for (const dir of ['k8s', 'kubernetes', 'manifests', 'deploy']) {
+        const abs = node_path_1.default.join(workDir, dir);
+        if (!isDir(abs))
+            continue;
+        let hasYaml;
+        try {
+            hasYaml = node_fs_1.default.readdirSync(abs).some((f) => /\.ya?ml$/.test(f));
+        }
+        catch {
+            hasYaml = false;
+        }
+        if (!hasYaml)
+            continue;
+        out.push({
+            name: dir,
+            command: `kubectl apply -f ${dir}/`,
+            source: `${dir}/`,
+            env: 'unknown',
+            why: 'applies to whatever cluster kubectl points at — check `kubectl config current-context` first',
+        });
+    }
+    try {
+        const hasTf = node_fs_1.default.readdirSync(workDir).some((f) => f.endsWith('.tf'));
+        if (hasTf) {
+            out.push({
+                name: 'terraform',
+                command: 'terraform apply',
+                source: '*.tf',
+                env: 'unknown',
+                why: 'applies to the selected workspace and state — `terraform plan` shows what changes',
+            });
+        }
+    }
+    catch {
+        /* unreadable dir — nothing to offer */
+    }
+    return out;
+}
+/**
+ * Every deploy target this folder can offer, in a stable order: package.json scripts, then
+ * recipes, then tool configs, then infrastructure. Duplicate commands are collapsed (a
+ * `deploy` script that merely calls `vercel deploy` is also matched by the vercel config).
+ */
+function detectDeployTargets(workDir) {
+    const all = [
+        ...scriptsFrom(workDir),
+        ...recipeTargets(node_path_1.default.join(workDir, 'Makefile'), 'make'),
+        ...recipeTargets(node_path_1.default.join(workDir, 'justfile'), 'just'),
+        ...configTargets(workDir),
+        ...infraTargets(workDir),
+    ];
+    const byCommand = new Map();
+    for (const t of all)
+        if (!byCommand.has(t.command))
+            byCommand.set(t.command, t);
+    return [...byCommand.values()];
+}
+exports.DEPLOY_USAGE = '/deploy [target] [--env local|staging|production] [--yes] [--dry-run]   ·   /deploy list';
+const isEnv = (s) => s === 'local' || s === 'staging' || s === 'production' || s === 'unknown';
+function parseDeployArgs(arg) {
+    const parts = arg.trim().split(/\s+/).filter(Boolean);
+    const out = { yes: false, dryRun: false, list: false };
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (p === 'list' || p === '--list' || p === '-l') {
+            out.list = true;
+            continue;
+        }
+        if (p === '--yes' || p === '-y') {
+            out.yes = true;
+            continue;
+        }
+        if (p === '--dry-run' || p === '-n') {
+            out.dryRun = true;
+            continue;
+        }
+        if (p === '--env' || p === '--environment') {
+            const v = parts[i + 1];
+            if (!v)
+                return { error: '--env needs a value (local, staging, production).' };
+            if (!isEnv(v))
+                return { error: `Unknown environment "${v}" — use local, staging or production.` };
+            out.env = v;
+            i++;
+            continue;
+        }
+        if (p.startsWith('--env=')) {
+            const v = p.slice(6);
+            if (!isEnv(v))
+                return { error: `Unknown environment "${v}" — use local, staging or production.` };
+            out.env = v;
+            continue;
+        }
+        if (p.startsWith('-'))
+            return { error: `Unknown flag "${p}".  ${exports.DEPLOY_USAGE}` };
+        if (out.name === undefined) {
+            out.name = p;
+            continue;
+        }
+        return { error: `Only one target at a time (got "${out.name}" and "${p}").  ${exports.DEPLOY_USAGE}` };
+    }
+    return out;
+}
+function deployGate(env, opts = {}) {
+    if (opts.readonly) {
+        return {
+            ok: false,
+            reason: 'This is a read-only session (--readonly) — a deploy changes things, so /deploy is refused. Restart without --readonly to deploy.',
+        };
+    }
+    if (env === 'production')
+        return { ok: true, confirmWord: 'production' };
+    if (env === 'unknown')
+        return { ok: true, confirmWord: 'deploy' };
+    return { ok: true, ask: !opts.yes };
+}
+/** The environment word the user must type, in one sentence they can act on. */
+function confirmPrompt(env) {
+    if (env === 'production')
+        return 'Type "production" to ship to production';
+    return 'Type "deploy" to confirm \u2014 nothing here says which environment this hits';
+}
+/** True when `typed` is the confirmation word `env` asked for. */
+function confirmMatches(env, typed) {
+    const want = env === 'production' ? 'production' : 'deploy';
+    return typed.trim().toLowerCase() === want;
+}
+//# sourceMappingURL=deployPanel.js.map

package/dist/ui/mergeAssistant.d.ts

@@ -0,0 +1,120 @@
+export type NodeStatus = 'running' | 'completed' | 'failed' | 'stopped';
+export declare const MAX_NODE_FILES = 40;
+export declare const STATUS_GLYPH: Record<NodeStatus | 'idle', string>;
+/** The ref a worktree branch would be merged INTO: the branch name, or HEAD when detached. */
+export declare function headRefFor(dir: string): string;
+/**
+ * git with stderr captured, because `merge-tree` says "clean" and "I could not run" with
+ * different exit codes and treating the second as the first is exactly the lie this feature
+ * exists to avoid. execFileSync throws on a non-zero status, so the fields come off the error.
+ */
+export declare const gitRunnerForMerge: GitRunner;
+/** Cap on merge-tree invocations per /merge — one per branch plus every pair, all cheap. */
+export declare const MAX_MERGE_TREE_CHECKS = 12;
+/** Agent rows before the panel stops listing and counts the rest. */
+export declare const MAX_WRITER_ROWS = 8;
+/** The subset of `AgentNode` this module needs. Structural, so chat.ts passes board nodes. */
+export interface WriterNode {
+    id: string;
+    name: string;
+    label: string;
+    status: NodeStatus;
+    files: string[];
+    report?: string;
+}
+export interface NoteWorktree {
+    path: string;
+    branch?: string;
+}
+export interface WriterInfo {
+    id: string;
+    name: string;
+    label: string;
+    status: NodeStatus;
+    /** Paths this agent wrote, first-seen order, as the board recorded them. */
+    files: string[];
+    /** True once the per-node cap is hit: `files.length` is then a floor, not a total. */
+    capped: boolean;
+    /** Present when the agent kept an isolated worktree (its writes are NOT in this checkout). */
+    worktree?: NoteWorktree;
+}
+export declare function parseWorktreeNote(text: string | undefined): NoteWorktree | null;
+/** Agents that wrote at least one file, or that kept a worktree worth reconciling. */
+export declare function writersFrom(nodes: readonly WriterNode[]): WriterInfo[];
+export interface SharedFile {
+    path: string;
+    /** Writer ids, first-seen order. */
+    writers: string[];
+}
+/**
+ * Files written by more than one agent in the same checkout.
+ *
+ * An isolated agent is skipped: its writes landed in its own worktree, so the same relative
+ * path is a different file on disk and pairing them here would invent a clash.
+ */
+export declare function sharedFiles(writers: readonly WriterInfo[]): SharedFile[];
+/** Sub-agent writes that the main agent also made this session (same checkout only). */
+export declare function alsoByMain(writers: readonly WriterInfo[], mainFiles: readonly string[]): string[];
+export interface MergePair {
+    a: string;
+    b: string;
+}
+export interface MergeCheck extends MergePair {
+    /** Paths git reported as conflicting; empty means the merge is clean. */
+    conflicts: string[];
+    /** Set when the check could not run (missing branch, old git, …). */
+    error?: string;
+    /**
+     * Both refs resolve to ONE commit, so there is nothing between them: `merge-tree` can only
+     * answer "clean" for the trivial reason that the two sides are the same tree. This is the
+     * normal state of a worktree agent that has not committed yet, and "clean" must not be read
+     * as "these changes merge safely".
+     */
+    trivial?: boolean;
+}
+export type GitRunner = (cwd: string, args: string[]) => {
+    status: number;
+    stdout: string;
+    stderr: string;
+};
+/** A ref we are willing to hand to git — no leading dash, no whitespace. */
+export declare function looksLikeRef(name: string): boolean;
+/**
+ * Which merges to test, most useful first: every branch into the current checkout, then the
+ * branches against each other (merging A then B is exactly where two agents' overlapping work
+ * surfaces). Capped, and the number left out is reported rather than hidden.
+ */
+export declare function mergePairs(writers: readonly WriterInfo[], head: string, max?: number): {
+    pairs: MergePair[];
+    skipped: number;
+};
+/** Conflicted paths from `merge-tree --write-tree`: the stage rows are the authoritative list. */
+export declare function parseMergeTree(stdout: string): string[];
+/**
+ * Run one dry-run merge per pair. Exit 0 = clean, 1 = conflicts (paths on stdout), anything
+ * else = the check did not happen, which is reported as such instead of as "no conflicts".
+ *
+ * Pairs whose two refs resolve to the same commit are marked `trivial` instead of being asked:
+ * the answer is fixed before git runs, and it is exactly the case a freshly spawned worktree
+ * agent is in (its writes are on disk in the worktree, not in any commit).
+ */
+export declare function checkBranchMerges(cwd: string, pairs: readonly MergePair[], run: GitRunner): {
+    checks: MergeCheck[];
+    unsupported: boolean;
+};
+export interface MergeInput {
+    /** Sub-agents that wrote files (or kept a worktree). */
+    writers: readonly WriterInfo[];
+    /** Sub-agents spawned this session INCLUDING those that wrote nothing. */
+    totalAgents: number;
+    mainFiles?: readonly string[];
+    /** Result of `checkBranchMerges`, if the caller ran it. */
+    checks?: readonly MergeCheck[];
+    skippedChecks?: number;
+    /** git here has no `merge-tree --write-tree`: say so instead of implying "clean". */
+    unsupportedGit?: boolean;
+    /** Any sub-agent still running — conflicts are only as final as the work is. */
+    running?: boolean;
+}
+export declare function formatMergePanel(input: MergeInput, cols: number): string[];
+//# sourceMappingURL=mergeAssistant.d.ts.map

package/dist/ui/mergeAssistant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeAssistant.d.ts","sourceRoot":"","sources":["../../src/ui/mergeAssistant.ts"],"names":[],"mappings":"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"}