@redential/cli 0.1.0

package/dist/errors.js

@@ -0,0 +1,20 @@
+/** Domain error for scan failures (empty repo, unconfirmed authorization, a
+ * secret found in the payload, closed input stream, ...). Kept in its own
+ * module so leaf modules (secret-scan.ts, prompt.ts) can throw it without
+ * creating an import cycle with scan.ts. */
+export class ScanError extends Error {
+}
+/** Session/authentication failures: device flow denied/expired, no stored
+ * credentials, or a stored token that belongs to a different SITE_URL. */
+export class AuthError extends Error {
+}
+/** submit-specific failures that aren't auth or network: refused because
+ * the remote looks publicly reachable, malformed server response, etc. */
+export class SubmitError extends Error {
+}
+/** A request to SITE_URL (or a remote host, for the visibility check)
+ * couldn't complete or came back with a non-2xx status. Message is built
+ * from the request's host and status only — never headers or body — so it
+ * can never echo a bearer token or bundle content. */
+export class NetworkError extends Error {
+}

package/dist/git.js

@@ -0,0 +1,141 @@
+import { execFileSync } from "node:child_process";
+function git(repoPath, args) {
+    return execFileSync("git", args, {
+        cwd: repoPath,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+const RECORD_SEP = "\x01";
+const FIELD_SEP = "\x02";
+/**
+ * All commits reachable from HEAD, oldest first. Returns [] for a repo with
+ * no commits yet, rather than throwing.
+ */
+export function getAllCommits(repoPath) {
+    let out;
+    try {
+        out = git(repoPath, [
+            "log",
+            "--reverse",
+            "--numstat",
+            `--format=${RECORD_SEP}%H${FIELD_SEP}%ae${FIELD_SEP}%aI${FIELD_SEP}%G?${FIELD_SEP}%P`,
+        ]);
+    }
+    catch {
+        return [];
+    }
+    return out
+        .split(RECORD_SEP)
+        .filter((chunk) => chunk.trim().length > 0)
+        .map((chunk) => {
+        const lines = chunk.split("\n");
+        const [sha, email, authorDateIso, signatureStatus, parents] = lines[0].split(FIELD_SEP);
+        const churn = [];
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const parts = line.split("\t");
+            if (parts.length < 3)
+                continue;
+            const [addedRaw, deletedRaw, ...pathParts] = parts;
+            churn.push({
+                path: pathParts.join("\t"),
+                added: addedRaw === "-" ? 0 : parseInt(addedRaw, 10),
+                deleted: deletedRaw === "-" ? 0 : parseInt(deletedRaw, 10),
+            });
+        }
+        return {
+            sha,
+            email,
+            authorDate: new Date(authorDateIso),
+            // Only a fully verified good signature ("G") counts as signed. "U"
+            // (good but untrusted/unmatched key), "B" (bad), "X"/"Y"/"R"
+            // (expired/expired-key/revoked-key) and "E" (can't check) all mean
+            // the signature doesn't actually establish anything — see
+            // docs/schema.md's `signed` section for why.
+            signed: signatureStatus === "G",
+            churn,
+            isMerge: parents.trim().split(/\s+/).filter(Boolean).length > 1,
+        };
+    });
+}
+/** First line of `rev-list --max-parents=0`; multi-root histories are out of scope. */
+export function getRootCommitSha(repoPath) {
+    return git(repoPath, ["rev-list", "--max-parents=0", "HEAD"]).trim().split("\n")[0];
+}
+/** Raw `origin` remote URL, read purely from local git config — null if there's none. */
+export function getRemoteUrl(repoPath) {
+    try {
+        return git(repoPath, ["remote", "get-url", "origin"]).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function getRemoteHostType(repoPath) {
+    const url = getRemoteUrl(repoPath);
+    if (!url)
+        return "none";
+    if (/github\.com/.test(url))
+        return "github";
+    if (/gitlab\.com/.test(url))
+        return "gitlab";
+    if (/bitbucket\.org/.test(url))
+        return "bitbucket";
+    return "other";
+}
+/**
+ * Lines a single (non-merge — caller's responsibility to skip those,
+ * matching `getAllCommits`' own numstat behavior) commit ADDED, grouped by
+ * file — the input to skill-detection pattern matching (src/skill-detect.ts).
+ * Never removed/context lines: we care what was introduced, not what a diff
+ * happened to touch. `--no-color`/`--no-ext-diff`/`core.quotepath=off` keep
+ * the user's own git config (color.ui, an external diff tool, quoted
+ * non-ASCII paths) from corrupting this parser — this reads local git
+ * output, but the shape of that output must stay ours to depend on.
+ */
+export function getCommitAddedLines(repoPath, sha) {
+    let out;
+    try {
+        out = git(repoPath, [
+            "-c",
+            "core.quotepath=off",
+            "show",
+            sha,
+            "--unified=0",
+            "--format=",
+            "--no-color",
+            "--no-ext-diff",
+        ]);
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    let currentPath = null;
+    let currentLines = [];
+    const flush = () => {
+        if (currentPath)
+            files.push({ path: currentPath, addedLines: currentLines.join("\n") });
+    };
+    for (const line of out.split("\n")) {
+        if (line.startsWith("+++ b/")) {
+            flush();
+            currentPath = line.slice("+++ b/".length);
+            currentLines = [];
+        }
+        else if (line.startsWith("+++ /dev/null")) {
+            // Deleted file — nothing was added to it.
+            flush();
+            currentPath = null;
+            currentLines = [];
+        }
+        else if (line.startsWith("+") && !line.startsWith("+++")) {
+            currentLines.push(line.slice(1));
+        }
+    }
+    flush();
+    return files;
+}

package/dist/hash.js

@@ -0,0 +1,4 @@
+import { createHash } from "node:crypto";
+export function saltedHash(salt, value) {
+    return createHash("sha256").update(salt).update(value).digest("hex");
+}

package/dist/http-client.js

@@ -0,0 +1,129 @@
+import { NetworkError } from "./errors.js";
+/**
+ * The only module allowed to call `fetch` for JSON requests (login.ts and
+ * submit.ts are the other two — see test/privacy/zero-network.test.ts's
+ * allowlist). Error messages are built from the URL's host and the HTTP
+ * status only, never from response headers or body, so a failure can never
+ * echo a bearer token or bundle content back into a printed error.
+ */
+export async function postJson(url, body, headers = {}) {
+    const host = new URL(url).host;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json", ...headers },
+            body: JSON.stringify(body),
+        });
+    }
+    catch {
+        throw new NetworkError(`Could not reach ${host}.`);
+    }
+    if (!res.ok) {
+        throw new NetworkError(`Request to ${host} failed with status ${res.status}.`);
+    }
+    try {
+        return (await res.json());
+    }
+    catch {
+        throw new NetworkError(`Response from ${host} was not valid JSON.`);
+    }
+}
+/**
+ * Same as postJson, but sends `rawBody` verbatim instead of re-serializing
+ * an object — used by submit so the bytes on the wire are byte-identical to
+ * the bytes printed for user review (principle 4, "User-reviewed").
+ */
+export async function postRawJson(url, rawBody, headers = {}) {
+    const host = new URL(url).host;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json", ...headers },
+            body: rawBody,
+        });
+    }
+    catch {
+        throw new NetworkError(`Could not reach ${host}.`);
+    }
+    if (!res.ok) {
+        throw new NetworkError(`Request to ${host} failed with status ${res.status}.`);
+    }
+    try {
+        return (await res.json());
+    }
+    catch {
+        throw new NetworkError(`Response from ${host} was not valid JSON.`);
+    }
+}
+/**
+ * Like postJson, but for the device-token poll endpoint only: RFC 8628
+ * device flow returns EVERY `{error: "..."}` state — including the
+ * non-terminal authorization_pending/slow_down the CLI is expected to keep
+ * polling through — as HTTP 400, reserving 200 for `{access_token}` success
+ * (see docs/login-submit.md). Treats 200 and 400 alike as "parse the body";
+ * any other status is still a real failure. Same error-message discipline
+ * as postJson: built from the host and status only, never from response
+ * headers or body, so a failure here can never echo a bearer token.
+ */
+export async function pollJson(url, body) {
+    const host = new URL(url).host;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    catch {
+        throw new NetworkError(`Could not reach ${host}.`);
+    }
+    if (!res.ok && res.status !== 400) {
+        throw new NetworkError(`Request to ${host} failed with status ${res.status}.`);
+    }
+    try {
+        return (await res.json());
+    }
+    catch {
+        throw new NetworkError(`Response from ${host} was not valid JSON.`);
+    }
+}
+/**
+ * Anonymous HEAD request used only by submit's remote-visibility gate — the
+ * request target is the repo's own remote host, never SITE_URL. Returns
+ * null (not a thrown error) on any network failure/timeout: an inconclusive
+ * check must never be treated as a confirmed answer either way.
+ */
+export async function headRequest(url, timeoutMs) {
+    try {
+        const res = await fetch(url, {
+            method: "HEAD",
+            redirect: "follow",
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        return { status: res.status };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Anonymous GET with a timeout, used only by version-check.ts's best-effort
+ * npm-registry freshness check. Returns null (never throws) on any failure —
+ * network error, timeout, non-2xx status, or a body that isn't valid JSON —
+ * so a broken or offline registry can never delay or fail the login/submit
+ * command this is attached to.
+ */
+export async function getJson(url, timeoutMs) {
+    try {
+        const res = await fetch(url, { method: "GET", signal: AbortSignal.timeout(timeoutMs) });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}

package/dist/import-detect.js

@@ -0,0 +1,281 @@
+// Tier 1 of skill detection (see docs/signatures.md): generic import
+// parsing, language-by-language, over a commit's ADDED diff lines only.
+// Returns normalized package names for src/skill-detect.ts to look up in
+// signatures/package-map.json. Never sends anything anywhere — pure string
+// parsing, no I/O.
+//
+// Deliberately regex-based, not a real parser per language (that would mean
+// 5 new dependencies — CLAUDE.md's dependency policy forbids that without
+// written justification). The tradeoff: perfect syntactic correctness isn't
+// the goal, bounded false positives are (principle 3) — every extractor is
+// anchored to reject the three near-miss classes that matter in practice:
+// comments, package names embedded in string literals, and doc files.
+const DOC_EXTENSIONS = new Set([".md", ".mdx", ".txt", ".rst", ".markdown"]);
+function languageForPath(filePath) {
+    const lower = filePath.toLowerCase();
+    const ext = lower.slice(lower.lastIndexOf("."));
+    if (DOC_EXTENSIONS.has(ext))
+        return null; // never scan docs for imports
+    if ([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"].includes(ext))
+        return "js";
+    if (ext === ".py")
+        return "python";
+    if (ext === ".go")
+        return "go";
+    if (ext === ".rb" || lower.endsWith("/gemfile") || lower === "gemfile")
+        return "ruby";
+    if (ext === ".php" || lower.endsWith("/composer.json") || lower === "composer.json")
+        return "php";
+    return null;
+}
+// A line is "commented out" if, once trimmed, it starts with a comment
+// marker — catches a same-line "// import x from 'y'" near-miss. Multi-line
+// regions (block comments, template literals, triple-quoted strings) are
+// NOT line-prefix detectable at all — handled separately by
+// `stripNonCodeRegions`, called once before any language extractor runs.
+const COMMENT_PREFIXES = ["//", "#", "/*", "*", "<!--", "--"];
+function isCommentLine(line) {
+    const trimmed = line.trimStart();
+    return COMMENT_PREFIXES.some((p) => trimmed.startsWith(p));
+}
+// Replaces the CONTENTS of three multi-line region types with spaces
+// (never removing lines — every other position in the text must keep its
+// original line/column so isRealStatement's line lookups stay correct):
+// block comments, JS/TS template literals, and Python triple-quoted
+// strings. Without this, import-shaped text inside any of them is real
+// text sitting at the start of ITS OWN line once the region spans multiple
+// lines — isCommentLine/isInsideStringLiteral only ever look at a single
+// line, so they can't catch a false positive that only exists because of
+// what an EARLIER line opened.
+function stripNonCodeRegions(text) {
+    const blank = (m) => m.replace(/[^\n]/g, " ");
+    let out = text.replace(/\/\*[\s\S]*?\*\//g, blank);
+    out = out.replace(/`(?:[^`\\]|\\.)*`/g, blank);
+    out = out.replace(/("""[\s\S]*?"""|'''[\s\S]*?''')/g, blank);
+    return out;
+}
+// Rejects a match whose containing line has an odd number of unescaped
+// quote characters before the match start — i.e. the match sits inside an
+// outer string literal ("const s = 'import x from \"y\"';"), not as real
+// syntax. A cheap, deliberately approximate stand-in for real string
+// tracking: good enough to kill the near-miss this is meant to kill,
+// without a full tokenizer.
+function isInsideStringLiteral(line, matchStart) {
+    const before = line.slice(0, matchStart);
+    let quoteChar = null;
+    let count = 0;
+    for (let i = 0; i < before.length; i++) {
+        const c = before[i];
+        if (c === "\\") {
+            i++; // skip escaped char
+            continue;
+        }
+        if (c === "'" || c === '"' || c === "`") {
+            if (quoteChar === null) {
+                quoteChar = c;
+                count = 1;
+            }
+            else if (c === quoteChar) {
+                quoteChar = null;
+                count = 0;
+            }
+        }
+    }
+    return count > 0;
+}
+function lineAndOffsetAt(text, index) {
+    const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+    let lineEnd = text.indexOf("\n", index);
+    if (lineEnd === -1)
+        lineEnd = text.length;
+    return { line: text.slice(lineStart, lineEnd), offsetInLine: index - lineStart };
+}
+// A candidate match is accepted only if: (1) the statement-starting line
+// (where the keyword itself begins, even for multi-line statements) isn't
+// a comment, and (2) the keyword isn't sitting inside an outer string
+// literal on that line.
+function isRealStatement(text, keywordIndex) {
+    const { line, offsetInLine } = lineAndOffsetAt(text, keywordIndex);
+    if (isCommentLine(line))
+        return false;
+    if (isInsideStringLiteral(line, offsetInLine))
+        return false;
+    return true;
+}
+function normalizeJs(raw) {
+    if (raw.startsWith("@"))
+        return raw.split("/").slice(0, 2).join("/");
+    return raw.split("/")[0];
+}
+function extractJs(text) {
+    const found = [];
+    // import ... from "pkg" / export ... from "pkg" (also covers `export * from`,
+    // `export { x } from`, and multi-line named-import lists via [\s\S]*?).
+    // `d` (hasIndices) exposes the captured package name's own start offset —
+    // needed because `[\s\S]*?\bfrom` is a lazy bridge that can walk INTO an
+    // unrelated string literal later on the same line (e.g. a SQL string
+    // containing the word "from") even when the line legitimately starts
+    // with a real `import`/`export` keyword. Checking string-nesting at the
+    // keyword's position alone (isRealStatement) doesn't catch that — the
+    // capture's OWN position must be checked too.
+    const fromRe = /^[ \t]*(import|export)\b[\s\S]*?\bfrom\s+["']([^"'\n]+)["']/gmd;
+    for (const m of text.matchAll(fromRe)) {
+        if (!isRealStatement(text, m.index))
+            continue;
+        // Check quote parity up to (but not including) the OPENING quote of the
+        // captured package string itself — not the package text's own start.
+        // Using the package text's start would count that opening quote as
+        // "already inside a string," which is trivially true for every real
+        // match (a quoted string always opens with a quote right before its
+        // content) and would reject every legitimate import.
+        const indices = m.indices;
+        const openQuotePos = indices[2][0] - 1;
+        const { line, offsetInLine } = lineAndOffsetAt(text, openQuotePos);
+        if (isInsideStringLiteral(line, offsetInLine))
+            continue;
+        found.push(normalizeJs(m[2]));
+    }
+    // import "pkg"; (side-effect import, no `from`)
+    const bareImportRe = /^[ \t]*import\s+["']([^"'\n]+)["']\s*;?/gm;
+    for (const m of text.matchAll(bareImportRe)) {
+        if (isRealStatement(text, m.index))
+            found.push(normalizeJs(m[1]));
+    }
+    // require("pkg") / import("pkg") — dynamic import, anywhere a real
+    // statement could reasonably put it (assignment, await, bare call).
+    const requireRe = /\b(?:require|import)\(\s*["']([^"'\n]+)["']\s*\)/g;
+    for (const m of text.matchAll(requireRe)) {
+        const { line, offsetInLine } = lineAndOffsetAt(text, m.index);
+        if (isCommentLine(line))
+            continue;
+        if (isInsideStringLiteral(line, offsetInLine))
+            continue;
+        found.push(normalizeJs(m[1]));
+    }
+    return found;
+}
+function extractPython(text) {
+    const found = [];
+    // import pkg[.sub][ as alias][, pkg2[ as alias2] ...] — each item can
+    // carry its own "as alias" before the next comma, which must be allowed
+    // inside the repeated group or the chain breaks and everything after the
+    // first alias silently falls out of the match.
+    const importRe = /^[ \t]*import\s+([\w.]+(?:\s+as\s+\w+)?(?:\s*,\s*[\w.]+(?:\s+as\s+\w+)?)*)/gm;
+    for (const m of text.matchAll(importRe)) {
+        if (!isRealStatement(text, m.index))
+            continue;
+        for (const part of m[1].split(",")) {
+            const name = part.trim().split(/\s+as\s+/)[0];
+            if (name)
+                found.push(name.split(".")[0]);
+        }
+    }
+    // from pkg[.sub] import x
+    const fromRe = /^[ \t]*from\s+([\w.]+)\s+import\b/gm;
+    for (const m of text.matchAll(fromRe)) {
+        if (isRealStatement(text, m.index))
+            found.push(m[1].split(".")[0]);
+    }
+    return found;
+}
+function extractGo(text) {
+    const found = [];
+    const normalize = (p) => p.replace(/\/v\d+$/, "");
+    // Single-line: import "path" or import alias "path"
+    const singleRe = /^[ \t]*import\s+(?:\w+\s+)?["']([^"'\n]+)["']/gm;
+    for (const m of text.matchAll(singleRe)) {
+        if (isRealStatement(text, m.index))
+            found.push(normalize(m[1]));
+    }
+    // Block: import (\n  "path1"\n  alias "path2"\n)
+    const blockRe = /^[ \t]*import\s*\(([\s\S]*?)\)/gm;
+    for (const m of text.matchAll(blockRe)) {
+        if (!isRealStatement(text, m.index))
+            continue;
+        const pathRe = /["']([^"'\n]+)["']/g;
+        for (const p of m[1].matchAll(pathRe))
+            found.push(normalize(p[1]));
+    }
+    return found;
+}
+function extractRuby(text, filePath) {
+    const found = [];
+    const isGemfile = /gemfile$/i.test(filePath);
+    if (isGemfile) {
+        // gem "name"[, "~> 1.0"] — a Gemfile dependency declaration.
+        const gemRe = /^[ \t]*gem\s+["']([^"'\n]+)["']/gm;
+        for (const m of text.matchAll(gemRe)) {
+            if (isRealStatement(text, m.index))
+                found.push(m[1].split("/")[0]);
+        }
+        return found;
+    }
+    // require "pkg" — require_relative is deliberately excluded (it loads a
+    // local file, not a third-party package; matching it would misattribute
+    // a plain relative require to some unrelated real gem sharing the name).
+    const requireRe = /^[ \t]*require\s+["']([^"'\n]+)["']/gm;
+    for (const m of text.matchAll(requireRe)) {
+        if (isRealStatement(text, m.index))
+            found.push(m[1].split("/")[0]);
+    }
+    return found;
+}
+function extractPhp(text, filePath) {
+    const found = [];
+    if (/composer\.json$/i.test(filePath)) {
+        // Structured JSON — no regex needed, and safest possible source: no
+        // comment/string-literal ambiguity exists in JSON added-lines at all.
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed.require)
+                found.push(...Object.keys(parsed.require).filter((k) => k !== "php"));
+        }
+        catch {
+            // A partial diff (added lines only) is rarely valid standalone JSON —
+            // fall through to returning whatever we found (nothing), rather than
+            // guessing at a malformed fragment.
+        }
+        return found;
+    }
+    // use Vendor\Sub\Class; — namespace-to-composer-package mapping isn't
+    // mechanical in PHP, so this only extracts the first namespace segment
+    // (lowercased) as the lookup key. That's enough for framework-level
+    // detection (e.g. `use Illuminate\...` -> "illuminate") but deliberately
+    // doesn't attempt vendor/package-accurate resolution — see docs/signatures.md.
+    const useRe = /^[ \t]*use\s+([A-Za-z0-9_]+)\\/gm;
+    for (const m of text.matchAll(useRe)) {
+        if (isRealStatement(text, m.index))
+            found.push(m[1].toLowerCase());
+    }
+    return found;
+}
+/**
+ * Extracts normalized package names from one file's added diff lines.
+ * `filePath` selects the language (and, for Ruby/PHP, distinguishes a
+ * Gemfile/composer.json from ordinary source). Returns [] for files whose
+ * extension isn't recognized, or for excluded doc files (.md etc.) — never
+ * throws.
+ */
+export function extractImportedPackages(addedLines, filePath) {
+    const language = languageForPath(filePath);
+    if (!language)
+        return [];
+    // composer.json is parsed as structured JSON — stripping would only ever
+    // be a harmless no-op there, but skip it anyway rather than run a regex
+    // pass with zero possible benefit right before a JSON.parse. Every other
+    // path gets the stripped text.
+    const isComposerJson = language === "php" && /composer\.json$/i.test(filePath);
+    const text = isComposerJson ? addedLines : stripNonCodeRegions(addedLines);
+    switch (language) {
+        case "js":
+            return extractJs(text);
+        case "python":
+            return extractPython(text);
+        case "go":
+            return extractGo(text);
+        case "ruby":
+            return extractRuby(text, filePath);
+        case "php":
+            return extractPhp(text, filePath);
+    }
+}