@tiqora/tiqora 0.0.2-dev

package/dist/index.mjs

@@ -0,0 +1,1565 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve7 } from "path";
+
+// src/commands/init.ts
+import { cancel as cancel3, isCancel as isCancel3, select as select2, text as text2 } from "@clack/prompts";
+
+// src/utils/env-detect.ts
+import { accessSync, existsSync, mkdirSync, readdirSync, statSync, constants } from "fs";
+import { homedir } from "os";
+import { resolve } from "path";
+import { cancel, isCancel, multiselect, select, text } from "@clack/prompts";
+var ENVIRONMENT_PROBES = [
+  {
+    envId: "claude-code",
+    label: "Claude Code",
+    targetRelativePath: ".claude/commands",
+    indicatorRelativePaths: [".claude/commands", ".claude"]
+  },
+  {
+    envId: "codex",
+    label: "Codex",
+    targetRelativePath: ".codex/prompts",
+    indicatorRelativePaths: [".codex/prompts", ".codex"]
+  },
+  {
+    envId: "cursor",
+    label: "Cursor",
+    targetRelativePath: ".cursor/commands",
+    indicatorRelativePaths: [".cursor/commands", ".cursor"]
+  }
+];
+var SOURCE_ORDER = ["project", "home"];
+var INSTALLED_COMMAND_FILES = [
+  "tiq-agent-dev.md",
+  "tiq-agent-sm.md",
+  "tiq-agent-pm.md",
+  "tiq-workflow-create-story.md",
+  "tiq-workflow-dev-story.md",
+  "tiq-workflow-fetch-project-context.md",
+  "tiq-workflow-create-ticket.md"
+];
+function detectEnvironmentCandidates(options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const homeDir = resolve(options.homeDir ?? homedir());
+  const candidates = [];
+  for (const source of SOURCE_ORDER) {
+    const sourceRoot = source === "project" ? cwd : homeDir;
+    for (const probe of ENVIRONMENT_PROBES) {
+      const hasIndicator = probe.indicatorRelativePaths.some(
+        (indicatorPath) => isExistingDirectory(resolve(sourceRoot, indicatorPath))
+      );
+      if (hasIndicator) {
+        const targetPath = resolve(sourceRoot, probe.targetRelativePath);
+        if (!isCreatableDirectoryTarget(targetPath)) {
+          continue;
+        }
+        candidates.push({
+          envId: probe.envId,
+          label: probe.label,
+          targetPath,
+          source
+        });
+      }
+    }
+  }
+  return candidates;
+}
+async function resolveEnvironmentTarget(options = {}) {
+  const detected = detectEnvironmentCandidates(options);
+  const allowMultipleSelections = options.allowMultipleSelections ?? false;
+  if (detected.length === 1) {
+    const selected2 = toSelectedEnvironment(detected[0]);
+    return {
+      detected,
+      selectedTargets: [selected2],
+      selected: selected2,
+      needsManualPath: false
+    };
+  }
+  if (detected.length > 1) {
+    if (allowMultipleSelections) {
+      const selectEnvironments = options.selectEnvironments ?? defaultSelectEnvironments;
+      const selectedKeys = await selectEnvironments(detected);
+      if (!selectedKeys || selectedKeys.length === 0) {
+        throw new Error("Environment selection was cancelled.");
+      }
+      const selectedTargets = detected.filter((candidate) => selectedKeys.includes(candidateKey(candidate))).map(toSelectedEnvironment);
+      if (selectedTargets.length === 0) {
+        throw new Error("Selected environments do not match detected candidates.");
+      }
+      return {
+        detected,
+        selectedTargets,
+        selected: selectedTargets[0],
+        needsManualPath: false
+      };
+    }
+    const selectEnvironment = options.selectEnvironment ?? defaultSelectEnvironment;
+    const selectedKey = await selectEnvironment(detected);
+    if (!selectedKey) {
+      throw new Error("Environment selection was cancelled.");
+    }
+    const selectedCandidate = detected.find((candidate) => candidateKey(candidate) === selectedKey);
+    if (!selectedCandidate) {
+      throw new Error(`Selected environment does not match detected candidates: ${selectedKey}`);
+    }
+    const selected2 = toSelectedEnvironment(selectedCandidate);
+    return {
+      detected,
+      selectedTargets: [selected2],
+      selected: selected2,
+      needsManualPath: false
+    };
+  }
+  const promptManualPath = options.promptManualPath ?? defaultManualPathPrompt;
+  const manualInput = await promptManualPath();
+  if (!manualInput) {
+    throw new Error("Manual deployment path prompt was cancelled.");
+  }
+  const normalizedPath = normalizeManualTargetPath(manualInput, {
+    baseDir: options.manualPathBaseDir ?? options.cwd ?? process.cwd()
+  });
+  const validateTargetPath = options.validateTargetPath ?? validateDeploymentTargetPath;
+  validateTargetPath(normalizedPath);
+  const selected = {
+    envId: "manual",
+    label: "Manual path",
+    targetPath: normalizedPath,
+    source: "manual"
+  };
+  return {
+    detected,
+    selectedTargets: [selected],
+    selected,
+    needsManualPath: true
+  };
+}
+function normalizeManualTargetPath(inputPath, options = {}) {
+  const trimmed = inputPath.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Manual deployment path cannot be empty.");
+  }
+  const baseDir = resolve(options.baseDir ?? process.cwd());
+  return resolve(baseDir, trimmed);
+}
+function validateDeploymentTargetPath(targetPath) {
+  if (existsSync(targetPath)) {
+    const stats = statSync(targetPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Deployment target is not a directory: ${targetPath}`);
+    }
+  } else {
+    mkdirSync(targetPath, { recursive: true });
+  }
+  accessSync(targetPath, constants.W_OK);
+}
+function candidateKey(candidate) {
+  return `${candidate.source}:${candidate.envId}`;
+}
+function toSelectedEnvironment(candidate) {
+  return {
+    envId: candidate.envId,
+    label: candidate.label,
+    targetPath: candidate.targetPath,
+    source: candidate.source
+  };
+}
+async function defaultSelectEnvironment(candidates) {
+  const answer = await select({
+    message: "Multiple AI environments detected. Choose deployment target:",
+    options: candidates.map((candidate) => ({
+      value: candidateKey(candidate),
+      label: `${candidate.label} (${candidate.source})`,
+      hint: candidate.targetPath
+    }))
+  });
+  if (isCancel(answer)) {
+    cancel("Operation cancelled.");
+    return null;
+  }
+  return String(answer);
+}
+async function defaultSelectEnvironments(candidates) {
+  const initialValues = getDefaultSelectedEnvironmentKeys(candidates);
+  const answer = await multiselect({
+    message: "Multiple AI environments detected. Choose deployment targets:",
+    initialValues,
+    options: candidates.map((candidate) => ({
+      value: candidateKey(candidate),
+      label: `${candidate.label} (${candidate.source})`,
+      hint: candidate.targetPath
+    }))
+  });
+  if (isCancel(answer)) {
+    cancel("Operation cancelled.");
+    return null;
+  }
+  return Array.from(answer).map((value) => String(value));
+}
+function getDefaultSelectedEnvironmentKeys(candidates) {
+  return candidates.filter(
+    (candidate) => hasInstalledCommandFiles(candidate.targetPath) || hasAnyTiqCommandFiles(candidate.targetPath)
+  ).map(candidateKey);
+}
+async function defaultManualPathPrompt() {
+  const answer = await text({
+    message: "No known AI environment found. Enter deployment directory:"
+  });
+  if (isCancel(answer)) {
+    cancel("Operation cancelled.");
+    return null;
+  }
+  return String(answer);
+}
+function isExistingDirectory(path) {
+  if (!existsSync(path)) {
+    return false;
+  }
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isCreatableDirectoryTarget(path) {
+  if (!existsSync(path)) {
+    return true;
+  }
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function hasInstalledCommandFiles(targetPath) {
+  return INSTALLED_COMMAND_FILES.every(
+    (fileName) => existsSync(resolve(targetPath, fileName))
+  );
+}
+function hasAnyTiqCommandFiles(targetPath) {
+  try {
+    const entries = readdirSync(targetPath, { withFileTypes: true });
+    return entries.some(
+      (entry) => entry.isFile() && /^tiq-[a-z0-9-]+\.md$/iu.test(entry.name)
+    );
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/file-ops.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  realpathSync,
+  readFileSync,
+  readdirSync as readdirSync2,
+  writeFileSync
+} from "fs";
+import { dirname, relative, resolve as resolve2 } from "path";
+import { cancel as cancel2, confirm, isCancel as isCancel2 } from "@clack/prompts";
+var COMMAND_TEMPLATE_FILES = [
+  "tiq-agent-dev.md",
+  "tiq-agent-sm.md",
+  "tiq-agent-pm.md",
+  "tiq-workflow-create-story.md",
+  "tiq-workflow-dev-story.md",
+  "tiq-workflow-fetch-project-context.md",
+  "tiq-workflow-create-ticket.md"
+];
+var TIQORA_WORKSPACE_DIRECTORIES = [
+  "config",
+  "state",
+  "agents/sessions",
+  "workflows/runs",
+  "workflows/steps",
+  "sessions",
+  "sprints",
+  "reports/daily",
+  "reports/retrospective",
+  "reports/mr-context",
+  "sync",
+  "migrations"
+];
+var TIQORA_WORKSPACE_ROOT = ".tiqora";
+var TIQORA_RUNTIME_ROOT = "_tiqora";
+var MissingTemplateFileError = class extends Error {
+  constructor(templateFile, templatePath) {
+    super(`Missing required template file: ${templatePath}`);
+    this.templateFile = templateFile;
+    this.templatePath = templatePath;
+    this.name = "MissingTemplateFileError";
+  }
+  code = "MISSING_TEMPLATE_FILE";
+};
+function resolveTemplateSourceDir(startDir) {
+  const startDirs = getSearchRoots(startDir);
+  for (const initialCursor of startDirs) {
+    let cursor = initialCursor;
+    for (let level = 0; level <= 6; level += 1) {
+      const candidate = resolve2(cursor, "templates", "commands");
+      if (existsSync2(candidate)) {
+        return candidate;
+      }
+      const parent = dirname(cursor);
+      if (parent === cursor) {
+        break;
+      }
+      cursor = parent;
+    }
+  }
+  return resolve2(process.cwd(), "templates", "commands");
+}
+function getCommandTemplateManifest(templateSourceDir) {
+  const sourceDir = resolve2(templateSourceDir ?? resolveTemplateSourceDir());
+  return COMMAND_TEMPLATE_FILES.map((fileName) => {
+    const sourcePath = resolve2(sourceDir, fileName);
+    if (!existsSync2(sourcePath)) {
+      throw new MissingTemplateFileError(fileName, sourcePath);
+    }
+    return {
+      fileName,
+      sourcePath
+    };
+  });
+}
+async function deployCommandTemplates(options) {
+  if (!options.selectedTargets.length) {
+    throw new Error("No deployment targets were provided.");
+  }
+  const manifest = getCommandTemplateManifest(options.templateSourceDir);
+  const askOverwrite = options.confirmOverwrite ?? defaultConfirmOverwrite;
+  const force = options.force ?? false;
+  const summary = {
+    deployedTargets: [],
+    filesCopied: [],
+    filesOverwritten: [],
+    filesSkipped: []
+  };
+  let overwriteDecision;
+  for (const selectedTarget of options.selectedTargets) {
+    const targetPath = resolve2(selectedTarget.targetPath);
+    mkdirSync2(targetPath, { recursive: true });
+    summary.deployedTargets.push(targetPath);
+    for (const templateEntry of manifest) {
+      const outputPath = resolve2(targetPath, templateEntry.fileName);
+      if (!existsSync2(outputPath)) {
+        copyFileSync(templateEntry.sourcePath, outputPath);
+        summary.filesCopied.push(outputPath);
+        continue;
+      }
+      if (force) {
+        copyFileSync(templateEntry.sourcePath, outputPath);
+        summary.filesOverwritten.push(outputPath);
+        continue;
+      }
+      if (overwriteDecision === void 0) {
+        overwriteDecision = await askOverwrite({
+          targetPath: outputPath,
+          templateFile: templateEntry.fileName
+        });
+      }
+      if (overwriteDecision) {
+        copyFileSync(templateEntry.sourcePath, outputPath);
+        summary.filesOverwritten.push(outputPath);
+      } else {
+        summary.filesSkipped.push(outputPath);
+      }
+    }
+  }
+  return summary;
+}
+function patchGitignoreWithTiqora(options = {}) {
+  const projectRoot = resolve2(options.projectRoot ?? process.cwd());
+  const gitignorePath = resolve2(projectRoot, ".gitignore");
+  if (!existsSync2(gitignorePath)) {
+    writeFileSync(gitignorePath, ".tiqora/\n", "utf8");
+    return true;
+  }
+  const current = readFileSync(gitignorePath, "utf8");
+  const normalized = current.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  if (lines.includes(".tiqora/")) {
+    return false;
+  }
+  const withTrailingNewline = normalized.endsWith("\n") ? normalized : `${normalized}
+`;
+  const nextContent = `${withTrailingNewline}.tiqora/
+`;
+  writeFileSync(gitignorePath, nextContent, "utf8");
+  return true;
+}
+async function deployAgentAssets(options) {
+  const deployment = await deployCommandTemplates(options);
+  const workspaceSummary = bootstrapTiqoraWorkspace({
+    projectRoot: options.projectRoot
+  });
+  const runtimeSummary = deployTiqoraRuntimeAssets({
+    projectRoot: options.projectRoot,
+    runtimeSourceDir: options.runtimeSourceDir,
+    force: options.force
+  });
+  const gitignorePatched = patchGitignoreWithTiqora({
+    projectRoot: options.projectRoot
+  });
+  return {
+    ...deployment,
+    gitignorePatched,
+    runtimeSummary,
+    workspaceSummary
+  };
+}
+function deployTiqoraRuntimeAssets(options = {}) {
+  const projectRoot = resolve2(options.projectRoot ?? process.cwd());
+  const runtimeRoot = resolve2(projectRoot, TIQORA_RUNTIME_ROOT);
+  const sourcePath = options.runtimeSourceDir ? resolve2(options.runtimeSourceDir) : resolveTiqoraRuntimeSourceDir(projectRoot);
+  const force = options.force ?? false;
+  const summary = {
+    sourceFound: false,
+    sourcePath,
+    runtimeRoot,
+    filesCopied: [],
+    filesOverwritten: [],
+    filesSkipped: []
+  };
+  if (!sourcePath) {
+    return summary;
+  }
+  const sourceWorkflowEngine = resolve2(sourcePath, "core", "tasks", "workflow.xml");
+  if (!existsSync2(sourceWorkflowEngine)) {
+    return summary;
+  }
+  summary.sourceFound = true;
+  syncRuntimeTree({
+    sourcePath,
+    targetPath: runtimeRoot,
+    projectRoot,
+    force,
+    summary
+  });
+  return summary;
+}
+function bootstrapTiqoraWorkspace(options = {}) {
+  const projectRoot = resolve2(options.projectRoot ?? process.cwd());
+  const workspaceRoot = resolve2(projectRoot, TIQORA_WORKSPACE_ROOT);
+  const directoriesCreated = [];
+  for (const relativeDir of TIQORA_WORKSPACE_DIRECTORIES) {
+    const directoryPath = resolve2(workspaceRoot, relativeDir);
+    if (!existsSync2(directoryPath)) {
+      directoriesCreated.push(toProjectRelativePath(projectRoot, directoryPath));
+    }
+    mkdirSync2(directoryPath, { recursive: true });
+  }
+  return {
+    workspaceRoot,
+    directoriesCreated
+  };
+}
+async function defaultConfirmOverwrite(args) {
+  const answer = await confirm({
+    message: "Existing command files were found. Do you want to update all command files for this run?",
+    initialValue: false,
+    active: "Yes, update all",
+    inactive: "No, keep existing"
+  });
+  if (isCancel2(answer)) {
+    cancel2("Operation cancelled.");
+    throw new Error("Overwrite confirmation was cancelled.");
+  }
+  return Boolean(answer);
+}
+function syncRuntimeTree(options) {
+  const sourceStats = lstatSync(options.sourcePath);
+  if (sourceStats.isDirectory()) {
+    mkdirSync2(options.targetPath, { recursive: true });
+    const entries = readdirSync2(options.sourcePath, { withFileTypes: true });
+    for (const entry of entries) {
+      syncRuntimeTree({
+        ...options,
+        sourcePath: resolve2(options.sourcePath, entry.name),
+        targetPath: resolve2(options.targetPath, entry.name)
+      });
+    }
+    return;
+  }
+  if (!sourceStats.isFile()) {
+    return;
+  }
+  const relativeTargetPath = toProjectRelativePath(options.projectRoot, options.targetPath);
+  if (existsSync2(options.targetPath)) {
+    if (!options.force) {
+      options.summary.filesSkipped.push(relativeTargetPath);
+      return;
+    }
+    mkdirSync2(dirname(options.targetPath), { recursive: true });
+    copyFileSync(options.sourcePath, options.targetPath);
+    options.summary.filesOverwritten.push(relativeTargetPath);
+    return;
+  }
+  mkdirSync2(dirname(options.targetPath), { recursive: true });
+  copyFileSync(options.sourcePath, options.targetPath);
+  options.summary.filesCopied.push(relativeTargetPath);
+}
+function resolveTiqoraRuntimeSourceDir(startDir) {
+  const startDirs = getSearchRoots(startDir);
+  for (const initialCursor of startDirs) {
+    let cursor = initialCursor;
+    for (let level = 0; level <= 6; level += 1) {
+      const candidate = resolve2(cursor, TIQORA_RUNTIME_ROOT);
+      const workflowEngineCandidate = resolve2(candidate, "core", "tasks", "workflow.xml");
+      if (existsSync2(workflowEngineCandidate)) {
+        return candidate;
+      }
+      const parent = dirname(cursor);
+      if (parent === cursor) {
+        break;
+      }
+      cursor = parent;
+    }
+  }
+  return null;
+}
+function getSearchRoots(startDir) {
+  const startDirs = /* @__PURE__ */ new Set();
+  addProcessEntrySearchRoots(startDirs);
+  addModuleSearchRoots(startDirs);
+  if (startDir) {
+    startDirs.add(resolve2(startDir));
+  }
+  startDirs.add(resolve2(process.cwd()));
+  return startDirs;
+}
+function addProcessEntrySearchRoots(startDirs) {
+  const entryPath = process.argv[1];
+  if (!entryPath) {
+    return;
+  }
+  addPathAndParent(startDirs, resolve2(entryPath));
+  try {
+    const realEntryPath = realpathSync(entryPath);
+    addPathAndParent(startDirs, resolve2(realEntryPath));
+  } catch {
+  }
+}
+function addModuleSearchRoots(startDirs) {
+  if (typeof __filename !== "string" || __filename.length === 0) {
+    return;
+  }
+  addPathAndParent(startDirs, resolve2(__filename));
+}
+function addPathAndParent(startDirs, path) {
+  const pathDir = dirname(path);
+  startDirs.add(pathDir);
+  startDirs.add(resolve2(pathDir, ".."));
+}
+function toProjectRelativePath(projectRoot, absolutePath) {
+  const relativePath = relative(projectRoot, absolutePath);
+  if (relativePath.length === 0) {
+    return ".";
+  }
+  return relativePath.replace(/\\/gu, "/");
+}
+
+// src/utils/git-branch-pattern.ts
+import { execFileSync } from "child_process";
+import { resolve as resolve3 } from "path";
+var DEFAULT_BRANCH_PATTERN = "feature/*";
+var IGNORED_BRANCH_NAMES = /* @__PURE__ */ new Set([
+  "main",
+  "master",
+  "develop",
+  "development",
+  "dev",
+  "trunk",
+  "staging",
+  "production",
+  "prod"
+]);
+var PATTERN_PRIORITY = [
+  "feature/*",
+  "feat/*",
+  "story/*",
+  "chore/*",
+  "bugfix/*",
+  "fix/*",
+  "hotfix/*",
+  "task/*",
+  "release/*"
+];
+function suggestBranchPattern(options = {}) {
+  const cwd = resolve3(options.cwd ?? process.cwd());
+  try {
+    const listBranches = options.listBranches ?? listLocalBranches;
+    return inferBranchPatternFromBranches(listBranches(cwd));
+  } catch {
+    return DEFAULT_BRANCH_PATTERN;
+  }
+}
+function inferBranchPatternFromBranches(branches) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const rawBranch of branches) {
+    const pattern = toPattern(rawBranch);
+    if (!pattern) {
+      continue;
+    }
+    counts.set(pattern, (counts.get(pattern) ?? 0) + 1);
+  }
+  if (counts.size === 0) {
+    return DEFAULT_BRANCH_PATTERN;
+  }
+  return Array.from(counts.entries()).sort((left, right) => {
+    const countDelta = right[1] - left[1];
+    if (countDelta !== 0) {
+      return countDelta;
+    }
+    const leftPriority = patternPriorityIndex(left[0]);
+    const rightPriority = patternPriorityIndex(right[0]);
+    if (leftPriority !== rightPriority) {
+      return leftPriority - rightPriority;
+    }
+    return left[0].localeCompare(right[0]);
+  })[0][0];
+}
+function listLocalBranches(cwd) {
+  const output = execFileSync(
+    "git",
+    ["for-each-ref", "--format=%(refname:short)", "refs/heads"],
+    {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }
+  );
+  return output.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function toPattern(branchName) {
+  const normalized = branchName.trim().replace(/^remotes\/origin\//u, "");
+  if (normalized.length === 0 || IGNORED_BRANCH_NAMES.has(normalized)) {
+    return null;
+  }
+  if (normalized.includes("/")) {
+    const prefix = normalized.split("/")[0].toLowerCase();
+    if (prefix.length === 0 || IGNORED_BRANCH_NAMES.has(prefix)) {
+      return null;
+    }
+    return `${prefix}/*`;
+  }
+  const dashedPrefixMatch = normalized.match(/^([a-z0-9._-]+)-/iu);
+  if (dashedPrefixMatch) {
+    const prefix = dashedPrefixMatch[1].toLowerCase();
+    if (!IGNORED_BRANCH_NAMES.has(prefix)) {
+      return `${prefix}/*`;
+    }
+  }
+  return null;
+}
+function patternPriorityIndex(pattern) {
+  const index = PATTERN_PRIORITY.indexOf(pattern);
+  return index === -1 ? PATTERN_PRIORITY.length : index;
+}
+
+// src/utils/init-config.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { resolve as resolve4 } from "path";
+var DEFAULT_IDLE_THRESHOLD_MINUTES = 15;
+var DEFAULT_USER_NAME = "Developer";
+var DEFAULT_COMMUNICATION_LANGUAGE = "fr";
+var DEFAULT_DOCUMENT_LANGUAGE = "fr";
+var PROJECT_INIT_CONFIG_FILE = ".tiqora.yaml";
+var GLOBAL_USER_CONFIG_FILE = ".tiqora/config.yaml";
+function createProjectInitConfigYaml(answers) {
+  const branchPattern = answers.branchPattern.trim();
+  if (branchPattern.length === 0) {
+    throw new Error("Branch pattern cannot be empty.");
+  }
+  const lines = [
+    `pm_tool: ${answers.pmTool}`,
+    `git_host: ${answers.gitHost}`,
+    `branch_pattern: '${escapeSingleQuotes(branchPattern)}'`
+  ];
+  if (answers.pmTool === "jira") {
+    const jira = answers.jira;
+    if (!jira) {
+      throw new Error("Jira configuration is required when pm_tool is jira.");
+    }
+    const projectKey = jira.projectKey.trim();
+    const boardId = jira.boardId.trim();
+    if (!projectKey || !boardId) {
+      throw new Error("jira.project_key and jira.board_id are required.");
+    }
+    lines.push("jira:");
+    lines.push(`  project_key: ${projectKey}`);
+    lines.push(`  board_id: '${escapeSingleQuotes(boardId)}'`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function createGlobalUserConfigYaml(answers) {
+  const idleThresholdMinutes = answers.idleThresholdMinutes ?? DEFAULT_IDLE_THRESHOLD_MINUTES;
+  if (!Number.isInteger(idleThresholdMinutes) || idleThresholdMinutes <= 0) {
+    throw new Error("idle_threshold_minutes must be a positive integer.");
+  }
+  const userName = normalizeRequiredValue(
+    answers.userName ?? DEFAULT_USER_NAME,
+    "user_name"
+  );
+  const communicationLanguage = normalizeLanguageValue(
+    answers.communicationLanguage ?? DEFAULT_COMMUNICATION_LANGUAGE,
+    "communication_language"
+  );
+  const documentLanguage = normalizeLanguageValue(
+    answers.documentLanguage ?? DEFAULT_DOCUMENT_LANGUAGE,
+    "document_language"
+  );
+  return [
+    `user_name: '${escapeSingleQuotes(userName)}'`,
+    `idle_threshold_minutes: ${idleThresholdMinutes}`,
+    `communication_language: '${escapeSingleQuotes(communicationLanguage)}'`,
+    `document_language: '${escapeSingleQuotes(documentLanguage)}'`,
+    ""
+  ].join("\n");
+}
+function writeProjectInitConfig(options) {
+  const projectRoot = resolve4(options.projectRoot ?? process.cwd());
+  const configPath = resolve4(projectRoot, PROJECT_INIT_CONFIG_FILE);
+  const allowOverwrite = options.allowOverwrite ?? false;
+  if (existsSync3(configPath) && !allowOverwrite) {
+    throw new Error(
+      `${PROJECT_INIT_CONFIG_FILE} already exists at ${configPath}. Remove it before running init.`
+    );
+  }
+  const content = createProjectInitConfigYaml(options.answers);
+  writeFileSync2(configPath, content, "utf8");
+  return configPath;
+}
+function writeGlobalUserConfig(options) {
+  const home = resolve4(options.homeDir ?? homedir2());
+  const configPath = resolve4(home, GLOBAL_USER_CONFIG_FILE);
+  mkdirSync3(resolve4(home, ".tiqora"), { recursive: true });
+  const content = createGlobalUserConfigYaml(options.answers);
+  writeFileSync2(configPath, content, "utf8");
+  return configPath;
+}
+function readExistingInitConfig(options = {}) {
+  const projectRoot = resolve4(options.projectRoot ?? process.cwd());
+  const projectConfigPath = resolve4(projectRoot, PROJECT_INIT_CONFIG_FILE);
+  const home = resolve4(options.homeDir ?? homedir2());
+  const globalConfigPath = resolve4(home, GLOBAL_USER_CONFIG_FILE);
+  if (!existsSync3(projectConfigPath) && !existsSync3(globalConfigPath)) {
+    return null;
+  }
+  const result = {};
+  const mergeFrom = (path) => {
+    if (!existsSync3(path)) {
+      return;
+    }
+    const parsed = parseExistingInitConfigFile(path);
+    Object.assign(result, parsed);
+  };
+  mergeFrom(globalConfigPath);
+  mergeFrom(projectConfigPath);
+  return result;
+}
+function parseExistingInitConfigFile(configPath) {
+  const content = readFileSync2(configPath, "utf8");
+  const lines = content.split(/\r?\n/u);
+  const result = {};
+  let inJiraBlock = false;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    if (line === "jira:") {
+      inJiraBlock = true;
+      continue;
+    }
+    if (!rawLine.startsWith(" ") && !rawLine.startsWith("	")) {
+      inJiraBlock = false;
+    }
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    const value = stripWrappingQuotes(line.slice(separatorIndex + 1).trim());
+    if (!inJiraBlock) {
+      if (key === "pm_tool" && isInitPmTool(value)) {
+        result.pmTool = value;
+      } else if (key === "git_host" && isInitGitHost(value)) {
+        result.gitHost = value;
+      } else if (key === "branch_pattern" && value.length > 0) {
+        result.branchPattern = value;
+      } else if (key === "idle_threshold_minutes") {
+        const parsed = Number(value);
+        if (Number.isInteger(parsed) && parsed > 0) {
+          result.idleThresholdMinutes = parsed;
+        }
+      } else if (key === "user_name" && value.length > 0) {
+        result.userName = value;
+      } else if (key === "communication_language" && value.length > 0) {
+        result.communicationLanguage = value;
+      } else if (key === "document_language" && value.length > 0) {
+        result.documentLanguage = value;
+      }
+      continue;
+    }
+    if (key === "project_key" && value.length > 0) {
+      result.jira = {
+        projectKey: value,
+        boardId: result.jira?.boardId ?? ""
+      };
+    } else if (key === "board_id" && value.length > 0) {
+      result.jira = {
+        projectKey: result.jira?.projectKey ?? "",
+        boardId: value
+      };
+    }
+  }
+  if (result.jira && (result.jira.projectKey.length === 0 || result.jira.boardId.length === 0)) {
+    delete result.jira;
+  }
+  return result;
+}
+function escapeSingleQuotes(value) {
+  return value.replace(/'/gu, "''");
+}
+function stripWrappingQuotes(value) {
+  if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function normalizeLanguageValue(value, key) {
+  return normalizeRequiredValue(value, key);
+}
+function normalizeRequiredValue(value, key) {
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    throw new Error(`${key} cannot be empty.`);
+  }
+  return normalized;
+}
+function isInitPmTool(value) {
+  return value === "jira" || value === "gitlab" || value === "none";
+}
+function isInitGitHost(value) {
+  return value === "gitlab" || value === "github";
+}
+
+// src/utils/jira-mcp.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync3,
+  realpathSync as realpathSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, resolve as resolve5, sep } from "path";
+var ATLASSIAN_MCP_URL = "https://mcp.atlassian.com/v1/mcp";
+function ensureJiraMcpConfigured(options) {
+  const projectRoot = resolve5(options.projectRoot ?? process.cwd());
+  const homeDir = resolve5(options.homeDir ?? homedir3());
+  const envIds = new Set(options.selectedTargets.map((target) => target.envId));
+  for (const envId of envIds) {
+    if (envId === "manual") {
+      continue;
+    }
+    if (envId === "codex") {
+      ensureCodexJiraMcp(resolve5(homeDir, ".codex", "config.toml"));
+      continue;
+    }
+    if (envId === "claude-code") {
+      ensureClaudeJiraMcp(resolve5(homeDir, ".claude.json"), projectRoot);
+      continue;
+    }
+    if (envId === "cursor") {
+      ensureCursorJiraMcp(resolve5(homeDir, ".cursor", "mcp.json"));
+      continue;
+    }
+  }
+}
+function ensureCodexJiraMcp(configPath) {
+  mkdirSync4(dirname2(configPath), { recursive: true });
+  const rawContent = existsSync4(configPath) ? readFileSync3(configPath, "utf8") : "";
+  const content = normalizeInlineSectionFormatting(rawContent);
+  const sectionName = getTomlSectionName(content, ["mcp_servers.jira", "mcp_servers.atlassian"]);
+  if (!sectionName) {
+    const nextContent2 = appendTomlSection(content, "mcp_servers.jira", [
+      "enabled = true",
+      `url = "${ATLASSIAN_MCP_URL}"`
+    ]);
+    writeFileSync3(configPath, nextContent2, "utf8");
+    return;
+  }
+  const sectionRange = getTomlSectionRange(content, sectionName);
+  if (!sectionRange) {
+    const nextContent2 = appendTomlSection(content, sectionName, [
+      "enabled = true",
+      `url = "${ATLASSIAN_MCP_URL}"`
+    ]);
+    writeFileSync3(configPath, nextContent2, "utf8");
+    return;
+  }
+  const updatedSectionBody = upsertTomlKey(
+    upsertTomlKey(sectionRange.body, "enabled", "true"),
+    "url",
+    `"${ATLASSIAN_MCP_URL}"`
+  );
+  const formattedSectionBody = ensureTomlSectionBodyStartsOnNewLine(updatedSectionBody);
+  const nextContent = `${content.slice(0, sectionRange.start)}${formattedSectionBody}${content.slice(
+    sectionRange.end
+  )}`;
+  writeFileSync3(configPath, nextContent, "utf8");
+}
+function ensureClaudeJiraMcp(configPath, projectRoot) {
+  mkdirSync4(dirname2(configPath), { recursive: true });
+  const parsed = readJsonOrDefault(configPath, {});
+  const rootRecord = asRecord(parsed);
+  if (!rootRecord) {
+    throw new Error(`\u2717 ${configPath} must contain a JSON object`);
+  }
+  const projects = asRecord(rootRecord.projects) ?? {};
+  const bestProject = findBestProjectMatch(projects, projectRoot);
+  const projectKey = bestProject?.key ?? resolve5(projectRoot);
+  const projectConfig = asRecord(projects[projectKey]) ?? {};
+  const mcpServers = asRecord(projectConfig.mcpServers) ?? {};
+  const atlassianKey = Object.keys(mcpServers).find((key) => key.toLowerCase() === "atlassian") ?? "atlassian";
+  const atlassianServer = asRecord(mcpServers[atlassianKey]) ?? {};
+  mcpServers[atlassianKey] = {
+    ...atlassianServer,
+    type: "http",
+    url: ATLASSIAN_MCP_URL
+  };
+  projectConfig.mcpServers = mcpServers;
+  projects[projectKey] = projectConfig;
+  rootRecord.projects = projects;
+  writeFileSync3(configPath, `${JSON.stringify(rootRecord, null, 2)}
+`, "utf8");
+}
+function ensureCursorJiraMcp(configPath) {
+  mkdirSync4(dirname2(configPath), { recursive: true });
+  const parsed = readJsonOrDefault(configPath, {});
+  const rootRecord = asRecord(parsed);
+  if (!rootRecord) {
+    throw new Error(`\u2717 ${configPath} must contain a JSON object`);
+  }
+  const mcpServers = asRecord(rootRecord.mcpServers) ?? {};
+  const atlassianKey = Object.keys(mcpServers).find((key) => key.toLowerCase() === "atlassian") ?? "Atlassian";
+  const atlassianServer = asRecord(mcpServers[atlassianKey]) ?? {};
+  mcpServers[atlassianKey] = {
+    ...atlassianServer,
+    url: ATLASSIAN_MCP_URL,
+    headers: asRecord(atlassianServer.headers) ?? {}
+  };
+  rootRecord.mcpServers = mcpServers;
+  writeFileSync3(configPath, `${JSON.stringify(rootRecord, null, 2)}
+`, "utf8");
+}
+function appendTomlSection(content, sectionName, lines) {
+  const prefix = content.trim().length === 0 ? "" : content.endsWith("\n") ? content : `${content}
+`;
+  return `${prefix}[${sectionName}]
+${lines.join("\n")}
+`;
+}
+function getTomlSectionName(content, sectionNames) {
+  for (const sectionName of sectionNames) {
+    const sectionHeader = new RegExp(`^\\s*\\[${escapeForRegex(sectionName)}\\]\\s*$`, "m");
+    if (sectionHeader.test(content)) {
+      return sectionName;
+    }
+  }
+  return null;
+}
+function getTomlSectionRange(content, sectionName) {
+  const sectionHeader = new RegExp(`^\\s*\\[${escapeForRegex(sectionName)}\\]\\s*$`, "m");
+  const match = sectionHeader.exec(content);
+  if (!match || match.index === void 0) {
+    return null;
+  }
+  const start = match.index + match[0].length;
+  const remaining = content.slice(start);
+  const nextSection = /^\s*\[[^\]]+\]\s*$/m.exec(remaining);
+  const end = nextSection?.index !== void 0 ? start + nextSection.index : content.length;
+  return {
+    start,
+    end,
+    body: content.slice(start, end)
+  };
+}
+function upsertTomlKey(sectionBody, key, valueLiteral) {
+  const keyPattern = new RegExp(`^\\s*${escapeForRegex(key)}\\s*=.*$`, "m");
+  const line = `${key} = ${valueLiteral}`;
+  if (keyPattern.test(sectionBody)) {
+    return sectionBody.replace(keyPattern, line);
+  }
+  if (sectionBody.trim().length === 0) {
+    return `
+${line}
+`;
+  }
+  const suffix = sectionBody.endsWith("\n") ? "" : "\n";
+  return `${sectionBody}${suffix}${line}
+`;
+}
+function ensureTomlSectionBodyStartsOnNewLine(sectionBody) {
+  if (sectionBody.startsWith("\n")) {
+    return sectionBody;
+  }
+  return `
+${sectionBody}`;
+}
+function normalizeInlineSectionFormatting(content) {
+  return content.replace(
+    /(\[mcp_servers\.(?:jira|atlassian)\])\s*(enabled\s*=)/giu,
+    "$1\n$2"
+  );
+}
+function readJsonOrDefault(path, fallback) {
+  if (!existsSync4(path)) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    throw new Error(`\u2717 ${path} is not valid JSON`);
+  }
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function findBestProjectMatch(projects, projectRoot) {
+  const normalizedRoot = normalizePath(projectRoot);
+  let best = null;
+  let bestLength = -1;
+  for (const [key, value] of Object.entries(projects)) {
+    const normalizedKey = normalizePath(key);
+    const isExactMatch = normalizedRoot === normalizedKey;
+    const isPrefixMatch = normalizedRoot.startsWith(`${normalizedKey}${sep}`);
+    if (!isExactMatch && !isPrefixMatch) {
+      continue;
+    }
+    if (normalizedKey.length > bestLength) {
+      best = { key, value };
+      bestLength = normalizedKey.length;
+    }
+  }
+  return best;
+}
+function escapeForRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function normalizePath(pathValue) {
+  const resolved = resolve5(pathValue);
+  try {
+    return realpathSync2(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+// src/commands/init.ts
+async function runInitCommand(options = {}) {
+  const projectRoot = options.projectRoot ?? options.cwd ?? process.cwd();
+  const resolution = await resolveEnvironmentTarget({
+    cwd: options.cwd,
+    homeDir: options.homeDir,
+    allowMultipleSelections: options.allowMultipleSelections ?? true,
+    selectEnvironment: options.selectEnvironment,
+    selectEnvironments: options.selectEnvironments,
+    promptManualPath: options.promptManualPath,
+    validateTargetPath: options.validateTargetPath,
+    manualPathBaseDir: options.manualPathBaseDir
+  });
+  const branchPatternSuggester = options.branchPatternSuggester ?? suggestBranchPattern;
+  const existingConfig = readExistingInitConfig({
+    projectRoot,
+    homeDir: options.homeDir
+  });
+  const suggestedBranchPattern = existingConfig?.branchPattern ?? branchPatternSuggester({ cwd: projectRoot });
+  const collectInitAnswers = options.collectInitAnswers ?? defaultCollectInitAnswers;
+  const answers = await collectInitAnswers({
+    cwd: projectRoot,
+    suggestedBranchPattern,
+    existingConfig
+  });
+  if (!answers) {
+    throw new Error("Init wizard cancelled.");
+  }
+  if (answers.pmTool === "jira") {
+    ensureJiraMcpConfigured({
+      projectRoot,
+      homeDir: options.homeDir,
+      selectedTargets: resolution.selectedTargets
+    });
+  }
+  const configPath = writeProjectInitConfig({
+    projectRoot,
+    answers,
+    allowOverwrite: true
+  });
+  const userConfigPath = writeGlobalUserConfig({
+    homeDir: options.homeDir,
+    answers
+  });
+  const deploymentSummary = await deployAgentAssets({
+    selectedTargets: resolution.selectedTargets,
+    templateSourceDir: options.templateSourceDir,
+    runtimeSourceDir: options.runtimeSourceDir,
+    projectRoot,
+    force: options.force ?? false,
+    confirmOverwrite: options.confirmOverwrite
+  });
+  return {
+    ...resolution,
+    deploymentSummary,
+    configPath,
+    userConfigPath
+  };
+}
+function registerInitCommand(program) {
+  program.command("init").description("Initialize tiqora in this repository.").option("-f, --force", "Overwrite existing command files without prompting.").action((commandOptions) => {
+    void runInitCommand({ force: Boolean(commandOptions.force) }).then((result) => {
+      printInitSummary(result);
+    }).catch(handleCommandError);
+  });
+}
+function printInitSummary(result) {
+  console.log(`Created config: ${result.configPath}`);
+  console.log(`Updated user profile: ${result.userConfigPath}`);
+  printDeploymentSummary(result.deploymentSummary);
+}
+function printDeploymentSummary(summary) {
+  if (summary.deployedTargets.length === 1) {
+    console.log(`Deployment target: ${summary.deployedTargets[0]}`);
+  } else {
+    console.log(
+      `Deployment targets (${summary.deployedTargets.length}):
+- ${summary.deployedTargets.join(
+        "\n- "
+      )}`
+    );
+  }
+  console.log(
+    `Deployment summary: copied=${summary.filesCopied.length}, overwritten=${summary.filesOverwritten.length}, skipped=${summary.filesSkipped.length}`
+  );
+  console.log(
+    summary.gitignorePatched ? "Patched .gitignore with .tiqora/." : ".gitignore already contains .tiqora/."
+  );
+  console.log(
+    summary.runtimeSummary.sourceFound ? `Runtime summary (_tiqora): copied=${summary.runtimeSummary.filesCopied.length}, overwritten=${summary.runtimeSummary.filesOverwritten.length}, skipped=${summary.runtimeSummary.filesSkipped.length}` : "Runtime summary (_tiqora): source not found, skipped."
+  );
+  console.log(
+    `Workspace summary: created=${summary.workspaceSummary.directoriesCreated.length}`
+  );
+}
+async function defaultCollectInitAnswers(context) {
+  const pmToolAnswer = await select2({
+    message: "Project management tool:",
+    options: [
+      { value: "jira", label: "Jira" },
+      { value: "gitlab", label: "GitLab" },
+      { value: "none", label: "None" }
+    ],
+    initialValue: context.existingConfig?.pmTool
+  });
+  if (isCancel3(pmToolAnswer)) {
+    cancel3("Operation cancelled.");
+    return null;
+  }
+  const gitHostAnswer = await select2({
+    message: "Git host:",
+    options: [
+      { value: "gitlab", label: "GitLab" },
+      { value: "github", label: "GitHub" }
+    ],
+    initialValue: context.existingConfig?.gitHost
+  });
+  if (isCancel3(gitHostAnswer)) {
+    cancel3("Operation cancelled.");
+    return null;
+  }
+  const branchPatternAnswer = await text2({
+    message: "Branch naming pattern:",
+    defaultValue: context.suggestedBranchPattern,
+    placeholder: "feature/*",
+    validate(value) {
+      if (value.trim().length === 0) {
+        return "Branch pattern cannot be empty.";
+      }
+      return void 0;
+    }
+  });
+  if (isCancel3(branchPatternAnswer)) {
+    cancel3("Operation cancelled.");
+    return null;
+  }
+  const pmTool = String(pmToolAnswer);
+  const answers = {
+    pmTool,
+    gitHost: String(gitHostAnswer),
+    branchPattern: String(branchPatternAnswer).trim()
+  };
+  const userNameAnswer = await text2({
+    message: "Your name (for agent interactions):",
+    defaultValue: context.existingConfig?.userName ?? process.env.USER ?? DEFAULT_USER_NAME,
+    placeholder: "Developer",
+    validate(value) {
+      if (value.trim().length === 0) {
+        return "Name cannot be empty.";
+      }
+      return void 0;
+    }
+  });
+  if (isCancel3(userNameAnswer)) {
+    cancel3("Operation cancelled.");
+    return null;
+  }
+  const communicationLanguageAnswer = await text2({
+    message: "Agent response language:",
+    defaultValue: context.existingConfig?.communicationLanguage ?? DEFAULT_COMMUNICATION_LANGUAGE,
+    placeholder: "fr",
+    validate(value) {
+      if (value.trim().length === 0) {
+        return "Language cannot be empty.";
+      }
+      return void 0;
+    }
+  });
+  if (isCancel3(communicationLanguageAnswer)) {
+    cancel3("Operation cancelled.");
+    return null;
+  }
+  const documentLanguageAnswer = await text2({
+    message: "Document output language:",
+    defaultValue: context.existingConfig?.documentLanguage ?? DEFAULT_DOCUMENT_LANGUAGE,
+    placeholder: "fr",
+    validate(value) {
+      if (value.trim().length === 0) {
+        return "Language cannot be empty.";
+      }
+      return void 0;
+    }
+  });
+  if (isCancel3(documentLanguageAnswer)) {
+    cancel3("Operation cancelled.");
+    return null;
+  }
+  answers.communicationLanguage = String(communicationLanguageAnswer).trim();
+  answers.documentLanguage = String(documentLanguageAnswer).trim();
+  answers.userName = String(userNameAnswer).trim();
+  if (pmTool === "jira") {
+    const projectKeyAnswer = await text2({
+      message: "Jira project key:",
+      placeholder: "PROJ",
+      initialValue: context.existingConfig?.jira?.projectKey,
+      validate(value) {
+        if (value.trim().length === 0) {
+          return "Project key is required.";
+        }
+        return void 0;
+      }
+    });
+    if (isCancel3(projectKeyAnswer)) {
+      cancel3("Operation cancelled.");
+      return null;
+    }
+    const boardIdAnswer = await text2({
+      message: "Jira board id:",
+      placeholder: "123",
+      initialValue: context.existingConfig?.jira?.boardId,
+      validate(value) {
+        if (value.trim().length === 0) {
+          return "Board id is required.";
+        }
+        return void 0;
+      }
+    });
+    if (isCancel3(boardIdAnswer)) {
+      cancel3("Operation cancelled.");
+      return null;
+    }
+    answers.jira = {
+      projectKey: String(projectKeyAnswer).trim(),
+      boardId: String(boardIdAnswer).trim()
+    };
+  }
+  return answers;
+}
+function handleCommandError(error) {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  console.error(message.startsWith("\u2717") ? message : `\u2717 ${message}`);
+  return process.exit(1);
+}
+
+// src/utils/config.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname3, resolve as resolve6 } from "path";
+var PROJECT_CONFIG_FILE = ".tiqora.yaml";
+var GLOBAL_CONFIG_FILE = ".tiqora/config.yaml";
+var MISSING_CONFIG_ERROR_MESSAGE = "\u2717 No .tiqora.yaml found. Run npx tiqora init first.";
+var DEFAULT_USER_NAME2 = "Developer";
+var DEFAULT_COMMUNICATION_LANGUAGE2 = "fr";
+var DEFAULT_DOCUMENT_LANGUAGE2 = "fr";
+var REQUIRED_CONFIG_KEYS = [
+  "pm_tool",
+  "git_host",
+  "branch_pattern"
+];
+var ConfigNotFoundError = class extends Error {
+  code = "CONFIG_NOT_FOUND";
+  constructor(message = MISSING_CONFIG_ERROR_MESSAGE) {
+    super(message);
+    this.name = "ConfigNotFoundError";
+  }
+};
+function discoverProjectConfigPath(startDir = process.cwd(), maxParentLevels = 3) {
+  let cursor = resolve6(startDir);
+  for (let level = 0; level <= maxParentLevels; level += 1) {
+    const candidate = resolve6(cursor, PROJECT_CONFIG_FILE);
+    if (existsSync5(candidate)) {
+      return candidate;
+    }
+    const parent = dirname3(cursor);
+    if (parent === cursor) {
+      break;
+    }
+    cursor = parent;
+  }
+  return null;
+}
+function getGlobalConfigPath() {
+  return resolve6(homedir4(), GLOBAL_CONFIG_FILE);
+}
+function loadRuntimeConfig(options = {}) {
+  const projectPath = discoverProjectConfigPath(
+    options.startDir ?? process.cwd(),
+    options.maxParentLevels ?? 3
+  );
+  const globalPath = options.globalConfigPath ?? getGlobalConfigPath();
+  const hasGlobal = existsSync5(globalPath);
+  if (!projectPath && !hasGlobal) {
+    throw new ConfigNotFoundError();
+  }
+  const projectValues = projectPath ? parseYamlFlatMap(readFileSync4(projectPath, "utf8")) : {};
+  const globalValues = hasGlobal ? parseYamlFlatMap(readFileSync4(globalPath, "utf8")) : {};
+  return parseAndValidateConfig(
+    {
+      ...globalValues,
+      ...projectValues
+    },
+    projectPath ?? globalPath
+  );
+}
+function loadRuntimeConfigOrExit(options = {}) {
+  try {
+    return loadRuntimeConfig(options);
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      const log = options.log ?? console.error;
+      const exit = options.exit ?? process.exit;
+      log(MISSING_CONFIG_ERROR_MESSAGE);
+      return exit(1);
+    }
+    throw error;
+  }
+}
+function parseAndValidateConfig(parsed, configPath) {
+  const missingKey = REQUIRED_CONFIG_KEYS.find((key) => !(key in parsed));
+  if (missingKey) {
+    throw new Error(`Missing required key "${missingKey}" in ${configPath}`);
+  }
+  const idleThreshold = Number(parsed.idle_threshold_minutes ?? "15");
+  if (!Number.isFinite(idleThreshold) || idleThreshold <= 0) {
+    throw new Error(`Invalid idle_threshold_minutes in ${configPath}`);
+  }
+  return {
+    user_name: parseOptionalRequiredValue(parsed.user_name, DEFAULT_USER_NAME2),
+    pm_tool: String(parsed.pm_tool),
+    git_host: String(parsed.git_host),
+    branch_pattern: String(parsed.branch_pattern),
+    idle_threshold_minutes: idleThreshold,
+    communication_language: parseOptionalLanguage(
+      parsed.communication_language,
+      DEFAULT_COMMUNICATION_LANGUAGE2
+    ),
+    document_language: parseOptionalLanguage(
+      parsed.document_language,
+      DEFAULT_DOCUMENT_LANGUAGE2
+    )
+  };
+}
+function parseYamlFlatMap(content) {
+  const result = {};
+  for (const rawLine of content.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    const rawValue = line.slice(separatorIndex + 1).trim();
+    result[key] = stripWrappingQuotes2(rawValue);
+  }
+  return result;
+}
+function stripWrappingQuotes2(value) {
+  if (value.length < 2) {
+    return value;
+  }
+  const startsWithSingle = value.startsWith("'");
+  const startsWithDouble = value.startsWith('"');
+  if (startsWithSingle && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (startsWithDouble && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseOptionalLanguage(value, fallback) {
+  return parseOptionalRequiredValue(value, fallback);
+}
+function parseOptionalRequiredValue(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  const normalized = value.trim();
+  return normalized.length === 0 ? fallback : normalized;
+}
+
+// src/commands/install.ts
+var INVALID_INSTALL_CONFIG_ERROR_MESSAGE = "\u2717 No valid .tiqora.yaml found. Run npx tiqora init first.";
+async function runInstallCommand(options = {}) {
+  const projectRoot = options.projectRoot ?? options.cwd ?? process.cwd();
+  const runtimeConfig = ensureValidInstallConfig(projectRoot);
+  const resolution = await resolveEnvironmentTarget({
+    cwd: options.cwd,
+    homeDir: options.homeDir,
+    allowMultipleSelections: options.allowMultipleSelections ?? true,
+    selectEnvironment: options.selectEnvironment,
+    selectEnvironments: options.selectEnvironments,
+    promptManualPath: options.promptManualPath,
+    validateTargetPath: options.validateTargetPath,
+    manualPathBaseDir: options.manualPathBaseDir
+  });
+  if (runtimeConfig.pm_tool === "jira") {
+    ensureJiraMcpConfigured({
+      projectRoot,
+      homeDir: options.homeDir,
+      selectedTargets: resolution.selectedTargets
+    });
+  }
+  const deploymentSummary = await deployAgentAssets({
+    selectedTargets: resolution.selectedTargets,
+    templateSourceDir: options.templateSourceDir,
+    runtimeSourceDir: options.runtimeSourceDir,
+    projectRoot,
+    force: options.force ?? false,
+    confirmOverwrite: options.confirmOverwrite
+  });
+  return {
+    ...resolution,
+    deploymentSummary
+  };
+}
+function registerInstallCommand(program) {
+  program.command("install").description("Install tiqora assets into the selected environment.").option("-f, --force", "Overwrite existing command files without prompting.").action((commandOptions) => {
+    void runInstallCommand({ force: Boolean(commandOptions.force) }).then((result) => {
+      printDeploymentSummary2(result.deploymentSummary);
+      console.log("\u2713 tiqora installed");
+    }).catch(handleCommandError2);
+  });
+}
+function ensureValidInstallConfig(projectRoot) {
+  try {
+    return loadRuntimeConfig({ startDir: projectRoot });
+  } catch {
+    throw new Error(INVALID_INSTALL_CONFIG_ERROR_MESSAGE);
+  }
+}
+function printDeploymentSummary2(summary) {
+  if (summary.deployedTargets.length === 1) {
+    console.log(`Deployment target: ${summary.deployedTargets[0]}`);
+  } else {
+    console.log(
+      `Deployment targets (${summary.deployedTargets.length}):
+- ${summary.deployedTargets.join(
+        "\n- "
+      )}`
+    );
+  }
+  console.log(
+    `Deployment summary: copied=${summary.filesCopied.length}, overwritten=${summary.filesOverwritten.length}, skipped=${summary.filesSkipped.length}`
+  );
+  console.log(
+    summary.gitignorePatched ? "Patched .gitignore with .tiqora/." : ".gitignore already contains .tiqora/."
+  );
+  console.log(
+    summary.runtimeSummary.sourceFound ? `Runtime summary (_tiqora): copied=${summary.runtimeSummary.filesCopied.length}, overwritten=${summary.runtimeSummary.filesOverwritten.length}, skipped=${summary.runtimeSummary.filesSkipped.length}` : "Runtime summary (_tiqora): source not found, skipped."
+  );
+  console.log(
+    `Workspace summary: created=${summary.workspaceSummary.directoriesCreated.length}`
+  );
+}
+function handleCommandError2(error) {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  console.error(message.startsWith("\u2717") ? message : `\u2717 ${message}`);
+  return process.exit(1);
+}
+
+// src/index.ts
+var cli = new Command();
+cli.name("tiqora");
+cli.description("Tiqora CLI scaffold");
+cli.version(readPackageVersion(), "-v, --version", "output the current version");
+registerInitCommand(cli);
+registerInstallCommand(cli);
+if (shouldLoadRuntimeConfig(process.argv.slice(2))) {
+  loadRuntimeConfigOrExit();
+}
+cli.parse();
+function readPackageVersion() {
+  try {
+    const packageJsonPath = resolve7(process.cwd(), "package.json");
+    const content = readFileSync5(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(content);
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "0.1.0";
+}
+function shouldLoadRuntimeConfig(args) {
+  if (args.length === 0) {
+    return false;
+  }
+  const bypassFlags = /* @__PURE__ */ new Set(["-v", "--version", "-h", "--help"]);
+  if (args.some((arg) => bypassFlags.has(arg))) {
+    return false;
+  }
+  const firstCommand = args.find((arg) => !arg.startsWith("-"));
+  const installerCommands = /* @__PURE__ */ new Set(["init", "install"]);
+  if (firstCommand && installerCommands.has(firstCommand)) {
+    return false;
+  }
+  return true;
+}