@nkmc/cli 0.0.1

package/dist/chunk-53LSAGFF.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+// src/commands/register.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/credentials.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { chmod } from "fs/promises";
+function nkmcDir() {
+  return process.env.NKMC_HOME || join(homedir(), ".nkmc");
+}
+function credentialsPath() {
+  return join(nkmcDir(), "credentials.json");
+}
+async function loadCredentials() {
+  try {
+    const raw = await readFile(credentialsPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { tokens: {} };
+  }
+}
+async function saveToken(domain, publishToken) {
+  const creds = await loadCredentials();
+  const payloadB64 = publishToken.split(".")[1];
+  const payload = JSON.parse(
+    Buffer.from(payloadB64, "base64url").toString("utf-8")
+  );
+  creds.tokens[domain] = {
+    publishToken,
+    issuedAt: new Date(payload.iat * 1e3).toISOString(),
+    expiresAt: new Date(payload.exp * 1e3).toISOString()
+  };
+  const dir = nkmcDir();
+  await mkdir(dir, { recursive: true });
+  const filePath = credentialsPath();
+  await writeFile(filePath, JSON.stringify(creds, null, 2) + "\n");
+  await chmod(filePath, 384);
+}
+async function getToken(domain) {
+  const creds = await loadCredentials();
+  const entry = creds.tokens[domain];
+  if (!entry) return null;
+  if (new Date(entry.expiresAt).getTime() < Date.now()) {
+    return null;
+  }
+  return entry.publishToken;
+}
+
+// src/commands/register.ts
+async function registerService(options) {
+  const { gatewayUrl, token, domain, skillMdPath } = options;
+  const mdPath = skillMdPath ?? join2(process.cwd(), ".well-known", "skill.md");
+  const skillMd = await readFile2(mdPath, "utf-8");
+  if (!skillMd.trim()) {
+    throw new Error(`skill.md is empty at ${mdPath}`);
+  }
+  const url = `${gatewayUrl.replace(/\/$/, "")}/registry/services?domain=${encodeURIComponent(domain)}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "text/markdown"
+    },
+    body: skillMd
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Registration failed (${res.status}): ${body}`);
+  }
+  const result = await res.json();
+  console.log(`Registered ${result.name} as ${result.domain}`);
+}
+async function resolveToken(options) {
+  if (options.token) return options.token;
+  if (process.env.NKMC_PUBLISH_TOKEN) return process.env.NKMC_PUBLISH_TOKEN;
+  if (options.domain) {
+    const stored = await getToken(options.domain);
+    if (stored) return stored;
+  }
+  if (options.adminToken) {
+    console.warn("Warning: --admin-token is deprecated. Use `nkmc claim` to obtain a publish token.");
+    return options.adminToken;
+  }
+  if (process.env.NKMC_ADMIN_TOKEN) {
+    return process.env.NKMC_ADMIN_TOKEN;
+  }
+  throw new Error(
+    "No auth token found. Use `nkmc claim <domain>` to obtain a publish token, or provide --token."
+  );
+}
+async function runRegister(options) {
+  const projectDir = options.dir ?? process.cwd();
+  const gatewayUrl = options.gatewayUrl ?? process.env.NKMC_GATEWAY_URL;
+  const domain = options.domain ?? process.env.NKMC_DOMAIN;
+  if (!gatewayUrl) {
+    throw new Error(
+      "Gateway URL is required. Use --gateway-url or NKMC_GATEWAY_URL env var."
+    );
+  }
+  if (!domain) {
+    throw new Error(
+      "Domain is required. Use --domain or NKMC_DOMAIN env var."
+    );
+  }
+  const token = await resolveToken({
+    token: options.token,
+    adminToken: options.adminToken,
+    domain
+  });
+  await registerService({
+    gatewayUrl,
+    token,
+    domain,
+    skillMdPath: join2(projectDir, ".well-known", "skill.md")
+  });
+}
+
+export {
+  saveToken,
+  registerService,
+  resolveToken,
+  runRegister
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,540 @@
+#!/usr/bin/env node
+import {
+  runRegister,
+  saveToken
+} from "./chunk-53LSAGFF.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/scanner/detect.ts
+import { readFile, access } from "fs/promises";
+import { join } from "path";
+import { detectFrameworkFromDeps } from "@nkmc/core/scanner";
+var FRAMEWORK_MAP = {
+  hono: "hono",
+  next: "nextjs",
+  express: "express",
+  fastify: "fastify"
+};
+async function detectFramework(projectDir) {
+  const pkgPath = join(projectDir, "package.json");
+  const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const detected = detectFrameworkFromDeps(allDeps);
+  const framework = detected ? FRAMEWORK_MAP[detected] ?? "unknown" : "unknown";
+  let orm = "none";
+  let ormSchemaPath;
+  if (allDeps["prisma"] || allDeps["@prisma/client"]) {
+    const schemaPath = "prisma/schema.prisma";
+    try {
+      await access(join(projectDir, schemaPath));
+      orm = "prisma";
+      ormSchemaPath = schemaPath;
+    } catch {
+      orm = "prisma";
+    }
+  } else if (allDeps["drizzle-orm"]) {
+    orm = "drizzle";
+    try {
+      await access(join(projectDir, "drizzle.config.ts"));
+      ormSchemaPath = "drizzle.config.ts";
+    } catch {
+    }
+  }
+  return { framework, orm, ormSchemaPath };
+}
+
+// src/commands/init.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+function generateConfig(options) {
+  const { name, version, roles, detected } = options;
+  const rolesStr = roles.map((r) => `"${r}"`).join(", ");
+  const lines = [
+    `import { defineConfig } from "@nkmc/core";`,
+    ``,
+    `export default defineConfig({`,
+    `  name: "${name}",`,
+    `  version: "${version}",`,
+    `  roles: [${rolesStr}],`,
+    `  framework: "${detected.framework}",`
+  ];
+  if (detected.orm !== "none") {
+    lines.push(`  orm: "${detected.orm}",`);
+    if (detected.ormSchemaPath) {
+      lines.push(`  schemaPath: "${detected.ormSchemaPath}",`);
+    }
+  }
+  lines.push(
+    `  pricing: {`,
+    `    // "POST /api/example": { cost: 0.01, token: "USDC" },`,
+    `  },`,
+    `});`,
+    ``
+  );
+  return lines.join("\n");
+}
+async function runInit(projectDir) {
+  const detected = await detectFramework(projectDir);
+  console.log(`Detected framework: ${detected.framework}`);
+  console.log(`Detected ORM: ${detected.orm}`);
+  const pkgPath = join2(projectDir, "package.json");
+  const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
+  const name = pkg.name || "my-service";
+  const config = generateConfig({
+    name,
+    version: "1.0",
+    roles: ["agent"],
+    detected
+  });
+  const configPath = join2(projectDir, "nkmc.config.ts");
+  await writeFile(configPath, config);
+  console.log(`Created ${configPath}`);
+}
+
+// src/commands/generate.ts
+import { readFile as readFile4, writeFile as writeFile2, mkdir } from "fs/promises";
+import { join as join4 } from "path";
+import { generateSkillMd } from "@nkmc/core";
+
+// src/scanner/routes.ts
+import { Project, SyntaxKind } from "ts-morph";
+import { join as join3, relative, dirname } from "path";
+import { readdir } from "fs/promises";
+var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete"]);
+async function scanRoutes(projectDir, framework) {
+  if (framework === "nextjs") {
+    return scanNextjsRoutes(projectDir);
+  }
+  return scanCodeRoutes(projectDir);
+}
+async function scanCodeRoutes(projectDir) {
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  const srcFiles = await findTsFiles(projectDir);
+  for (const filePath of srcFiles) {
+    project.addSourceFileAtPath(filePath);
+  }
+  const routes = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const call of calls) {
+      const route = extractRouteFromCall(call, projectDir);
+      if (route) routes.push(route);
+    }
+  }
+  return routes;
+}
+function extractRouteFromCall(call, projectDir) {
+  const expr = call.getExpression();
+  if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) return null;
+  const propAccess = expr.asKind(SyntaxKind.PropertyAccessExpression);
+  if (!propAccess) return null;
+  const methodName = propAccess.getName().toLowerCase();
+  if (!HTTP_METHODS.has(methodName)) return null;
+  const args = call.getArguments();
+  if (args.length < 1) return null;
+  const firstArg = args[0];
+  if (firstArg.getKind() !== SyntaxKind.StringLiteral) return null;
+  const path = firstArg.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+  if (!path) return null;
+  const description = extractLeadingComment(call);
+  const filePath = relative(projectDir, call.getSourceFile().getFilePath());
+  return {
+    method: methodName.toUpperCase(),
+    path,
+    filePath,
+    description
+  };
+}
+function extractLeadingComment(call) {
+  const statement = call.getFirstAncestorByKind(SyntaxKind.ExpressionStatement);
+  if (!statement) return void 0;
+  const leadingComments = statement.getLeadingCommentRanges();
+  if (leadingComments.length === 0) return void 0;
+  const comment = leadingComments[leadingComments.length - 1].getText();
+  const match = comment.match(/\/\*\*\s*(.*?)\s*\*\//s);
+  if (match) return match[1].replace(/\s*\*\s*/g, " ").trim();
+  const singleMatch = comment.match(/\/\/\s*(.*)/);
+  if (singleMatch) return singleMatch[1].trim();
+  return void 0;
+}
+async function scanNextjsRoutes(projectDir) {
+  const routes = [];
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  const routeFiles = await findFiles(projectDir, /\broute\.(ts|js)$/);
+  for (const filePath of routeFiles) {
+    const relPath = relative(projectDir, filePath);
+    const urlPath = "/" + dirname(relPath).replace(/^app\//, "");
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    for (const fn of sourceFile.getFunctions()) {
+      if (!fn.isExported()) continue;
+      const name = fn.getName()?.toUpperCase();
+      if (name && HTTP_METHODS.has(name.toLowerCase())) {
+        const jsDocs = fn.getJsDocs();
+        const description = jsDocs.length > 0 ? jsDocs[0].getDescription().trim() : void 0;
+        routes.push({
+          method: name,
+          path: urlPath,
+          filePath: relPath,
+          description: description || void 0
+        });
+      }
+    }
+  }
+  return routes;
+}
+async function findTsFiles(dir) {
+  return findFiles(dir, /\.(ts|tsx|js|jsx)$/);
+}
+async function findFiles(dir, pattern) {
+  const results = [];
+  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".next", "dist", "build", ".git"]);
+  async function walk(current) {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP.has(entry.name)) continue;
+      const fullPath = join3(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (pattern.test(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return results;
+}
+
+// src/scanner/schema.ts
+import { readFile as readFile3 } from "fs/promises";
+import { getSchema } from "@mrleebo/prisma-ast";
+async function scanPrismaSchema(schemaPath) {
+  const content = await readFile3(schemaPath, "utf-8");
+  const ast = getSchema(content);
+  const tables = [];
+  let pendingTopComment = "";
+  for (const block of ast.list) {
+    if (block.type === "comment") {
+      pendingTopComment = block.text.replace(/^\/\/\/?\s*/, "").trim();
+      continue;
+    }
+    if (block.type !== "model") {
+      pendingTopComment = "";
+      continue;
+    }
+    const fields = [];
+    let prevComment = "";
+    for (const prop of block.properties) {
+      if (prop.type === "comment") {
+        prevComment = (prop.text || "").replace(/^\/\/\/?\s*/, "").trim();
+        continue;
+      }
+      if (prop.type === "field") {
+        fields.push({
+          name: prop.name,
+          type: typeof prop.fieldType === "string" ? prop.fieldType : String(prop.fieldType),
+          description: prevComment
+        });
+        prevComment = "";
+        continue;
+      }
+      if (prop.type !== "break") {
+        prevComment = "";
+      }
+    }
+    tables.push({
+      name: block.name,
+      description: pendingTopComment,
+      fields
+    });
+    pendingTopComment = "";
+  }
+  return tables;
+}
+
+// src/commands/generate.ts
+function buildSkillDefinition(config, routes, schemas) {
+  const api = routes.map((route) => {
+    const pricingKey = `${route.method} ${route.path}`;
+    const pricing = config.pricing?.[pricingKey];
+    return {
+      method: route.method,
+      path: route.path,
+      role: "agent",
+      description: route.description || `${route.method} ${route.path}`,
+      ...pricing ? { pricing } : {}
+    };
+  });
+  const schema = schemas.map((s) => ({
+    name: s.name,
+    description: s.description || `${s.name} table`,
+    read: "agent",
+    write: "agent",
+    fields: s.fields.map((f) => ({
+      name: f.name,
+      type: f.type,
+      description: f.description || ""
+    }))
+  }));
+  return {
+    frontmatter: {
+      name: config.name,
+      gateway: "nkmc",
+      version: config.version,
+      roles: config.roles
+    },
+    description: `${config.name} \u2014 powered by nkmc.`,
+    schema,
+    api
+  };
+}
+async function runGenerate(projectDir, options) {
+  const detected = await detectFramework(projectDir);
+  console.log(`Detected: ${detected.framework} + ${detected.orm}`);
+  const routes = await scanRoutes(projectDir, detected.framework);
+  console.log(`Found ${routes.length} routes`);
+  let schemas = [];
+  if (detected.orm === "prisma" && detected.ormSchemaPath) {
+    schemas = await scanPrismaSchema(join4(projectDir, detected.ormSchemaPath));
+    console.log(`Found ${schemas.length} models`);
+  }
+  const pkg = JSON.parse(await readFile4(join4(projectDir, "package.json"), "utf-8"));
+  const config = {
+    name: pkg.name || "my-service",
+    version: "1.0",
+    roles: ["agent"],
+    framework: detected.framework,
+    orm: detected.orm !== "none" ? detected.orm : void 0
+  };
+  const skill = buildSkillDefinition(config, routes, schemas);
+  const md = generateSkillMd(skill);
+  const outputDir = join4(projectDir, ".well-known");
+  await mkdir(outputDir, { recursive: true });
+  const outputPath = join4(outputDir, "skill.md");
+  await writeFile2(outputPath, md);
+  console.log(`Generated ${outputPath}`);
+  if (options?.register) {
+    const { registerService, resolveToken } = await import("./register-GWQ2Z2YL.js");
+    const gatewayUrl = options.gatewayUrl ?? process.env.NKMC_GATEWAY_URL;
+    const domain = options.domain ?? process.env.NKMC_DOMAIN;
+    if (!gatewayUrl || !domain) {
+      console.log(
+        "Skipping registration: --gateway-url and --domain are required."
+      );
+      return;
+    }
+    const token = await resolveToken({
+      token: options.token,
+      adminToken: options.adminToken,
+      domain
+    });
+    await registerService({
+      gatewayUrl,
+      token,
+      domain,
+      skillMdPath: outputPath
+    });
+  }
+}
+
+// src/commands/claim.ts
+async function runClaim(options) {
+  const { gatewayUrl, domain, verify } = options;
+  const baseUrl = gatewayUrl.replace(/\/$/, "");
+  if (verify) {
+    await verifyClaim(baseUrl, domain);
+  } else {
+    await requestChallenge(baseUrl, domain);
+  }
+}
+async function requestChallenge(baseUrl, domain) {
+  const res = await fetch(`${baseUrl}/domains/challenge`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ domain })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Challenge request failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  const expires = new Date(data.expiresAt).toISOString();
+  console.log(`
+Domain claim initiated for ${data.domain}
+`);
+  console.log(`Add the following DNS TXT record:
+`);
+  console.log(`  Name:  ${data.txtRecord}`);
+  console.log(`  Value: ${data.txtValue}
+`);
+  console.log(`This challenge expires at ${expires}.
+`);
+  console.log(`After adding the record, verify with:`);
+  console.log(`  nkmc claim ${domain} --verify
+`);
+  console.log(`Tip: You can check propagation with:`);
+  console.log(`  dig TXT ${data.txtRecord}`);
+}
+async function verifyClaim(baseUrl, domain) {
+  const res = await fetch(`${baseUrl}/domains/verify`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ domain })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    const error = data.error || "Verification failed";
+    console.error(`
+Verification failed: ${error}
+`);
+    console.log(`Troubleshooting:`);
+    console.log(`  1. Check the record exists: dig TXT _nkmc.${domain}`);
+    console.log(`  2. DNS propagation can take up to 5 minutes`);
+    console.log(`  3. Ensure the TXT value matches exactly (including "nkmc-verify=" prefix)
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const publishToken = data.publishToken;
+  await saveToken(domain, publishToken);
+  console.log(`
+Domain ${domain} verified successfully!`);
+  console.log(`Publish token saved to ~/.nkmc/credentials.json
+`);
+  console.log(`You can now register services:`);
+  console.log(`  nkmc register --domain ${domain}`);
+}
+
+// src/gateway/client.ts
+var GatewayClient = class {
+  constructor(gatewayUrl, token) {
+    this.gatewayUrl = gatewayUrl;
+    this.token = token;
+  }
+  async execute(command) {
+    const url = `${this.gatewayUrl.replace(/\/$/, "")}/execute`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ command })
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Gateway error ${res.status}: ${body}`);
+    }
+    return res.json();
+  }
+};
+function createClient() {
+  const gatewayUrl = process.env.NKMC_GATEWAY_URL;
+  const token = process.env.NKMC_TOKEN;
+  if (!gatewayUrl) throw new Error("NKMC_GATEWAY_URL is required");
+  if (!token) throw new Error("NKMC_TOKEN is required");
+  return new GatewayClient(gatewayUrl, token);
+}
+
+// src/commands/fs.ts
+function output(result) {
+  console.log(JSON.stringify(result));
+}
+function handleError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(JSON.stringify({ error: message }));
+  process.exit(1);
+}
+function registerFsCommands(program2) {
+  program2.command("ls").description("List files in a directory").argument("<path>", "Directory path").action(async (path) => {
+    try {
+      const client = createClient();
+      const result = await client.execute(`ls ${path}`);
+      output(result);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("cat").description("Read file contents").argument("<path>", "File path").action(async (path) => {
+    try {
+      const client = createClient();
+      const result = await client.execute(`cat ${path}`);
+      output(result);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("write").description("Write data to a file").argument("<path>", "File path").argument("<data>", "Data to write").action(async (path, data) => {
+    try {
+      const client = createClient();
+      const result = await client.execute(`write ${path} ${data}`);
+      output(result);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("rm").description("Remove a file").argument("<path>", "File path").action(async (path) => {
+    try {
+      const client = createClient();
+      const result = await client.execute(`rm ${path}`);
+      output(result);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("grep").description("Search file contents").argument("<pattern>", "Search pattern").argument("<path>", "File or directory path").action(async (pattern, path) => {
+    try {
+      const client = createClient();
+      const result = await client.execute(`grep ${pattern} ${path}`);
+      output(result);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("nkmc").description("nkmc SDK CLI").version("0.1.0");
+program.command("init").description("Initialize nkmc in the current project").argument("[dir]", "Project directory", ".").action(async (dir) => {
+  const projectDir = dir === "." ? process.cwd() : dir;
+  await runInit(projectDir);
+});
+program.command("generate").description("Scan project and generate skill.md").argument("[dir]", "Project directory", ".").option("--register", "Register the service with the gateway after generating").option("--gateway-url <url>", "Gateway URL for registration").option("--token <token>", "Auth token for registration (publish token or admin token)").option("--admin-token <token>", "Admin token for registration (deprecated, use --token)").option("--domain <domain>", "Domain name for the service").action(async (dir, opts) => {
+  const projectDir = dir === "." ? process.cwd() : dir;
+  await runGenerate(projectDir, {
+    register: opts.register,
+    gatewayUrl: opts.gatewayUrl,
+    token: opts.token,
+    adminToken: opts.adminToken,
+    domain: opts.domain
+  });
+});
+program.command("claim <domain>").description("Claim domain ownership via DNS verification").option("--verify", "Verify DNS record and obtain publish token").option("--gateway-url <url>", "Gateway URL").action(async (domain, opts) => {
+  const gatewayUrl = opts.gatewayUrl ?? process.env.NKMC_GATEWAY_URL;
+  if (!gatewayUrl) {
+    throw new Error(
+      "Gateway URL is required. Use --gateway-url or NKMC_GATEWAY_URL env var."
+    );
+  }
+  await runClaim({
+    gatewayUrl,
+    domain,
+    verify: opts.verify
+  });
+});
+program.command("register").description("Register skill.md with the gateway").option("--gateway-url <url>", "Gateway URL").option("--token <token>", "Auth token (publish token or admin token)").option("--admin-token <token>", "Admin token (deprecated, use --token)").option("--domain <domain>", "Domain name for the service").option("--dir <dir>", "Project directory", ".").action(async (opts) => {
+  await runRegister({
+    gatewayUrl: opts.gatewayUrl,
+    token: opts.token,
+    adminToken: opts.adminToken,
+    domain: opts.domain,
+    dir: opts.dir === "." ? process.cwd() : opts.dir
+  });
+});
+registerFsCommands(program);
+program.parse();

package/dist/register-GWQ2Z2YL.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  registerService,
+  resolveToken,
+  runRegister
+} from "./chunk-53LSAGFF.js";
+export {
+  registerService,
+  resolveToken,
+  runRegister
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@nkmc/cli",
+  "version": "0.0.1",
+  "description": "CLI for scanning and registering APIs with the nkmc gateway",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "nkmc": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "@mrleebo/prisma-ast": "^0.13.1",
+    "@nkmc/core": "workspace:^",
+    "commander": "^13.0.0",
+    "ts-morph": "^27.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chekusu/nkmc-sdk.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ]
+}