@kntic/kntic 0.5.0 → 0.7.0

package/README.md

@@ -1,93 +1,162 @@
-# Control
+# @kntic/kntic
 
+KNTIC CLI — bootstrap and manage KNTIC AI-orchestrated projects.
 
+## Requirements
 
-## Getting started
+- **Node.js** >= 18.0.0
+- **Docker** (with `docker compose` v2) — required for `kntic start` / `kntic stop`
+- **GNU screen** _(optional)_ — needed for `kntic start --screen`
+- **Git** _(optional)_ — enables auto-detection of `GIT_HOST`, `GIT_REPO_PATH`, and `GITLAB_TOKEN` during `kntic init`
 
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
+## Installation
+
+```bash
+npm install -g @kntic/kntic
+```
+
+## Preflight Checks
 
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
+When running `kntic init`, the CLI performs automatic preflight checks before downloading the bootstrap archive. All checks are **warnings only** — they never block execution.
 
-## Add your files
+| Check | Condition | Warning |
+|-------|-----------|---------|
+| **Platform** | `process.platform !== "linux"` | `⚠ Non-Linux detected (<platform>) — KNTIC is designed for Linux, other platforms may have issues` |
+| **Docker** | `docker` binary not found in `$PATH` | `⚠ docker not found — required for \`kntic start\`` |
+| **Screen** | `screen` binary not found in `$PATH` | `⚠ screen not found — optional, needed for \`kntic start --screen\`` |
 
-* [Create](https://docs.gitlab.com/user/project/repository/web_editor/#create-a-file) or [upload](https://docs.gitlab.com/user/project/repository/web_editor/#upload-a-file) files
-* [Add files using the command line](https://docs.gitlab.com/topics/git/add_files/#add-files-to-a-git-repository) or push an existing Git repository with the following command:
+## Commands
 
+### `kntic usage`
+
+List all available sub-commands.
+
+```bash
+kntic usage
 ```
-cd existing_repo
-git remote add origin https://gitlab.kommune7.wien/kntic-ai/orchestrator/control.git
-git branch -M main
-git push -uf origin main
+
+---
+
+### `kntic init`
+
+Download and extract the KNTIC bootstrap template into the current directory. Sets up the `.kntic/` directory structure, `kntic.yml`, and `.kntic.env`.
+
+```bash
+kntic init [--quick | --interactive | -i]
 ```
 
-## Integrate with your tools
+| Option | Description |
+|--------|-------------|
+| `--quick` | **Default.** Non-interactive mode. Auto-detects `GIT_HOST` and `GIT_REPO_PATH` from the git origin remote (SSH and HTTPS). Extracts `GITLAB_TOKEN` from HTTPS credentials if available (`glpat-*` tokens). |
+| `--interactive`, `-i` | Walks through all `.kntic.env` values interactively, prompting for each variable. Auto-detected values are pre-filled as defaults. Skips `KNTIC_VERSION` and already-detected `GITLAB_TOKEN`. |
 
-* [Set up project integrations](https://gitlab.kommune7.wien/kntic-ai/orchestrator/control/-/settings/integrations)
+**What it does:**
 
-## Collaborate with your team
+1. Runs [preflight checks](#preflight-checks)
+2. Fetches version metadata from the bootstrap artifact URL
+3. Downloads and extracts the bootstrap archive (merges `.gitignore` if one already exists)
+4. Appends `KNTIC_VERSION=<version>` to `.kntic.env`
+5. Auto-detects git remote information and fills `GIT_HOST`, `GIT_REPO_PATH`, and `GITLAB_TOKEN`
+6. _(Interactive mode only)_ Prompts for remaining `.kntic.env` values
 
-* [Invite team members and collaborators](https://docs.gitlab.com/user/project/members/)
-* [Create a new merge request](https://docs.gitlab.com/user/project/merge_requests/creating_merge_requests/)
-* [Automatically close issues from merge requests](https://docs.gitlab.com/user/project/issues/managing_issues/#closing-issues-automatically)
-* [Enable merge request approvals](https://docs.gitlab.com/user/project/merge_requests/approvals/)
-* [Set auto-merge](https://docs.gitlab.com/user/project/merge_requests/auto_merge/)
+---
 
-## Test and Deploy
+### `kntic start`
 
-Use the built-in continuous integration in GitLab.
+Build and start KNTIC services via Docker Compose.
 
-* [Get started with GitLab CI/CD](https://docs.gitlab.com/ci/quick_start/)
-* [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/user/application_security/sast/)
-* [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/topics/autodevops/requirements/)
-* [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/user/clusters/agent/)
-* [Set up protected environments](https://docs.gitlab.com/ci/environments/protected_environments/)
+```bash
+kntic start [--screen]
+```
 
-***
+| Option | Description |
+|--------|-------------|
+| `--screen` | Wrap the Docker Compose process in a GNU `screen` session. The session name is read from `KNTIC_PRJ_PREFIX` in `.kntic.env`, falling back to the current directory name. Skipped if already inside a screen session or if `screen` is not available. |
 
-# Editing this README
+Runs:
+```bash
+docker compose -f kntic.yml --env-file .kntic.env up --build
+```
 
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
+---
 
-## Suggestions for a good README
+### `kntic stop`
 
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
+Stop KNTIC services via Docker Compose.
 
-## Name
-Choose a self-explaining name for your project.
+```bash
+kntic stop
+```
 
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
+Runs:
+```bash
+docker compose -f kntic.yml --env-file .kntic.env stop
+```
 
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
+---
 
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
+### `kntic update`
 
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
+Download the latest KNTIC bootstrap archive and update managed files.
+
+```bash
+kntic update [--lib-only] [--compose]
+```
+
+| Option | Description |
+|--------|-------------|
+| `--lib-only` | Update only `.kntic/lib/` (skip ADRs, hooks, and weights). |
+| `--compose` | Also replace `kntic.yml` from the bootstrap template. Creates a backup at `kntic.yml.bak` before overwriting. |
+
+**Default update scope** (without `--lib-only`):
 
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
+| Path | Strategy |
+|------|----------|
+| `.kntic/lib/` | **Replaced** — cleared and re-extracted |
+| `.kntic/adrs/` | **Replaced** — cleared and re-extracted |
+| `.kntic/hooks/gia/internal/` | **Updated** — existing files overwritten, new files added, unlisted files preserved |
+| `.kntic/hooks/gia/specific/` | **Bootstrap only** — extracted only if the directory does not already exist (user customizations are never overwritten) |
+| `.kntic/gia/weights.json` | **Replaced** if present in the archive |
+| `.kntic.env` | **Merged** — new variables from the template are appended with their comments; existing values are never overwritten |
+| `KNTIC_VERSION` | Updated in `.kntic.env` to the latest version |
 
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
+## Environment Variables
 
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
+The `.kntic.env` file contains project configuration:
 
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
+| Variable | Description |
+|----------|-------------|
+| `ANTHROPIC_API_KEY` | API key for Anthropic (used by the orchestrator engine) |
+| `UID` | Host user ID for container user mapping |
+| `GID` | Host group ID for container user mapping |
+| `GITLAB_TOKEN` | GitLab personal access token (`glpat-*`) |
+| `GIT_HOST` | Git server hostname (auto-detected from origin remote) |
+| `GIT_REPO_PATH` | Repository path on the git server (auto-detected from origin remote) |
+| `KNTIC_VERSION` | Bootstrap version (set automatically by `kntic init` / `kntic update`) |
+| `KNTIC_PRJ_PREFIX` | Project prefix used for screen session naming in `kntic start --screen` |
 
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
+## Services
 
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
+Defined in `kntic.yml`:
 
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
+| Service | Container | Image | Port |
+|---------|-----------|-------|------|
+| **Dashboard** | `control-dashboard` | `kntic/dashboard:latest` | `8002` |
+| **Orchestrator** | `control-engine` | `nexus.kommune7.wien/kntic/kntic-engine:latest` | — |
+
+Both services run as `${UID}:${GID}` (non-root) and use `.kntic.env` for environment configuration.
+
+## Testing
+
+```bash
+npm test
+```
+
+Runs tests using the Node.js built-in test runner:
+```bash
+node --test src/**/*.test.js
+```
 
 ## License
-For open source projects, say how it is licensed.
 
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+[MIT](LICENSE)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kntic/kntic",
-  "version": "0.5.0",
+  "version": "0.7.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,160 @@ 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();
+  });
+}
+
+/**
+ * Run preflight checks before downloading the bootstrap archive.
+ * All checks are warnings only — they never throw or exit.
+ * Returns an array of warning strings (empty if all checks pass).
+ */
+function preflightChecks() {
+  const warnings = [];
+
+  // 1. Linux platform check
+  if (process.platform !== "linux") {
+    warnings.push(
+      `⚠  Non-Linux detected (${process.platform}) — KNTIC is designed for Linux, other platforms may have issues`
+    );
+  }
+
+  // 2. docker binary check
+  try {
+    execSync("which docker", { stdio: "ignore" });
+  } catch {
+    warnings.push("⚠  docker not found — required for `kntic start`");
+  }
+
+  // 3. screen binary check
+  try {
+    execSync("which screen", { stdio: "ignore" });
+  } catch {
+    warnings.push("⚠  screen not found — optional, needed for `kntic start --screen`");
+  }
+
+  for (const w of warnings) {
+    console.log(w);
+  }
+
+  return warnings;
+}
+
+async function init(options = {}) {
+  // Run preflight checks before anything else
+  preflightChecks();
+
   // Resolve current version from the artifact metadata file
   const artifactFilename = await fetchText(BOOTSTRAP_ARTIFACT_URL);
   const version = extractVersion(artifactFilename);
@@ -174,9 +328,32 @@ 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;
+module.exports.preflightChecks = preflightChecks;

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, preflightChecks } = require("./init");
 
 /**
  * Helper — create a tar.gz archive in `tmpDir` containing the given files.
@@ -28,6 +28,68 @@ function createTarball(tmpDir, files) {
   return tarball;
 }
 
+describe("preflightChecks", () => {
+  let originalPlatform;
+  let logMessages;
+  let originalLog;
+
+  beforeEach(() => {
+    originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+    originalLog = console.log;
+    logMessages = [];
+    console.log = (...args) => logMessages.push(args.join(" "));
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, "platform", originalPlatform);
+    console.log = originalLog;
+  });
+
+  it("warns when platform is not linux", () => {
+    Object.defineProperty(process, "platform", { value: "darwin", configurable: true });
+    const warnings = preflightChecks();
+    const platformWarning = warnings.find((w) => w.includes("Non-Linux detected"));
+    assert.ok(platformWarning, "should warn about non-linux platform");
+    assert.ok(platformWarning.includes("darwin"));
+  });
+
+  it("does not warn about platform on linux", () => {
+    Object.defineProperty(process, "platform", { value: "linux", configurable: true });
+    const warnings = preflightChecks();
+    const platformWarning = warnings.find((w) => w.includes("Non-Linux detected"));
+    assert.equal(platformWarning, undefined, "should not warn on linux");
+  });
+
+  it("warns when docker is not found", () => {
+    // We test by checking the function handles missing binaries.
+    // On the test system docker may or may not exist, so we check the structure.
+    const warnings = preflightChecks();
+    // Each warning should be a string
+    for (const w of warnings) {
+      assert.equal(typeof w, "string");
+    }
+  });
+
+  it("each warning is independent (all checks run)", () => {
+    Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+    const warnings = preflightChecks();
+    // Platform warning must be present regardless of binary check results
+    const platformWarning = warnings.find((w) => w.includes("Non-Linux detected"));
+    assert.ok(platformWarning, "platform warning must be present");
+    assert.ok(platformWarning.includes("win32"));
+    // All warnings are logged to console
+    assert.equal(logMessages.length, warnings.length, "all warnings must be logged");
+  });
+
+  it("prints warnings to console.log", () => {
+    Object.defineProperty(process, "platform", { value: "freebsd", configurable: true });
+    const warnings = preflightChecks();
+    // At least the platform warning should be logged
+    const platformLog = logMessages.find((m) => m.includes("Non-Linux detected"));
+    assert.ok(platformLog, "platform warning must be printed via console.log");
+  });
+});
+
 describe("extractArchive", () => {
   let tmpDir;
   let destDir;
@@ -126,3 +188,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");