trust-npm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 trust-npm contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# trust-npm
+
+`trust-npm` is a production-oriented npm wrapper that blocks unknown dependencies by default and requires explicit approvals.
+
+It uses your existing `package-lock.json` as a trust baseline and intercepts `npm install` before allowing package installation.
+
+## Features
+
+- Default-deny installs for unknown packages
+- Trust baseline bootstrapped from `package-lock.json`
+- Risk scoring for unknown packages (age, downloads, repo, naming pattern)
+- Explicit approvals via `trust-npm approve`
+- Cross-platform npm passthrough using `child_process.spawn`
+
+## Install
+
+```bash
+npm install
+npm run build
+npm link
+```
+
+Then use:
+
+```bash
+trust-npm --help
+```
+
+## One-command project setup
+
+If you want npm commands to go through `trust-npm` automatically:
+
+```bash
+trust-npm init
+```
+
+This will:
+
+- create/update `.trust-npm.json` from `package-lock.json`
+- persist alias `npm -> trust-npm` in your shell profile
+
+You can force shell target:
+
+```bash
+trust-npm init --shell powershell
+trust-npm init --shell bash
+trust-npm init --shell zsh
+```
+
+## Commands
+
+### `trust-npm init`
+
+Initializes `.trust-npm.json` using lockfile dependencies and sets a persistent shell alias (`npm -> trust-npm`).
+
+```bash
+trust-npm init
+```
+
+Skip automatic alias setup:
+
+```bash
+trust-npm init --skip-alias
+```
+
+Optional alias instructions:
+
+```bash
+trust-npm init --print-shell-alias
+```
+
+### `trust-npm install <package...>`
+
+Intercepts install requests and blocks unknown packages until explicitly approved.
+
+```bash
+trust-npm install lodash
+trust-npm install react -D
+```
+
+If blocked:
+
+```text
+❌ BLOCKED (high risk): fast-ultra-db-kit
+Reason:
+- Published 2 day(s) ago
+- 12 weekly downloads
+- Missing repository field
+- Risk score: 90/50
+
+Run:
+trust-npm approve fast-ultra-db-kit
+```
+
+### `trust-npm approve <package...>`
+
+Adds packages to trusted store:
+
+```bash
+trust-npm approve lodash
+trust-npm approve react react-dom
+```
+
+### `trust-npm status`
+
+Shows high-level trust status for the current project:
+
+```bash
+trust-npm status
+```
+
+## Trust Store Format
+
+`.trust-npm.json`:
+
+```json
+{
+  "version": 1,
+  "createdAt": "2026-04-04T10:00:00.000Z",
+  "updatedAt": "2026-04-04T10:05:00.000Z",
+  "trustedPackages": {
+    "lodash": {
+      "source": "lockfile",
+      "approvedAt": "2026-04-04T10:00:00.000Z"
+    },
+    "fast-ultra-db-kit": {
+      "source": "manual",
+      "approvedAt": "2026-04-04T10:05:00.000Z"
+    }
+  },
+  "riskThreshold": 50
+}
+```
+
+## Security Model
+
+- Unknown package install attempts are blocked.
+- High-risk unknown packages are called out with detailed risk factors.
+- Even low-risk unknown packages are still blocked until approved.
+- No silent approvals.
+
+## Notes
+
+- `trust-npm install` forwards to real `npm install` only when checks pass.
+- If you run plain `npm install`, trust checks are bypassed. Use shell aliasing if desired.
+- Network access to npm registry is required for risk analysis on unknown packages.
+
+## Future Extensions
+
+The structure is prepared for:
+
+- additional package manager adapters (for example, `pip`)
+- runtime import/require protection
+- CI/CD enforcement mode

package/dist/cli.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const install_1 = require("./commands/install");
+const approve_1 = require("./commands/approve");
+const status_1 = require("./commands/status");
+const program = new commander_1.Command();
+program
+    .name("trust-npm")
+    .description("Secure wrapper around npm install with trust baseline checks")
+    .version("0.1.0");
+program
+    .command("init")
+    .description("Create .trust-npm.json and auto-alias npm -> trust-npm")
+    .option("--print-shell-alias", "Print alias instructions")
+    .option("--skip-alias", "Skip automatic shell alias setup")
+    .option("--shell <shell>", "Alias target shell (powershell|bash|zsh)")
+    .action(async (options) => {
+    await (0, init_1.runInit)(options);
+});
+program
+    .command("install [packages...]")
+    .description("Intercept npm install and block unknown/untrusted packages")
+    .allowUnknownOption(true)
+    .action(async () => {
+    const rawInstallArgs = getRawInstallArgs(process.argv);
+    await (0, install_1.runInstall)(rawInstallArgs);
+});
+program
+    .command("approve <packages...>")
+    .description("Approve one or more packages into .trust-npm.json")
+    .action(async (packages) => {
+    await (0, approve_1.runApprove)(packages);
+});
+program
+    .command("status")
+    .description("Show trusted vs untrusted dependency status")
+    .action(async () => {
+    await (0, status_1.runStatus)();
+});
+program.parseAsync(process.argv).catch((error) => {
+    if (error instanceof Error) {
+        console.error(`trust-npm error: ${error.message}`);
+    }
+    else {
+        console.error("trust-npm error: unknown failure");
+    }
+    process.exitCode = 1;
+});
+function getRawInstallArgs(argv) {
+    const installIndex = argv.findIndex((token) => token === "install");
+    if (installIndex < 0) {
+        return [];
+    }
+    return argv.slice(installIndex + 1);
+}

package/dist/commands/approve.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runApprove = runApprove;
+const project_1 = require("../core/project");
+const trustStore_1 = require("../core/trustStore");
+async function runApprove(packages) {
+    if (packages.length === 0) {
+        throw new Error("Please provide at least one package to approve.");
+    }
+    const projectRoot = (0, project_1.findProjectRoot)();
+    const store = (0, trustStore_1.readTrustStore)(projectRoot) ?? (0, trustStore_1.createEmptyTrustStore)();
+    (0, trustStore_1.addTrustedPackages)(store, dedupe(packages), "manual");
+    (0, trustStore_1.writeTrustStore)(projectRoot, store);
+    console.log(`Approved package(s): ${dedupe(packages).join(", ")}`);
+}
+function dedupe(items) {
+    return [...new Set(items)];
+}

package/dist/commands/init.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const project_1 = require("../core/project");
+const lockfile_1 = require("../core/lockfile");
+const trustStore_1 = require("../core/trustStore");
+async function runInit(options = {}) {
+    const projectRoot = (0, project_1.findProjectRoot)();
+    const packageJsonPath = path_1.default.join(projectRoot, "package.json");
+    if (!fs_1.default.existsSync(packageJsonPath)) {
+        throw new Error("package.json not found. Run this inside an npm project.");
+    }
+    const trustedFromLockfile = (0, lockfile_1.extractTrustedFromLockfile)(projectRoot);
+    const existing = (0, trustStore_1.readTrustStore)(projectRoot);
+    const store = existing ?? (0, trustStore_1.createEmptyTrustStore)();
+    (0, trustStore_1.addTrustedPackages)(store, [...trustedFromLockfile], "lockfile");
+    (0, trustStore_1.writeTrustStore)(projectRoot, store);
+    const storePath = (0, trustStore_1.trustStorePath)(projectRoot);
+    console.log(`Initialized trust store: ${storePath}`);
+    console.log(`Trusted packages imported: ${trustedFromLockfile.size}`);
+    if (!options.skipAlias) {
+        const shell = detectShell(options.shell);
+        const profilePath = ensureAliasInProfile(shell);
+        console.log(`Alias configured for ${shell} in: ${profilePath}`);
+        console.log("Restart your terminal or reload profile for alias to take effect.");
+    }
+    if (options.printShellAlias) {
+        console.log("");
+        console.log("Optional shell alias:");
+        console.log("  alias npm='trust-npm'");
+        console.log("Windows PowerShell:");
+        console.log("  Set-Alias npm trust-npm");
+    }
+}
+function detectShell(requested) {
+    if (requested) {
+        return requested;
+    }
+    if (process.platform === "win32") {
+        return "powershell";
+    }
+    const envShell = process.env.SHELL ?? "";
+    if (envShell.includes("zsh")) {
+        return "zsh";
+    }
+    return "bash";
+}
+function ensureAliasInProfile(shell) {
+    if (shell === "powershell") {
+        return ensurePowerShellAlias();
+    }
+    return ensurePosixAlias(shell);
+}
+function ensurePowerShellAlias() {
+    const home = os_1.default.homedir();
+    const ps7Path = path_1.default.join(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+    const legacyPath = path_1.default.join(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+    const profilePath = fs_1.default.existsSync(ps7Path) ? ps7Path : legacyPath;
+    ensureFile(profilePath);
+    const startMarker = "# trust-npm alias start";
+    const endMarker = "# trust-npm alias end";
+    const block = `${startMarker}
+Set-Alias npm trust-npm
+${endMarker}
+`;
+    appendBlockIfMissing(profilePath, startMarker, block);
+    return profilePath;
+}
+function ensurePosixAlias(shell) {
+    const home = os_1.default.homedir();
+    const filename = shell === "zsh" ? ".zshrc" : ".bashrc";
+    const profilePath = path_1.default.join(home, filename);
+    ensureFile(profilePath);
+    const startMarker = "# trust-npm alias start";
+    const endMarker = "# trust-npm alias end";
+    const block = `${startMarker}
+alias npm='trust-npm'
+${endMarker}
+`;
+    appendBlockIfMissing(profilePath, startMarker, block);
+    return profilePath;
+}
+function ensureFile(filePath) {
+    const dir = path_1.default.dirname(filePath);
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs_1.default.existsSync(filePath)) {
+        fs_1.default.writeFileSync(filePath, "", "utf8");
+    }
+}
+function appendBlockIfMissing(filePath, marker, block) {
+    const existing = fs_1.default.readFileSync(filePath, "utf8");
+    if (existing.includes(marker)) {
+        return;
+    }
+    const prefix = existing.endsWith("\n") || existing.length === 0 ? "" : "\n";
+    fs_1.default.writeFileSync(filePath, `${existing}${prefix}${block}`, "utf8");
+}

package/dist/commands/install.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInstall = runInstall;
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+const project_1 = require("../core/project");
+const npm_1 = require("../core/npm");
+const risk_1 = require("../core/risk");
+const trustStore_1 = require("../core/trustStore");
+async function runInstall(rawInstallArgs) {
+    const projectRoot = (0, project_1.findProjectRoot)();
+    const store = (0, trustStore_1.readTrustStore)(projectRoot);
+    if (!store) {
+        throw new Error("No .trust-npm.json found. Run `trust-npm init` first.");
+    }
+    const requestedPackages = extractRequestedPackages(rawInstallArgs);
+    if (requestedPackages.length > 0) {
+        const unknown = requestedPackages.filter((name) => !store.trustedPackages[name]);
+        if (unknown.length > 0) {
+            const analyses = await Promise.all(unknown.map((pkg) => (0, risk_1.analyzePackageRisk)(pkg, store.riskThreshold)));
+            printBlockedPackages(analyses);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const exitCode = await (0, npm_1.runNpm)(["install", ...rawInstallArgs]);
+    process.exitCode = exitCode;
+}
+function extractRequestedPackages(args) {
+    const names = new Set();
+    for (const token of args) {
+        if (!token || token.startsWith("-")) {
+            continue;
+        }
+        try {
+            const parsed = (0, npm_package_arg_1.default)(token);
+            if (parsed.name) {
+                names.add(parsed.name);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return [...names];
+}
+function printBlockedPackages(analyses) {
+    for (const analysis of analyses) {
+        const header = analysis.isHighRisk ? "BLOCKED (high risk)" : "BLOCKED (untrusted package)";
+        console.error(`\n❌ ${header}: ${analysis.packageName}`);
+        console.error("Reason:");
+        if (analysis.reasons.length > 0) {
+            for (const reason of analysis.reasons) {
+                console.error(`- ${reason}`);
+            }
+        }
+        else {
+            console.error("- New package is not in trusted baseline");
+        }
+        console.error(`- Risk score: ${analysis.score}/${analysis.threshold}`);
+        console.error("");
+        console.error(`Run:\ntrust-npm approve ${analysis.packageName}`);
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStatus = runStatus;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_1 = require("../core/project");
+const trustStore_1 = require("../core/trustStore");
+async function runStatus() {
+    const projectRoot = (0, project_1.findProjectRoot)();
+    const store = (0, trustStore_1.readTrustStore)(projectRoot);
+    if (!store) {
+        console.log("No trust store found. Run `trust-npm init` first.");
+        return;
+    }
+    const pkg = readPackageJson(projectRoot);
+    const declared = new Set([
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {}),
+        ...Object.keys(pkg.peerDependencies ?? {}),
+        ...Object.keys(pkg.optionalDependencies ?? {})
+    ]);
+    const trustedDeclared = [];
+    const untrustedDeclared = [];
+    for (const name of declared) {
+        if (store.trustedPackages[name]) {
+            trustedDeclared.push(name);
+        }
+        else {
+            untrustedDeclared.push(name);
+        }
+    }
+    console.log(`Trust store path: ${path_1.default.join(projectRoot, ".trust-npm.json")}`);
+    console.log(`Total trusted packages in store: ${Object.keys(store.trustedPackages).length}`);
+    console.log(`Declared dependencies: ${declared.size}`);
+    console.log(`Trusted declared dependencies: ${trustedDeclared.length}`);
+    console.log(`Untrusted declared dependencies: ${untrustedDeclared.length}`);
+    if (untrustedDeclared.length > 0) {
+        console.log("");
+        console.log("Untrusted declared dependencies:");
+        for (const dep of untrustedDeclared.sort()) {
+            console.log(`- ${dep}`);
+        }
+    }
+}
+function readPackageJson(projectRoot) {
+    const filePath = path_1.default.join(projectRoot, "package.json");
+    if (!fs_1.default.existsSync(filePath)) {
+        throw new Error("package.json not found.");
+    }
+    return JSON.parse(fs_1.default.readFileSync(filePath, "utf8"));
+}

package/dist/core/lockfile.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLockfilePath = getLockfilePath;
+exports.readLockfile = readLockfile;
+exports.extractTrustedFromLockfile = extractTrustedFromLockfile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function getLockfilePath(projectRoot) {
+    return path_1.default.join(projectRoot, "package-lock.json");
+}
+function readLockfile(projectRoot) {
+    const lockfilePath = getLockfilePath(projectRoot);
+    if (!fs_1.default.existsSync(lockfilePath)) {
+        throw new Error(`Missing package-lock.json at ${lockfilePath}`);
+    }
+    const raw = fs_1.default.readFileSync(lockfilePath, "utf8");
+    return JSON.parse(raw);
+}
+function extractTrustedFromLockfile(projectRoot) {
+    const lockfile = readLockfile(projectRoot);
+    const trusted = new Set();
+    if (lockfile.packages) {
+        for (const key of Object.keys(lockfile.packages)) {
+            if (!key.startsWith("node_modules/")) {
+                continue;
+            }
+            const name = key.slice("node_modules/".length);
+            if (name) {
+                trusted.add(name);
+            }
+        }
+    }
+    if (lockfile.dependencies) {
+        walkDependencyTree(lockfile.dependencies, trusted);
+    }
+    return trusted;
+}
+function walkDependencyTree(deps, trusted) {
+    for (const [name, dep] of Object.entries(deps)) {
+        trusted.add(name);
+        if (dep.dependencies) {
+            walkDependencyTree(dep.dependencies, trusted);
+        }
+    }
+}

package/dist/core/npm.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNpm = runNpm;
+const child_process_1 = require("child_process");
+async function runNpm(args) {
+    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(npmCommand, args, {
+            stdio: "inherit",
+            shell: false
+        });
+        child.on("error", (error) => reject(error));
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}

package/dist/core/project.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectRoot = findProjectRoot;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function findProjectRoot(startDir = process.cwd()) {
+    let current = path_1.default.resolve(startDir);
+    const root = path_1.default.parse(current).root;
+    while (true) {
+        const packageJsonPath = path_1.default.join(current, "package.json");
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            return current;
+        }
+        if (current === root) {
+            throw new Error("Could not find project root (no package.json found).");
+        }
+        current = path_1.default.dirname(current);
+    }
+}

package/dist/core/registry.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPackageMetadata = fetchPackageMetadata;
+exports.fetchWeeklyDownloads = fetchWeeklyDownloads;
+const axios_1 = __importDefault(require("axios"));
+async function fetchPackageMetadata(packageName) {
+    const encoded = encodeURIComponent(packageName);
+    const url = `https://registry.npmjs.org/${encoded}`;
+    const response = await axios_1.default.get(url, { timeout: 5000 });
+    const data = response.data;
+    return {
+        name: data.name ?? packageName,
+        createdAt: data.time?.created,
+        repository: data.repository
+    };
+}
+async function fetchWeeklyDownloads(packageName) {
+    const encoded = encodeURIComponent(packageName);
+    const url = `https://api.npmjs.org/downloads/point/last-week/${encoded}`;
+    const response = await axios_1.default.get(url, { timeout: 5000 });
+    const data = response.data;
+    return {
+        downloads: typeof data.downloads === "number" ? data.downloads : 0
+    };
+}

package/dist/core/risk.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePackageRisk = analyzePackageRisk;
+const registry_1 = require("./registry");
+const NEW_PACKAGE_DAYS_THRESHOLD = 7;
+const LOW_DOWNLOADS_THRESHOLD = 100;
+async function analyzePackageRisk(packageName, threshold) {
+    let score = 0;
+    const reasons = [];
+    const metadata = {};
+    const [pkg, downloads] = await Promise.all([
+        (0, registry_1.fetchPackageMetadata)(packageName),
+        (0, registry_1.fetchWeeklyDownloads)(packageName)
+    ]);
+    const ageDays = getPackageAgeDays(pkg.createdAt);
+    metadata.publishedAt = pkg.createdAt;
+    metadata.ageDays = ageDays;
+    metadata.weeklyDownloads = downloads.downloads;
+    if (typeof ageDays === "number" && ageDays < NEW_PACKAGE_DAYS_THRESHOLD) {
+        score += 40;
+        reasons.push(`Published ${ageDays} day(s) ago`);
+    }
+    if (downloads.downloads < LOW_DOWNLOADS_THRESHOLD) {
+        score += 30;
+        reasons.push(`${downloads.downloads} weekly downloads`);
+    }
+    const hasRepo = hasRepository(pkg.repository);
+    metadata.hasRepository = hasRepo;
+    if (!hasRepo) {
+        score += 20;
+        reasons.push("Missing repository field");
+    }
+    const suspiciousName = hasSuspiciousName(packageName);
+    metadata.suspiciousName = suspiciousName;
+    if (suspiciousName) {
+        score += 10;
+        reasons.push("Suspicious naming pattern");
+    }
+    return {
+        packageName,
+        score,
+        threshold,
+        isHighRisk: score > threshold,
+        reasons,
+        metadata
+    };
+}
+function getPackageAgeDays(createdAt) {
+    if (!createdAt) {
+        return undefined;
+    }
+    const created = new Date(createdAt);
+    if (Number.isNaN(created.valueOf())) {
+        return undefined;
+    }
+    const diffMs = Date.now() - created.getTime();
+    return Math.max(0, Math.floor(diffMs / (1000 * 60 * 60 * 24)));
+}
+function hasRepository(repository) {
+    if (!repository) {
+        return false;
+    }
+    if (typeof repository === "string") {
+        return repository.trim().length > 0;
+    }
+    if (typeof repository === "object" && repository !== null) {
+        const maybeUrl = repository.url;
+        return typeof maybeUrl === "string" && maybeUrl.trim().length > 0;
+    }
+    return false;
+}
+function hasSuspiciousName(name) {
+    const normalized = name.toLowerCase();
+    const tokens = normalized.split(/[-_.]/g).filter(Boolean);
+    if (tokens.length >= 4) {
+        return true;
+    }
+    const suspiciousTokens = ["fast", "ultra", "super", "pro", "best", "safe"];
+    let suspiciousHits = 0;
+    for (const token of tokens) {
+        if (suspiciousTokens.includes(token)) {
+            suspiciousHits += 1;
+        }
+    }
+    return suspiciousHits >= 2;
+}

package/dist/core/trustStore.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRUST_STORE_FILE = void 0;
+exports.trustStorePath = trustStorePath;
+exports.createEmptyTrustStore = createEmptyTrustStore;
+exports.readTrustStore = readTrustStore;
+exports.writeTrustStore = writeTrustStore;
+exports.addTrustedPackages = addTrustedPackages;
+exports.isTrusted = isTrusted;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.TRUST_STORE_FILE = ".trust-npm.json";
+const DEFAULT_THRESHOLD = 50;
+function trustStorePath(projectRoot) {
+    return path_1.default.join(projectRoot, exports.TRUST_STORE_FILE);
+}
+function createEmptyTrustStore() {
+    const now = new Date().toISOString();
+    return {
+        version: 1,
+        createdAt: now,
+        updatedAt: now,
+        trustedPackages: {},
+        riskThreshold: DEFAULT_THRESHOLD
+    };
+}
+function readTrustStore(projectRoot) {
+    const filePath = trustStorePath(projectRoot);
+    if (!fs_1.default.existsSync(filePath)) {
+        return null;
+    }
+    const raw = fs_1.default.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    parsed.riskThreshold = parsed.riskThreshold ?? DEFAULT_THRESHOLD;
+    return parsed;
+}
+function writeTrustStore(projectRoot, store) {
+    const filePath = trustStorePath(projectRoot);
+    store.updatedAt = new Date().toISOString();
+    fs_1.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}\n`, "utf8");
+}
+function addTrustedPackages(store, packageNames, source) {
+    const now = new Date().toISOString();
+    for (const name of packageNames) {
+        store.trustedPackages[name] = {
+            source,
+            approvedAt: now
+        };
+    }
+    return store;
+}
+function isTrusted(store, packageName) {
+    return Boolean(store.trustedPackages[packageName]);
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "trust-npm",
+  "version": "0.1.0",
+  "description": "A safe npm wrapper that blocks untrusted dependencies by default.",
+  "type": "commonjs",
+  "main": "dist/cli.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "trust-npm": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/cli.js",
+    "dev": "ts-node src/cli.ts"
+  },
+  "keywords": [
+    "npm",
+    "security",
+    "supply-chain",
+    "cli",
+    "lockfile"
+  ],
+  "author": "trust-npm contributors",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.8.4",
+    "commander": "^12.1.0",
+    "npm-package-arg": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  }
+}