deepstrike 0.1.0 → 2.0.0

package/dist/cli.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { promises as fs } from "fs";
+import path from "path";
+
+// src/fs/common.ts
+var formatEnvironmentFileName = (environment) => {
+  const fsSafeEnvironment = environment.replace(/[^a-zA-Z0-9-_]/g, "_").toLowerCase();
+  return `.secrets.${fsSafeEnvironment}.json`;
+};
+var BASE_PATH = "./.deepstrike";
+var TEMPLATE_FILE_NAME = formatEnvironmentFileName("env");
+
+// src/cli.ts
+var deepstrikeDirName = BASE_PATH;
+var envTemplateFileName = TEMPLATE_FILE_NAME;
+var getProjectRoot = () => process.cwd();
+var getDeepstrikeDir = () => path.join(getProjectRoot(), deepstrikeDirName);
+var getEnvTemplatePath = () => path.join(getDeepstrikeDir(), envTemplateFileName);
+var getEnvironmentSecretsPath = (environmentName) => path.join(getDeepstrikeDir(), formatEnvironmentFileName(environmentName));
+var ensureDir = async (directoryPath) => {
+  await fs.mkdir(directoryPath, { recursive: true });
+};
+var fileExists = async (filePath) => {
+  try {
+    await fs.stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var writeJsonIfMissing = async (filePath, data) => {
+  if (await fileExists(filePath))
+    return false;
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2) + `
+`, "utf8");
+  return true;
+};
+var writeJsonOverwrite = async (filePath, data) => {
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2) + `
+`, "utf8");
+};
+var appendGitignoreRules = async (projectRoot) => {
+  const gitignorePath = path.join(projectRoot, ".gitignore");
+  const rules = [".deepstrike/.secrets.*.json", "!.deepstrike/.secrets.env.json"];
+  let existing = "";
+  if (await fileExists(gitignorePath)) {
+    existing = await fs.readFile(gitignorePath, "utf8");
+  }
+  const normalized = existing.replace(/\r\n/g, `
+`);
+  const missingRules = rules.filter((rule) => !new RegExp(`^${escapeRegex(rule)}$`, "m").test(normalized));
+  if (missingRules.length === 0)
+    return false;
+  const needsLeadingNewline = normalized.length > 0 && !normalized.endsWith(`
+`);
+  const block = (needsLeadingNewline ? `
+` : "") + missingRules.join(`
+`) + `
+`;
+  await fs.writeFile(gitignorePath, normalized + block, "utf8");
+  return true;
+};
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var getTemplateData = () => ({
+  projectName: "MyProject",
+  secretStoreName: "MyAkv",
+  connectionData: {
+    subscriptionId: "your-subscription-id",
+    tenantId: "your-tenant-id"
+  },
+  environment: {
+    name: "Template",
+    secretFileVersion: "latest"
+  },
+  secretNames: ["DatabasePassword", "ApiKey"]
+});
+var printHelp = () => {
+  const text = `deepstrike
+
+Usage:
+  deepstrike init
+  deepstrike create <environment>
+  deepstrike push <environment>
+  deepstrike pull <environment>
+
+Notes:
+  Config directory: ./${deepstrikeDirName}
+  Template file:     ./${deepstrikeDirName}/${envTemplateFileName}
+  Env file pattern:  ./${deepstrikeDirName}/.secrets.<environment>.json
+`;
+  process.stdout.write(text);
+};
+var initCommand = async () => {
+  const projectRoot = getProjectRoot();
+  const deepstrikeDir = getDeepstrikeDir();
+  const templatePath = getEnvTemplatePath();
+  await ensureDir(deepstrikeDir);
+  const wroteTemplate = await writeJsonIfMissing(templatePath, getTemplateData());
+  const updatedGitignore = await appendGitignoreRules(projectRoot);
+  const lines = [];
+  lines.push("Deepstrike initialized.");
+  lines.push(`Directory: ${deepstrikeDirName}`);
+  lines.push(`Template: ${path.relative(projectRoot, templatePath)}`);
+  lines.push(wroteTemplate ? "Template file created." : "Template file already exists.");
+  lines.push(updatedGitignore ? ".gitignore updated." : ".gitignore already up to date.");
+  lines.push("Next: deepstrike create <environment>");
+  process.stdout.write(lines.join(`
+`) + `
+`);
+};
+var createCommand = async (environmentRaw) => {
+  const environmentName = formatEnvironmentFileName(environmentRaw);
+  const deepstrikeDir = getDeepstrikeDir();
+  const targetPath = getEnvironmentSecretsPath(environmentName);
+  await ensureDir(deepstrikeDir);
+  if (await fileExists(targetPath)) {
+    process.stdout.write(`File already exists: ${path.relative(getProjectRoot(), targetPath)}
+`);
+    return;
+  }
+  const template = getTemplateData();
+  const envData = {
+    ...template,
+    environment: {
+      name: environmentName,
+      secretFileVersion: "latest"
+    }
+  };
+  await writeJsonOverwrite(targetPath, envData);
+  process.stdout.write(`Created: ${path.relative(getProjectRoot(), targetPath)}
+`);
+  process.stdout.write(`Edit the file, then run: deepstrike push <environment>
+`);
+};
+var pushCommand = async (environmentRaw) => {
+  const environmentName = formatEnvironmentFileName(environmentRaw);
+  const filePath = getEnvironmentSecretsPath(environmentName);
+  if (!await fileExists(filePath)) {
+    throw new Error(`Missing environment file: ${path.relative(getProjectRoot(), filePath)}`);
+  }
+  throw new Error("push is not implemented yet");
+};
+var pullCommand = async (environmentRaw) => {
+  const environmentName = formatEnvironmentFileName(environmentRaw);
+  const filePath = getEnvironmentSecretsPath(environmentName);
+  throw new Error("pull is not implemented yet");
+};
+var main = async () => {
+  const [, , command, ...args] = process.argv;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  if (command === "init") {
+    await initCommand();
+    return;
+  }
+  if (command === "create") {
+    const environment = args[0];
+    if (!environment)
+      throw new Error("create requires <environment>");
+    await createCommand(environment);
+    return;
+  }
+  if (command === "push") {
+    const environment = args[0];
+    if (!environment)
+      throw new Error("push requires <environment>");
+    await pushCommand(environment);
+    return;
+  }
+  if (command === "pull") {
+    const environment = args[0];
+    if (!environment)
+      throw new Error("pull requires <environment>");
+    await pullCommand(environment);
+    return;
+  }
+  throw new Error(`Unknown command: ${command}`);
+};
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+});