@amanpareek/depkit 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aman Pareek
+
+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

@@ -1,3 +1,84 @@
-# Temporary Holding Version
+# depkit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/@amanpareek/depkit)](https://www.npmjs.com/package/@amanpareek/depkit)
+[![license](https://img.shields.io/npm/l/@amanpareek/depkit)](LICENSE)
+
+**Stop retyping the same `npm install` in every project.**
+
+Save your dependencies once as a named preset. Reinstall them anywhere with one command.
+
+```bash
+# Before
+npm i express mongoose dotenv jsonwebtoken bcrypt cors
+npm i -D nodemon
+
+# After
+dk use mern-backend
+```
+
+depkit is not a project generator or boilerplate tool. It only saves and installs lists of npm packages.
+
+## Install
+
+```bash
+npm i -g @amanpareek/depkit
+```
+
+Use `depkit` or the short `dk`. Requires Node.js 18+ and npm.
+
+## 30-second tour
+
+```bash
+dk save mern-backend                                  # snapshot this project's dependencies
+dk create react-ui react react-dom -D prettier eslint # or create a custom preset
+dk use mern-backend                                   # install all its packages in any future project
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `dk save <name>` | Save the current project's dependencies as a preset |
+| `dk create <name> [packages...] [-D devPackages...]` | Create a preset from package names |
+| `dk add <preset> [packages...] [-D devPackages...]` | Add new packages to a preset |
+| `dk remove <preset> <packages...>` | Remove packages from a preset |
+| `dk update <preset> <packages...>` | Set packages to latest, or to `name@version` |
+| `dk update <preset> --all` | Set every package to latest |
+| `dk use <name>` | Install a preset into the current project |
+| `dk list` / `dk show <name>` | See your presets and what is inside |
+| `dk delete <name>` | Delete a preset |
+
+Add `--dry-run` to `use` and `update` to preview. Add `--force` to `save`, `create` and `delete` to skip the confirmation.
+
+## Good to know
+
+**Dev dependencies.** Everything after `-D` is a dev dependency. Write normal packages before it.
+
+```bash
+dk add api express zod             # both normal
+dk add api express -D nodemon      # express normal, nodemon dev
+```
+
+**Versions.** No version means `latest`, resolved when you run `dk use`, so old presets never go stale. Add a version when your code needs one: `express@4`, `zod@3.22.0`. Versions are checked against npm before saving, so a typo never gets in.
+
+```text
+No version of pdf-lib matches "1.17.2". Latest is 1.17.1.
+```
+
+**Nothing changes by accident.** `add` never overwrites a package that is already in the preset, and `update` only touches the packages you name (or everything, with `--all`).
+
+**Windows CMD.** `^` is an escape character there, so quote it: `dk add api "pdf-lib@^1.17.1"`. PowerShell does not need this.
+
+**Where presets live.** One JSON file: `~/.depkit/presets.json` (`C:\Users\<you>\.depkit` on Windows). Set `DEPKIT_HOME` to change the folder.
+
+## Coming next
+
+Export and import presets as shareable files.
+
+## Contributing
+
+Issues and pull requests are welcome at [github.com/amanp30/depkit](https://github.com/amanp30/depkit).
+
+## License
+
+MIT © [Aman Pareek](https://github.com/amanp30)

package/bin/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("../src/index.js");

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@amanpareek/depkit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Save your project's npm dependencies as named presets and reinstall them in any project with one command.",
+  "type": "commonjs",
+  "bin": {
+    "depkit": "./bin/cli.js",
+    "dk": "./bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "keywords": [
+    "npm",
+    "cli",
+    "dependencies",
+    "presets",
+    "dependency-manager",
+    "nodejs"
+  ],
+  "author": "Aman Pareek <https://github.com/amanp30>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amanp30/depkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/amanp30/depkit/issues"
+  },
+  "homepage": "https://github.com/amanp30/depkit#readme",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "prompts": "^2.4.2",
+    "semver": "^7.8.5",
+    "validate-npm-package-name": "^5.0.1"
+  }
+}

package/src/commands/add.js

@@ -0,0 +1,68 @@
+const store = require("../core/store");
+const { findIn, parseSpec } = require("../core/preset");
+const { resolveSpec } = require("../core/registry");
+const { splitPackages } = require("../utils/args");
+const log = require("../utils/logger");
+
+const EXAMPLE = "dk add api zod -D nodemon";
+
+function register(program) {
+  program
+    .command("add <preset> [packages...]")
+    .description(
+      "Add new packages to a preset. Everything after -D is a dev dependency",
+    )
+    .option(
+      "-D, --dev [packages...]",
+      "packages written after -D go to devDependencies",
+    )
+    .action(async (presetName, packages, opts) => {
+      const preset = store.getPreset(presetName);
+      if (!preset) throw new Error(`Preset "${presetName}" not found.`);
+
+      const { normal, dev } = splitPackages(packages, opts.dev, EXAMPLE);
+
+      // jo package pehle se preset me hai use jodna nahi, update ka rasta dikhana hai
+      const skipped = [];
+      const seen = new Set();
+      const onlyNew = (list) =>
+        list.filter((spec) => {
+          const { name } = parseSpec(spec);
+          if (seen.has(name)) return false; // ek command me dobara likha naam
+          seen.add(name);
+          const key = findIn(preset, name);
+          if (!key) return true;
+          skipped.push({ name, current: preset[key][name] });
+          return false;
+        });
+      const normalNew = onlyNew(normal);
+      const devNew = onlyNew(dev);
+
+      for (const s of skipped) {
+        log.warn(
+          `"${s.name}" is already in "${presetName}" (${s.current}). ` +
+            `To change it: dk update ${presetName} ${s.name}@<version>   (or just ${s.name} for latest)`,
+        );
+      }
+      if (normalNew.length + devNew.length === 0) return;
+
+      const [normalResolved, devResolved] = await Promise.all([
+        Promise.all(normalNew.map(resolveSpec)),
+        Promise.all(devNew.map(resolveSpec)),
+      ]);
+
+      for (const { name, version } of normalResolved) {
+        preset.dependencies[name] = version;
+        log.success(`Added ${name}@${version}`);
+      }
+      for (const { name, version } of devResolved) {
+        preset.devDependencies[name] = version;
+        log.success(`Added ${name}@${version} (dev)`);
+      }
+
+      preset.updatedAt = new Date().toISOString();
+      store.setPreset(presetName, preset);
+    });
+}
+
+module.exports = register;

package/src/commands/create.js

@@ -0,0 +1,51 @@
+const store = require("../core/store");
+const { assertPresetName } = require("../core/preset");
+const { resolveSpec } = require("../core/registry");
+const { splitPackages } = require("../utils/args");
+const { confirm } = require("../utils/prompt");
+const log = require("../utils/logger");
+
+const EXAMPLE = "dk create api express -D nodemon";
+
+async function toMap(specs) {
+  const resolved = await Promise.all(specs.map(resolveSpec));
+  return Object.fromEntries(resolved.map((r) => [r.name, r.version]));
+}
+
+function register(program) {
+  program
+    .command("create <name> [packages...]")
+    .description(
+      "Create a preset from package names. Everything after -D is a dev dependency",
+    )
+    .option(
+      "-D, --dev [packages...]",
+      "packages written after -D go to devDependencies",
+    )
+    .option("-f, --force", "overwrite without asking")
+    .action(async (name, packages, opts) => {
+      assertPresetName(name);
+      const { normal, dev } = splitPackages(packages, opts.dev, EXAMPLE);
+
+      if (store.getPreset(name) && !opts.force) {
+        if (!(await confirm(`Preset "${name}" already exists. Overwrite?`))) {
+          return log.info("Cancelled.");
+        }
+      }
+
+      const [dependencies, devDependencies] = await Promise.all([
+        toMap(normal),
+        toMap(dev),
+      ]);
+      store.setPreset(name, {
+        dependencies,
+        devDependencies,
+        updatedAt: new Date().toISOString(),
+      });
+      log.success(
+        `Created "${name}" (${Object.keys(dependencies).length} deps, ${Object.keys(devDependencies).length} dev).`,
+      );
+    });
+}
+
+module.exports = register;

package/src/commands/delete.js

@@ -0,0 +1,21 @@
+const store = require("../core/store");
+const { confirm } = require("../utils/prompt");
+const log = require("../utils/logger");
+
+function register(program) {
+  program
+    .command("delete <name>")
+    .description("Delete a preset")
+    .option("-f, --force", "delete without asking")
+    .action(async (name, opts) => {
+      if (!store.getPreset(name))
+        throw new Error(`Preset "${name}" not found.`);
+      if (!opts.force && !(await confirm(`Delete preset "${name}"?`))) {
+        return log.info("Cancelled.");
+      }
+      store.deletePreset(name);
+      log.success(`Deleted "${name}".`);
+    });
+}
+
+module.exports = register;

package/src/commands/list.js

@@ -0,0 +1,22 @@
+const store = require("../core/store");
+const log = require("../utils/logger");
+
+function register(program) {
+  program
+    .command("list")
+    .description("List saved presets")
+    .action(() => {
+      const presets = store.listPresets();
+      const names = Object.keys(presets);
+      if (names.length === 0)
+        return log.info("No presets yet. Try: depkit save <name>");
+      for (const n of names) {
+        const p = presets[n];
+        const d = Object.keys(p.dependencies).length;
+        const dev = Object.keys(p.devDependencies).length;
+        log.info(`${n}  (${d} deps, ${dev} dev)`);
+      }
+    });
+}
+
+module.exports = register;

package/src/commands/remove.js

@@ -0,0 +1,31 @@
+const store = require("../core/store");
+const { parseSpec, findIn } = require("../core/preset");
+const log = require("../utils/logger");
+
+function register(program) {
+  program
+    .command("remove <preset> <packages...>")
+    .description("Remove packages from a preset")
+    .action((presetName, packages) => {
+      const preset = store.getPreset(presetName);
+      if (!preset) throw new Error(`Preset "${presetName}" not found.`);
+
+      let removed = 0;
+      for (const pkg of packages) {
+        const { name } = parseSpec(pkg);
+        const key = findIn(preset, name);
+        if (!key) {
+          log.warn(`"${name}" is not in "${presetName}".`);
+          continue;
+        }
+        delete preset[key][name];
+        removed++;
+        log.success(`Removed ${name}`);
+      }
+      if (removed === 0) return;
+      preset.updatedAt = new Date().toISOString();
+      store.setPreset(presetName, preset);
+    });
+}
+
+module.exports = register;

package/src/commands/save.js

@@ -0,0 +1,33 @@
+const { readProjectDeps } = require("../core/project");
+const store = require("../core/store");
+const { assertPresetName, buildPreset } = require("../core/preset");
+const { confirm } = require("../utils/prompt");
+const log = require("../utils/logger");
+
+function register(program) {
+  program
+    .command("save <name>")
+    .description("Save this project's dependencies as a preset")
+    .option("-f, --force", "overwrite without asking")
+    .action(async (name, opts) => {
+      assertPresetName(name);
+      const { preset, skipped } = buildPreset(readProjectDeps());
+      const d = Object.keys(preset.dependencies).length;
+      const dev = Object.keys(preset.devDependencies).length;
+      if (d + dev === 0)
+        throw new Error("This project has no dependencies to save.");
+
+      if (store.getPreset(name) && !opts.force) {
+        if (!(await confirm(`Preset "${name}" already exists. Overwrite?`))) {
+          return log.info("Cancelled.");
+        }
+      }
+      store.setPreset(name, preset);
+      skipped.forEach((s) =>
+        log.warn(`Skipped (not a registry version): ${s}`),
+      );
+      log.success(`Saved "${name}" (${d} dependencies, ${dev} dev).`);
+    });
+}
+
+module.exports = register;

package/src/commands/show.js

@@ -0,0 +1,24 @@
+const store = require("../core/store");
+const log = require("../utils/logger");
+
+function print(title, map) {
+  const entries = Object.entries(map);
+  if (entries.length === 0) return;
+  log.info(`\n${title}`);
+  entries.forEach(([n, v]) => log.info(`  ${n}  ${v}`));
+}
+
+function register(program) {
+  program
+    .command("show <name>")
+    .description("Show what a preset contains")
+    .action((name) => {
+      const p = store.getPreset(name);
+      if (!p) throw new Error(`Preset "${name}" not found.`);
+      log.info(name);
+      print("Dependencies", p.dependencies);
+      print("Dev dependencies", p.devDependencies);
+    });
+}
+
+module.exports = register;

package/src/commands/update.js

@@ -0,0 +1,73 @@
+const store = require("../core/store");
+const { findIn, parseSpec, isRegistryVersion } = require("../core/preset");
+const { assertVersionExists } = require("../core/registry");
+const log = require("../utils/logger");
+
+function register(program) {
+  program
+    .command("update <preset> [packages...]")
+    .description(
+      "Set named packages to latest, or to name@version. Use --all for everything",
+    )
+    .option("--all", "set every package in the preset to latest")
+    .option("--dry-run", "show changes without saving")
+    .action(async (presetName, packages, opts) => {
+      const preset = store.getPreset(presetName);
+      if (!preset) throw new Error(`Preset "${presetName}" not found.`);
+
+      if (opts.all && packages.length > 0) {
+        throw new Error("Use either package names or --all, not both.");
+      }
+      if (!opts.all && packages.length === 0) {
+        throw new Error(
+          `Name the package(s) to update, or use --all. Example: dk update ${presetName} express`,
+        );
+      }
+
+      const targets = opts.all
+        ? [
+            ...Object.keys(preset.dependencies),
+            ...Object.keys(preset.devDependencies),
+          ].map((name) => ({ name, version: "latest" }))
+        : packages.map((p) => {
+            const t = parseSpec(p);
+            return { name: t.name, version: t.version || "latest" };
+          });
+
+      for (const t of targets) {
+        if (!findIn(preset, t.name)) {
+          throw new Error(`"${t.name}" is not in preset "${presetName}".`);
+        }
+        if (t.version !== "latest" && !isRegistryVersion(t.version)) {
+          throw new Error(`Invalid version "${t.version}" for ${t.name}`);
+        }
+      }
+
+      // diye hue versions registry me verify hote hain ("latest" ko check nahi chahiye)
+      await Promise.all(
+        targets
+          .filter((t) => t.version !== "latest")
+          .map((t) => assertVersionExists(t.name, t.version)),
+      );
+
+      let changed = 0;
+      for (const { name, version } of targets) {
+        const key = findIn(preset, name);
+        const old = preset[key][name];
+        if (old === version) continue;
+        log.info(`${name}  ${old} -> ${version}`);
+        preset[key][name] = version;
+        changed++;
+      }
+
+      if (changed === 0) return log.info("Nothing to change.");
+      if (opts.dryRun)
+        return log.info(`${changed} package(s) would change (dry run).`);
+
+      preset.updatedAt = new Date().toISOString();
+      store.setPreset(presetName, preset);
+      log.success(`Updated ${changed} package(s) in "${presetName}".`);
+    });
+}
+
+module.exports = register;

package/src/commands/use.js

@@ -0,0 +1,67 @@
+const store = require("../core/store");
+const { readProjectDeps } = require("../core/project");
+const { toSpecs } = require("../core/preset");
+const npm = require("../core/npm");
+const log = require("../utils/logger");
+
+const seconds = (start) => ((Date.now() - start) / 1000).toFixed(1);
+
+function register(program) {
+  program
+    .command("use <name>")
+    .description("Install a preset into the current project")
+    .option("--dry-run", "show what would be installed")
+    .action(async (name, opts) => {
+      const preset = store.getPreset(name);
+      if (!preset)
+        throw new Error(`Preset "${name}" not found. Run "depkit list".`);
+      readProjectDeps(); // package.json hona zaroori hai
+
+      const steps = [
+        {
+          label: "dependencies",
+          specs: toSpecs(preset.dependencies),
+          dev: false,
+        },
+        {
+          label: "dev dependencies",
+          specs: toSpecs(preset.devDependencies),
+          dev: true,
+        },
+      ].filter((s) => s.specs.length > 0);
+
+      if (steps.length === 0) throw new Error(`Preset "${name}" is empty.`);
+
+      log.info(`${opts.dryRun ? "[dry run] " : ""}Preset "${name}"`);
+      const started = Date.now();
+
+      for (const [i, step] of steps.entries()) {
+        const verb = opts.dryRun ? "Would install" : "Installing";
+        log.info(
+          `\n[${i + 1}/${steps.length}] ${verb} ${step.label} (${step.specs.length})`,
+        );
+        step.specs.forEach((s) => log.info(`  - ${s}`));
+        if (opts.dryRun) continue;
+
+        try {
+          await npm.install(step.specs, { dev: step.dev });
+        } catch (err) {
+          throw new Error(
+            `Failed while installing ${step.label}: ${err.message}`,
+          );
+        }
+        log.success(`${step.label} installed`);
+      }
+
+      if (opts.dryRun) return;
+      const summary = steps
+        .map((s) => `${s.specs.length} ${s.label}`)
+        .join(", ");
+      log.info("");
+      log.success(
+        `Done. Preset "${name}" installed (${summary}) in ${seconds(started)}s`,
+      );
+    });
+}
+
+module.exports = register;

package/src/config.js

@@ -0,0 +1,10 @@
+const os = require("os");
+const path = require("path");
+
+const DIR = process.env.DEPKIT_HOME || path.join(os.homedir(), ".depkit");
+
+module.exports = {
+  DIR,
+  STORE_FILE: path.join(DIR, "presets.json"),
+  SCHEMA_VERSION: 1,
+};

package/src/core/npm.js

@@ -0,0 +1,54 @@
+const { spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+// sirf in characters ki ijazat, taaki kuch ghus na sake
+const SAFE_SPEC = /^[A-Za-z0-9@/._~^*<>=|+\- ]+$/;
+
+// Windows par npm.cmd ko bina shell ke chalana allowed nahi,
+// isliye node se seedha npm-cli.js chalate hain (wo node.exe ke saath hi hota hai)
+function findNpmCli() {
+  const cli = path.join(
+    path.dirname(process.execPath),
+    "node_modules",
+    "npm",
+    "bin",
+    "npm-cli.js",
+  );
+  return fs.existsSync(cli) ? cli : null;
+}
+
+function run(args, cwd) {
+  return new Promise((resolve, reject) => {
+    let child;
+    if (process.platform === "win32") {
+      const cli = findNpmCli();
+      child = cli
+        ? spawn(process.execPath, [cli, ...args], { cwd, stdio: "inherit" })
+        : spawn(
+            "npm",
+            args.map((a) => `"${a}"`),
+            { cwd, stdio: "inherit", shell: true },
+          );
+    } else {
+      child = spawn("npm", args, { cwd, stdio: "inherit" });
+    }
+    child.on("error", reject);
+    child.on("close", (code) =>
+      code === 0
+        ? resolve()
+        : reject(new Error(`npm exited with code ${code}`)),
+    );
+  });
+}
+
+function install(specs, { dev = false, cwd = process.cwd() } = {}) {
+  if (specs.length === 0) return Promise.resolve();
+  for (const s of specs) {
+    if (!SAFE_SPEC.test(s))
+      return Promise.reject(new Error(`Unsafe package spec: ${s}`));
+  }
+  return run(["install", ...specs, ...(dev ? ["--save-dev"] : [])], cwd);
+}
+
+module.exports = { install };

package/src/core/preset.js

@@ -0,0 +1,73 @@
+const validate = require("validate-npm-package-name");
+
+const PRESET_NAME = /^[a-z0-9][a-z0-9_-]{0,49}$/i;
+// semver ranges aur tags (latest, next). file:, git+, workspace: wagairah reject.
+const REGISTRY_VERSION = /^[A-Za-z0-9.^~*<>=|+\- ]+$/;
+
+function assertPresetName(name) {
+  if (!PRESET_NAME.test(name)) {
+    throw new Error(
+      'Preset name must be letters, numbers, "-" or "_" (max 50 chars).',
+    );
+  }
+}
+
+function assertPackageName(name) {
+  if (name.startsWith("-") || !validate(name).validForOldPackages) {
+    throw new Error(`Invalid package name: "${name}"`);
+  }
+}
+
+const isRegistryVersion = (v) =>
+  typeof v === "string" && REGISTRY_VERSION.test(v);
+
+function clean(map, skipped) {
+  const out = {};
+  for (const [name, version] of Object.entries(map)) {
+    if (!isRegistryVersion(version)) {
+      skipped.push(`${name}@${version}`);
+      continue;
+    }
+    assertPackageName(name);
+    out[name] = version;
+  }
+  return out;
+}
+
+function buildPreset({ dependencies = {}, devDependencies = {} }) {
+  const skipped = [];
+  const preset = {
+    dependencies: clean(dependencies, skipped),
+    devDependencies: clean(devDependencies, skipped),
+    updatedAt: new Date().toISOString(),
+  };
+  return { preset, skipped };
+}
+
+const toSpecs = (map) => Object.entries(map).map(([n, v]) => `${n}@${v}`);
+
+// "react@18" -> { name: 'react', version: '18' }, "@types/node" -> { name: '@types/node', version: '' }
+function parseSpec(spec) {
+  const at = spec.lastIndexOf("@");
+  if (at > 0) return { name: spec.slice(0, at), version: spec.slice(at + 1) };
+  return { name: spec, version: "" };
+}
+
+// package kis section me hai: 'dependencies', 'devDependencies' ya null
+function findIn(preset, name) {
+  for (const key of ["dependencies", "devDependencies"]) {
+    if (Object.prototype.hasOwnProperty.call(preset[key] || {}, name))
+      return key;
+  }
+  return null;
+}
+
+module.exports = {
+  assertPresetName,
+  assertPackageName,
+  isRegistryVersion,
+  buildPreset,
+  toSpecs,
+  parseSpec,
+  findIn,
+};

package/src/core/project.js

@@ -0,0 +1,23 @@
+const fs = require("fs");
+const path = require("path");
+
+function readProjectDeps(dir = process.cwd()) {
+  const file = path.join(dir, "package.json");
+  if (!fs.existsSync(file)) {
+    throw new Error(
+      'No package.json found in this folder. Run "npm init -y" first.',
+    );
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    throw new Error("package.json is not valid JSON.");
+  }
+  return {
+    dependencies: pkg.dependencies || {},
+    devDependencies: pkg.devDependencies || {},
+  };
+}
+
+module.exports = { readProjectDeps };

package/src/core/registry.js

@@ -0,0 +1,52 @@
+const semver = require('semver');
+const { parseSpec, isRegistryVersion, assertPackageName } = require('./preset');
+
+const has = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+// Registry se package ki (chhoti) metadata laata hai: dist-tags aur versions ki list
+async function fetchMeta(name) {
+  const url = `https://registry.npmjs.org/${name.replace('/', '%2F')}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { Accept: 'application/vnd.npm.install-v1+json' },
+      signal: AbortSignal.timeout(10000),
+    });
+  } catch {
+    throw new Error(`Could not reach the npm registry for "${name}". Check your internet.`);
+  }
+  if (res.status === 404) throw new Error(`Package "${name}" not found on npm.`);
+  if (!res.ok) throw new Error(`npm registry error ${res.status} for "${name}".`);
+  return res.json();
+}
+
+// Diya hua version, range ya tag sach me maujood hai ya nahi
+async function assertVersionExists(name, version) {
+  const meta = await fetchMeta(name);
+  const tags = meta['dist-tags'] || {};
+  if (has(tags, version)) return; // jaise "next" ya "beta"
+  if (!semver.validRange(version)) {
+    throw new Error(`"${version}" is not a valid version, range or tag for ${name}.`);
+  }
+  if (!semver.maxSatisfying(Object.keys(meta.versions || {}), version)) {
+    throw new Error(`No version of ${name} matches "${version}". Latest is ${tags.latest}.`);
+  }
+}
+
+// Version nahi diya (ya "latest") -> "latest" save hota hai, install ke waqt resolve hoga.
+// Diya hua version registry me verify hota hai.
+async function resolveSpec(spec) {
+  const { name, version } = parseSpec(spec);
+  assertPackageName(name);
+  if (!version || version === 'latest') {
+    await fetchMeta(name); // sirf ye dekhne ke liye ki package maujood hai
+    return { name, version: 'latest' };
+  }
+  if (!isRegistryVersion(version)) {
+    throw new Error(`Invalid version "${version}" for ${name}`);
+  }
+  await assertVersionExists(name, version);
+  return { name, version };
+}
+
+module.exports = { assertVersionExists, resolveSpec };

package/src/core/store.js

@@ -0,0 +1,46 @@
+const fs = require("fs");
+const { DIR, STORE_FILE, SCHEMA_VERSION } = require("../config");
+
+const has = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+function load() {
+  if (!fs.existsSync(STORE_FILE))
+    return { schemaVersion: SCHEMA_VERSION, presets: {} };
+  try {
+    return JSON.parse(fs.readFileSync(STORE_FILE, "utf8"));
+  } catch {
+    throw new Error(`Presets file is corrupted: ${STORE_FILE}`);
+  }
+}
+
+function write(data) {
+  fs.mkdirSync(DIR, { recursive: true });
+  const tmp = `${STORE_FILE}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
+  fs.renameSync(tmp, STORE_FILE);
+}
+
+function getPreset(name) {
+  const { presets } = load();
+  return has(presets, name) ? presets[name] : null;
+}
+
+function setPreset(name, preset) {
+  const data = load();
+  data.presets[name] = preset;
+  write(data);
+}
+
+function deletePreset(name) {
+  const data = load();
+  if (!has(data.presets, name)) return false;
+  delete data.presets[name];
+  write(data);
+  return true;
+}
+
+function listPresets() {
+  return load().presets;
+}
+
+module.exports = { getPreset, setPreset, deletePreset, listPresets };

package/src/index.js

@@ -0,0 +1,22 @@
+const { Command } = require("commander");
+const pkg = require("../package.json");
+const log = require("./utils/logger");
+
+const program = new Command();
+program.name("depkit").description(pkg.description).version(pkg.version);
+
+require("./commands/save")(program);
+require("./commands/use")(program);
+require("./commands/list")(program);
+require("./commands/show")(program);
+
+require("./commands/create")(program);
+require("./commands/add")(program);
+require("./commands/remove")(program);
+require("./commands/update")(program);
+require("./commands/delete")(program);
+
+program.parseAsync(process.argv).catch((err) => {
+  log.error(err.message);
+  process.exit(1);
+});

package/src/utils/args.js

@@ -0,0 +1,25 @@
+const { parseSpec } = require('../core/preset');
+
+// "-D" se pehle likhe packages normal hain, baad ke saare dev hain.
+function splitPackages(packages, devOption, example) {
+  if (devOption === true) {
+    throw new Error(`-D needs package names after it. Example: ${example}`);
+  }
+  const normal = packages;
+  const dev = Array.isArray(devOption) ? devOption : [];
+
+  if (normal.length + dev.length === 0) {
+    throw new Error(`Give at least one package. Example: ${example}`);
+  }
+
+  const normalNames = new Set(normal.map((p) => parseSpec(p).name));
+  for (const d of dev) {
+    const { name } = parseSpec(d);
+    if (normalNames.has(name)) {
+      throw new Error(`"${name}" is listed both before and after -D.`);
+    }
+  }
+  return { normal, dev };
+}
+
+module.exports = { splitPackages };

package/src/utils/logger.js

@@ -0,0 +1,6 @@
+module.exports = {
+  info: (m) => console.log(m),
+  success: (m) => console.log(`✔ ${m}`),
+  warn: (m) => console.warn(`! ${m}`),
+  error: (m) => console.error(`✖ ${m}`),
+};

package/src/utils/prompt.js

@@ -0,0 +1,14 @@
+const prompts = require("prompts");
+
+async function confirm(message) {
+  if (!process.stdin.isTTY) return false;
+  const { ok } = await prompts({
+    type: "confirm",
+    name: "ok",
+    message,
+    initial: false,
+  });
+  return Boolean(ok);
+}
+
+module.exports = { confirm };