@kntic/kntic 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kntic/kntic",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "author": "Thomas Robak <contact@kntic.ai> (https://kntic.ai)",
   "description": "KNTIC CLI — bootstrap and manage KNTIC projects",
   "main": "src/index.js",

package/src/cli.js

@@ -10,7 +10,8 @@ const subcommand = args[0];
 if (!subcommand || subcommand === "usage") {
   commands.usage();
 } else if (subcommand === "init") {
-  commands.init().catch((err) => {
+  const initOpts = { interactive: args.includes("--interactive") || args.includes("-i") };
+  commands.init(initOpts).catch((err) => {
     console.error(`Error: ${err.message}`);
     process.exit(1);
   });

package/src/commands/init.js

@@ -6,6 +6,7 @@ const { execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
+const readline = require("readline");
 
 const BOOTSTRAP_ARTIFACT_URL =
   "https://minio.kommune7.wien/public/kntic-bootstrap-latest.artifact";
@@ -155,7 +156,121 @@ function extractArchive(tarball, destDir) {
   }
 }
 
-async function init() {
+/**
+ * Parse the git origin remote URL to extract host and repo path.
+ * Returns { host, repoPath } or null if not available.
+ */
+function parseGitRemote() {
+  try {
+    if (!fs.existsSync('.git')) return null;
+    const output = execSync('git remote -v', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+    const fetchLine = output.split('\n').find(l => l.startsWith('origin') && l.includes('(fetch)'));
+    if (!fetchLine) return null;
+    const url = fetchLine.split(/\s+/)[1];
+    // SSH format: git@host:path
+    const sshMatch = url.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+    if (sshMatch) return { host: sshMatch[1], repoPath: sshMatch[2] + '.git' };
+    // HTTPS with credentials: https://user:token@host/path.git
+    const httpsMatch = url.match(/^https?:\/\/(?:([^@]+)@)?([^/]+)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) {
+      const result = { host: httpsMatch[2], repoPath: httpsMatch[3] + '.git' };
+      // Extract glpat token from credentials (format: oauth2:glpat-xxx or just glpat-xxx)
+      if (httpsMatch[1]) {
+        const credParts = httpsMatch[1].split(':');
+        const token = credParts.find(p => p.startsWith('glpat-'));
+        if (token) result.gitlabToken = token;
+      }
+      return result;
+    }
+    return null;
+  } catch { return null; }
+}
+
+/**
+ * Read an env file, replace values for given keys (or append if missing),
+ * and write back.
+ */
+function fillEnvValues(envPath, values) {
+  let content = fs.readFileSync(envPath, 'utf8');
+  for (const [key, val] of Object.entries(values)) {
+    const regex = new RegExp(`^(${key}=).*$`, 'm');
+    if (regex.test(content)) {
+      content = content.replace(regex, `$1${val}`);
+    } else {
+      // Key missing from file — append it
+      content = content.trimEnd() + `\n${key}=${val}\n`;
+    }
+  }
+  fs.writeFileSync(envPath, content);
+}
+
+/**
+ * Interactively prompt the user for each env variable in the file.
+ * Skips KNTIC_VERSION. Shows current value as default.
+ */
+function interactiveEnvSetup(envPath) {
+  return new Promise((resolve) => {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const lines = content.split('\n');
+
+    // Collect KEY=VALUE entries to prompt for
+    const entries = [];
+    for (let i = 0; i < lines.length; i++) {
+      const match = lines[i].match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+      if (match) {
+        const key = match[1];
+        if (key === 'KNTIC_VERSION') continue;
+        // Also skip GITLAB_TOKEN if already auto-filled with a real token
+        if (key === 'GITLAB_TOKEN' && match[2].startsWith('glpat-')) continue;
+        entries.push({ index: i, key, value: match[2] });
+      }
+    }
+
+    if (entries.length === 0) {
+      resolve();
+      return;
+    }
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const updatedValues = {};
+    let idx = 0;
+
+    function promptNext() {
+      if (idx >= entries.length) {
+        rl.close();
+        // Write updated values back
+        const newLines = [...lines];
+        for (const entry of entries) {
+          const finalVal = updatedValues[entry.key] !== undefined
+            ? updatedValues[entry.key]
+            : entry.value;
+          newLines[entry.index] = `${entry.key}=${finalVal}`;
+        }
+        fs.writeFileSync(envPath, newLines.join('\n'));
+        resolve();
+        return;
+      }
+
+      const entry = entries[idx];
+      const displayVal = entry.value || '';
+      rl.question(`  ${entry.key} [${displayVal}]: `, (answer) => {
+        if (answer.length > 0) {
+          updatedValues[entry.key] = answer;
+        }
+        idx++;
+        promptNext();
+      });
+    }
+
+    promptNext();
+  });
+}
+
+async function init(options = {}) {
   // Resolve current version from the artifact metadata file
   const artifactFilename = await fetchText(BOOTSTRAP_ARTIFACT_URL);
   const version = extractVersion(artifactFilename);
@@ -174,9 +289,31 @@ async function init() {
   // Clean up
   fs.unlinkSync(tmpFile);
 
+  // Auto-detect git remote
+  const gitInfo = parseGitRemote();
+
+  // Auto-fill git values (both modes)
+  const autoValues = {};
+  if (gitInfo) {
+    autoValues.GIT_HOST = gitInfo.host;
+    autoValues.GIT_REPO_PATH = gitInfo.repoPath;
+    if (gitInfo.gitlabToken) {
+      autoValues.GITLAB_TOKEN = gitInfo.gitlabToken;
+    }
+  }
+  if (Object.keys(autoValues).length > 0) {
+    fillEnvValues('.kntic.env', autoValues);
+  }
+
+  if (options.interactive) {
+    await interactiveEnvSetup('.kntic.env');
+  }
+
   console.log("Done. KNTIC project bootstrapped successfully.");
 }
 
 module.exports = init;
 module.exports.extractArchive = extractArchive;
 module.exports.extractVersion = extractVersion;
+module.exports.parseGitRemote = parseGitRemote;
+module.exports.fillEnvValues = fillEnvValues;

package/src/commands/init.test.js

@@ -7,7 +7,7 @@ const path = require("path");
 const os = require("os");
 const { execSync } = require("child_process");
 
-const { extractArchive, extractVersion } = require("./init");
+const { extractArchive, extractVersion, parseGitRemote, fillEnvValues } = require("./init");
 
 /**
  * Helper — create a tar.gz archive in `tmpDir` containing the given files.
@@ -126,3 +126,136 @@ describe("extractVersion", () => {
     assert.throws(() => extractVersion("no-version-here.tar.gz"));
   });
 });
+
+describe("parseGitRemote", () => {
+  let tmpDir;
+  let originalCwd;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "kntic-git-test-"));
+    originalCwd = process.cwd();
+    process.chdir(tmpDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("parses SSH remote", () => {
+    execSync("git init", { stdio: "pipe" });
+    execSync("git remote add origin git@gitlab.kommune7.wien:kntic-ai/orchestrator/control.git", { stdio: "pipe" });
+    const result = parseGitRemote();
+    assert.deepStrictEqual(result, {
+      host: "gitlab.kommune7.wien",
+      repoPath: "kntic-ai/orchestrator/control.git",
+    });
+  });
+
+  it("parses HTTPS remote", () => {
+    execSync("git init", { stdio: "pipe" });
+    execSync("git remote add origin https://github.com/org/repo.git", { stdio: "pipe" });
+    const result = parseGitRemote();
+    assert.deepStrictEqual(result, {
+      host: "github.com",
+      repoPath: "org/repo.git",
+    });
+  });
+
+  it("returns null when no .git dir", () => {
+    const result = parseGitRemote();
+    assert.equal(result, null);
+  });
+
+  it("returns null when no origin remote", () => {
+    execSync("git init", { stdio: "pipe" });
+    const result = parseGitRemote();
+    assert.equal(result, null);
+  });
+
+  it("parses HTTPS remote with embedded glpat token", () => {
+    execSync("git init", { stdio: "pipe" });
+    execSync("git remote add origin https://oauth2:glpat-abc123@gitlab.kommune7.wien/org/repo.git", { stdio: "pipe" });
+    const result = parseGitRemote();
+    assert.deepStrictEqual(result, {
+      host: "gitlab.kommune7.wien",
+      repoPath: "org/repo.git",
+      gitlabToken: "glpat-abc123",
+    });
+  });
+
+  it("HTTPS without credentials returns no gitlabToken", () => {
+    execSync("git init", { stdio: "pipe" });
+    execSync("git remote add origin https://github.com/org/repo.git", { stdio: "pipe" });
+    const result = parseGitRemote();
+    assert.equal(result.host, "github.com");
+    assert.equal(result.repoPath, "org/repo.git");
+    assert.equal(result.gitlabToken, undefined);
+  });
+
+  it("HTTPS with non-glpat credentials returns no gitlabToken", () => {
+    execSync("git init", { stdio: "pipe" });
+    execSync("git remote add origin https://user:password@github.com/org/repo.git", { stdio: "pipe" });
+    const result = parseGitRemote();
+    assert.equal(result.host, "github.com");
+    assert.equal(result.repoPath, "org/repo.git");
+    assert.equal(result.gitlabToken, undefined);
+  });
+});
+
+describe("fillEnvValues", () => {
+  let tmpDir;
+  let envPath;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "kntic-env-test-"));
+    envPath = path.join(tmpDir, ".kntic.env");
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("replaces existing key", () => {
+    fs.writeFileSync(envPath, "GIT_HOST=\nGIT_REPO_PATH=\n");
+    fillEnvValues(envPath, { GIT_HOST: "gitlab.kommune7.wien" });
+    const content = fs.readFileSync(envPath, "utf8");
+    assert.ok(content.includes("GIT_HOST=gitlab.kommune7.wien"));
+  });
+
+  it("appends missing key", () => {
+    fs.writeFileSync(envPath, "GIT_REPO_PATH=some/path.git\n");
+    fillEnvValues(envPath, { GIT_HOST: "gitlab.kommune7.wien" });
+    const content = fs.readFileSync(envPath, "utf8");
+    assert.ok(content.includes("GIT_HOST=gitlab.kommune7.wien"));
+    assert.ok(content.includes("GIT_REPO_PATH=some/path.git"));
+  });
+
+  it("preserves other lines and comments", () => {
+    fs.writeFileSync(envPath, "# This is a comment\nAPI_KEY=abc123\nGIT_HOST=\n# Another comment\n");
+    fillEnvValues(envPath, { GIT_HOST: "example.com" });
+    const content = fs.readFileSync(envPath, "utf8");
+    assert.ok(content.includes("# This is a comment"));
+    assert.ok(content.includes("API_KEY=abc123"));
+    assert.ok(content.includes("GIT_HOST=example.com"));
+    assert.ok(content.includes("# Another comment"));
+  });
+
+  it("handles multiple replacements", () => {
+    fs.writeFileSync(envPath, "GIT_HOST=\nGIT_REPO_PATH=\n");
+    fillEnvValues(envPath, {
+      GIT_HOST: "gitlab.kommune7.wien",
+      GIT_REPO_PATH: "kntic-ai/orchestrator/control.git",
+    });
+    const content = fs.readFileSync(envPath, "utf8");
+    assert.ok(content.includes("GIT_HOST=gitlab.kommune7.wien"));
+    assert.ok(content.includes("GIT_REPO_PATH=kntic-ai/orchestrator/control.git"));
+  });
+
+  it("fills GITLAB_TOKEN from git remote", () => {
+    fs.writeFileSync(envPath, "GITLAB_TOKEN=***\nGIT_HOST=\n");
+    fillEnvValues(envPath, { GITLAB_TOKEN: "glpat-abc123" });
+    const content = fs.readFileSync(envPath, "utf8");
+    assert.ok(content.includes("GITLAB_TOKEN=glpat-abc123"));
+  });
+});

package/src/commands/usage.js

@@ -6,6 +6,8 @@ function usage() {
   console.log("Available commands:\n");
   console.log("  usage    List all available sub-commands");
   console.log("  init     Download and extract the KNTIC bootstrap template into the current directory");
+  console.log("             --quick         Default mode — non-interactive, auto-detects git remote");
+  console.log("             --interactive   Walk through .kntic.env values interactively (-i)");
   console.log("  start    Build and start KNTIC services via docker compose (uses kntic.yml + .kntic.env)");
   console.log("             --screen   Run inside a GNU screen session");
   console.log("  stop     Stop KNTIC services via docker compose");