x7-code-line 0.1.0

package/README.md

@@ -0,0 +1,333 @@
+# x7-code-line
+
+`x7-code-line` 是一个用于安装 Cursor、Codex 和 Git hooks 的 npm 模块。它用于在 agent 工作流中区分普通用户已有改动和 AI 生成改动，并在提交信息中自动追加 AI 行数 trailer。
+
+## 功能概览
+
+- 安装 Cursor 项目 hooks：写入当前安装目录的 `.cursor/hooks.json`。
+- 安装 Codex 项目 hooks：写入当前安装目录的 `.codex/hooks.json`。
+- 安装 Git hooks：为目标项目写入 `.git/hooks/pre-commit` 和 `.git/hooks/commit-msg`。
+- 初始化中心缓存目录：写入当前安装目录的 `.x7-code-line/`。
+- 支持多项目：多项目配置只用于替换目标项目的 Git hooks，以及在 `prompt-submit` / `stop` 时遍历读取这些项目的 `git diff`。
+- 记录普通 diff 行：prompt 提交时读取 `git diff`，把尚未进入 AI 缓存的 diff 行写入普通缓存。
+- 记录 AI diff 行：agent 结束时再次读取 `git diff`，把不属于普通缓存的 diff 行写入 AI 缓存。
+- 计算提交 AI 行数：`pre-commit` 对比当前仓库 staged diff 和中心 AI 缓存，计算本次提交真实包含的 AI diff 行数。
+- 写入 commit trailer：`commit-msg` 追加或替换 `x7-ai-lines: <数量>`。
+
+## 安装行为
+
+作为 npm 依赖安装时，`postinstall` 脚本使用 `INIT_CWD` 作为当前安装目录，也就是执行 `npm install` 时所在的项目目录。
+
+当前安装目录会创建或覆盖：
+
+```text
+.x7-code-line/install.json
+.x7-code-line/projects.json
+.x7-code-line/ai-diff-line-ids.json
+.x7-code-line/normal-diff-line-ids.json
+.cursor/hooks.json
+.codex/hooks.json
+```
+
+如果目标项目存在 `.git`，会创建或覆盖：
+
+```text
+.git/hooks/pre-commit
+.git/hooks/commit-msg
+```
+
+多项目配置只影响两类行为：
+
+- 为配置中的项目目录替换 `.git/hooks/pre-commit` 和 `.git/hooks/commit-msg`。
+- 执行 `prompt-submit` / `stop` 时遍历配置中的项目目录读取 `git diff`。
+
+`.cursor/hooks.json`、`.codex/hooks.json` 和 `.x7-code-line/` 只会写入当前安装目录，不会写入每个多项目目标目录。
+
+## Cursor Hooks
+
+Cursor 模板写入 `.cursor/hooks.json`：
+
+```json
+{
+  "hooks": {
+    "beforeSubmitPrompt": [
+      {
+        "command": "npx --no-install x7-code-line prompt-submit"
+      }
+    ],
+    "stop": [
+      {
+        "command": "npx --no-install x7-code-line stop"
+      }
+    ]
+  }
+}
+```
+
+## Codex Hooks
+
+Codex 模板写入 `.codex/hooks.json`：
+
+```json
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "command": "npx --no-install x7-code-line prompt-submit"
+      }
+    ],
+    "Stop": [
+      {
+        "command": "npx --no-install x7-code-line stop"
+      }
+    ]
+  }
+}
+```
+
+## Diff 行缓存
+
+`prompt-submit` 会进入每个已缓存的项目目录，执行：
+
+```sh
+git diff --no-ext-diff --unified=0 --no-color
+```
+
+然后对每个变更行计算 ID。ID 由以下信息生成：
+
+- 项目绝对路径
+- 文件路径
+- 变更类型：`add` 或 `delete`
+- 行号
+- 行内容
+
+如果该 ID 不在 AI diff 缓存中，就写入普通 diff 缓存：
+
+```text
+.x7-code-line/normal-diff-line-ids.json
+```
+
+`stop` 会再次读取每个项目的 `git diff` 并计算行 ID。如果某个 ID 不在普通 diff 缓存中，就写入 AI diff 缓存：
+
+```text
+.x7-code-line/ai-diff-line-ids.json
+```
+
+缓存按项目绝对路径分组，结构类似：
+
+```json
+{
+  "projects": {
+    "/path/to/repo-a": ["line-id-1"],
+    "/path/to/repo-b": ["line-id-2"]
+  }
+}
+```
+
+## Git Hooks
+
+安装器会生成 shell hook，并写入中心缓存目录：
+
+```sh
+X7_CODE_LINE_BASE='<当前安装目录>'
+export X7_CODE_LINE_BASE
+npx --no-install x7-code-line git-pre-commit
+```
+
+`pre-commit` 会读取当前仓库的 staged diff：
+
+```sh
+git diff --cached --no-ext-diff --unified=0 --no-color
+```
+
+然后使用当前仓库绝对路径从中心缓存中取出对应项目的 AI diff 行 ID，计算本次提交真正包含的 AI diff 行数，并写入：
+
+```text
+.x7-code-line/pending-commit.json
+```
+
+`commit-msg` 会读取该结果，并追加或替换 trailer：
+
+```text
+x7-ai-lines: 3
+```
+
+如果没有命中 AI diff 行，则写入：
+
+```text
+x7-ai-lines: 0
+```
+
+## 多项目安装
+
+通过 CLI 参数指定多个目标目录：
+
+```sh
+npx --no-install x7-code-line install --dir ../repo-a --dir ../repo-b
+```
+
+也可以在安装时通过环境变量指定。
+
+macOS / Linux 使用 `:` 作为目录分隔符：
+
+```sh
+X7_CODE_LINE_DIRS="../repo-a:../repo-b" npm install x7-code-line
+```
+
+Windows 使用 `;` 作为目录分隔符：
+
+```powershell
+$env:X7_CODE_LINE_DIRS = "../repo-a;../repo-b"
+npm install x7-code-line
+```
+
+## 配置文件
+
+可以通过 `--config` 或 `X7_CODE_LINE_CONFIG` 指定 JSON 配置文件：
+
+```json
+{
+  "dirs": ["../repo-a", "../repo-b"],
+  "gitDirs": [".git"]
+}
+```
+
+字段说明：
+
+- `dirs`：目标项目目录列表。
+- `gitDirs`：相对于每个目标项目目录的 Git 目录列表。
+
+## macOS 适配说明
+
+macOS 下整体可以直接使用，但需要注意以下几点：
+
+- Git hooks 使用 `#!/bin/sh`，macOS 自带 `/bin/sh`，无需额外安装 shell。
+- 安装器会对生成的 hook 文件执行 `chmod 755`。如果你手动复制 hook 文件，也需要执行：
+
+```sh
+chmod +x .git/hooks/pre-commit .git/hooks/commit-msg
+```
+
+- macOS / Linux 的多项目环境变量使用 `:` 分隔目录；不要使用 Windows 的 `;`。
+- 如果 Cursor 或 Codex 不是从终端启动，GUI 进程可能拿不到你的 shell `PATH`，导致 hook 中的 `npx` 找不到。遇到这种情况，优先从终端启动 Cursor/Codex，或确保 Node.js / npm 的安装路径已经进入 GUI 应用可见的 `PATH`。
+- 如果项目路径包含空格，安装器生成的 Git hook 会对 `X7_CODE_LINE_BASE` 做 shell quote，通常可以正常工作。
+- 使用 nvm、fnm、asdf 等 Node 版本管理器时，macOS GUI 应用经常不会加载对应初始化脚本。建议在运行 hooks 前确认：
+
+```sh
+which node
+which npm
+which npx
+```
+
+如果这些命令在 Cursor/Codex hook 环境中不可用，需要调整启动方式或 PATH。
+
+## Windows 适配说明
+
+- Git for Windows 会用 Git Bash 执行 `.git/hooks/*`，因此 `#!/bin/sh` hook 可以运行。
+- PowerShell 下设置多项目环境变量时使用 `$env:X7_CODE_LINE_DIRS`。
+- Windows 目录分隔符使用 `;`，例如：
+
+```powershell
+$env:X7_CODE_LINE_DIRS = "D:\repo-a;D:\repo-b"
+```
+
+## CLI 命令
+
+```sh
+x7-code-line install [--config path] [--dir path ...]
+x7-code-line prompt-submit
+x7-code-line stop
+x7-code-line git-pre-commit
+x7-code-line git-commit-msg <commit-msg-file>
+```
+
+## 本地验证
+
+```sh
+npm test
+npm pack --dry-run
+```
+
+## 发布到 npm
+
+首次发布和后续更新都建议先在本地完成校验：
+
+```sh
+npm test
+npm pack --dry-run
+```
+
+确认当前登录的 npm 账号：
+
+```sh
+npm whoami
+```
+
+如果还没有登录：
+
+```sh
+npm login
+```
+
+### 首次发布
+
+确认 `package.json` 中的包名和版本号正确后，执行：
+
+```sh
+npm publish
+```
+
+如果 npm 账号开启了 2FA，通常需要附带 OTP：
+
+```sh
+npm publish --otp <6位验证码>
+```
+
+如果将来改为 scope 包并需要公开发布，则使用：
+
+```sh
+npm publish --access public --otp <6位验证码>
+```
+
+### 更新已发布版本
+
+每次发布新版本前，先提升版本号：
+
+```sh
+npm version patch
+```
+
+也可以按需要使用：
+
+```sh
+npm version minor
+npm version major
+```
+
+然后重新发布：
+
+```sh
+npm publish --otp <6位验证码>
+```
+
+### 常见发布流程
+
+```sh
+npm test
+npm pack --dry-run
+npm version patch
+npm publish --otp <6位验证码>
+```
+
+### 2FA 与 token
+
+如果 npm 账号开启了两步验证，发布时需要满足以下任一条件：
+
+- 直接在 `npm publish` 时传入 `--otp`。
+- 使用具备 publish 权限并允许 bypass 2FA 的 npm access token。
+
+手动在本机发布时，最直接的方式通常是：
+
+```sh
+npm publish --otp <当前验证码>
+```

package/bin/x7-code-line.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+const { runCli } = require("../src/cli");
+
+runCli(process.argv.slice(2)).catch((error) => {
+  console.error(`[x7-code-line] ${error.message}`);
+  process.exit(1);
+});

package/hooks/git/commit-msg

@@ -0,0 +1,4 @@
+#!/bin/sh
+set -eu
+
+npx --no-install x7-code-line git-commit-msg "$1"

package/hooks/git/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+set -eu
+
+npx --no-install x7-code-line git-pre-commit "$@"

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "x7-code-line",
+  "version": "0.1.0",
+  "description": "Install Cursor, Codex, and git hooks for x7 code line workflows.",
+  "main": "src/index.js",
+  "bin": {
+    "x7-code-line": "bin/x7-code-line.js"
+  },
+  "scripts": {
+    "postinstall": "node src/postinstall.js",
+    "test": "node test/install.test.js"
+  },
+  "files": [
+    "bin/",
+    "hooks/",
+    "src/",
+    "templates/"
+  ],
+  "keywords": [
+    "cursor",
+    "codex",
+    "hooks",
+    "git-hooks"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/agent-hooks.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const {
+  AI_DIFF_CACHE_FILE,
+  NORMAL_DIFF_CACHE_FILE,
+  addProjectId,
+  getProjectIds,
+  readLineIdCache,
+  readProjects,
+  writeLineIdCache
+} = require("./cache");
+const { getGitDiffLineIds } = require("./diff-lines");
+
+function handlePromptSubmit(baseDir = process.env.INIT_CWD || process.cwd()) {
+  const projects = readProjects(baseDir);
+  const aiCache = readLineIdCache(baseDir, AI_DIFF_CACHE_FILE);
+  const normalCache = readLineIdCache(baseDir, NORMAL_DIFF_CACHE_FILE);
+
+  for (const projectDir of projects) {
+    const aiIds = getProjectIds(aiCache, projectDir);
+    for (const id of safelyGetDiffLineIds(projectDir)) {
+      if (!aiIds.has(id)) {
+        addProjectId(normalCache, projectDir, id);
+      }
+    }
+  }
+
+  writeLineIdCache(baseDir, NORMAL_DIFF_CACHE_FILE, normalCache);
+}
+
+function handleStop(baseDir = process.env.INIT_CWD || process.cwd()) {
+  const projects = readProjects(baseDir);
+  const aiCache = readLineIdCache(baseDir, AI_DIFF_CACHE_FILE);
+  const normalCache = readLineIdCache(baseDir, NORMAL_DIFF_CACHE_FILE);
+
+  for (const projectDir of projects) {
+    const normalIds = getProjectIds(normalCache, projectDir);
+    for (const id of safelyGetDiffLineIds(projectDir)) {
+      if (!normalIds.has(id)) {
+        addProjectId(aiCache, projectDir, id);
+      }
+    }
+  }
+
+  writeLineIdCache(baseDir, AI_DIFF_CACHE_FILE, aiCache);
+}
+
+function safelyGetDiffLineIds(projectDir) {
+  try {
+    return getGitDiffLineIds(projectDir);
+  } catch (error) {
+    if (process.env.X7_CODE_LINE_DEBUG === "1") {
+      console.error(`[x7-code-line] skip ${projectDir}: ${error.message}`);
+    }
+    return [];
+  }
+}
+
+module.exports = {
+  handlePromptSubmit,
+  handleStop
+};

package/src/cache.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const CACHE_DIR_NAME = ".x7-code-line";
+const PROJECTS_CACHE_FILE = "projects.json";
+const AI_DIFF_CACHE_FILE = "ai-diff-line-ids.json";
+const NORMAL_DIFF_CACHE_FILE = "normal-diff-line-ids.json";
+const PENDING_COMMIT_FILE = "pending-commit.json";
+
+function getCacheDir(baseDir = process.env.INIT_CWD || process.cwd()) {
+  return path.join(path.resolve(baseDir), CACHE_DIR_NAME);
+}
+
+function ensureCacheFiles(baseDir) {
+  const cacheDir = getCacheDir(baseDir);
+  fs.mkdirSync(cacheDir, { recursive: true });
+  ensureJson(path.join(cacheDir, PROJECTS_CACHE_FILE), { projects: [] });
+  ensureJson(path.join(cacheDir, AI_DIFF_CACHE_FILE), { projects: {} });
+  ensureJson(path.join(cacheDir, NORMAL_DIFF_CACHE_FILE), { projects: {} });
+  return cacheDir;
+}
+
+function writeProjects(baseDir, projectDirs) {
+  const cacheDir = ensureCacheFiles(baseDir);
+  const projects = [...new Set(projectDirs.map((dir) => path.resolve(dir)))];
+  writeJson(path.join(cacheDir, PROJECTS_CACHE_FILE), { projects });
+}
+
+function readProjects(baseDir = process.env.INIT_CWD || process.cwd()) {
+  const cacheDir = ensureCacheFiles(baseDir);
+  const cache = readJson(path.join(cacheDir, PROJECTS_CACHE_FILE), { projects: [] });
+  const projects = Array.isArray(cache.projects) ? cache.projects : [];
+  return projects.map((project) => path.resolve(project));
+}
+
+function readLineIdCache(baseDir, fileName) {
+  const cacheDir = ensureCacheFiles(baseDir);
+  const cache = readJson(path.join(cacheDir, fileName), { projects: {} });
+  return cache && typeof cache === "object" && !Array.isArray(cache) ? cache : { projects: {} };
+}
+
+function writeLineIdCache(baseDir, fileName, cache) {
+  const cacheDir = ensureCacheFiles(baseDir);
+  writeJson(path.join(cacheDir, fileName), cache);
+}
+
+function getProjectIds(cache, projectDir) {
+  const key = path.resolve(projectDir);
+  const ids = cache.projects && Array.isArray(cache.projects[key]) ? cache.projects[key] : [];
+  return new Set(ids);
+}
+
+function addProjectId(cache, projectDir, id) {
+  const key = path.resolve(projectDir);
+  if (!cache.projects || typeof cache.projects !== "object" || Array.isArray(cache.projects)) {
+    cache.projects = {};
+  }
+  if (!Array.isArray(cache.projects[key])) {
+    cache.projects[key] = [];
+  }
+  if (!cache.projects[key].includes(id)) {
+    cache.projects[key].push(id);
+    return true;
+  }
+  return false;
+}
+
+function ensureJson(filePath, defaultValue) {
+  if (!fs.existsSync(filePath)) {
+    writeJson(filePath, defaultValue);
+  }
+}
+
+function readJson(filePath, defaultValue) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return defaultValue;
+  }
+}
+
+function writeJson(filePath, value) {
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+module.exports = {
+  AI_DIFF_CACHE_FILE,
+  CACHE_DIR_NAME,
+  NORMAL_DIFF_CACHE_FILE,
+  PENDING_COMMIT_FILE,
+  PROJECTS_CACHE_FILE,
+  addProjectId,
+  ensureCacheFiles,
+  getCacheDir,
+  getProjectIds,
+  readLineIdCache,
+  readProjects,
+  writeLineIdCache,
+  writeProjects
+};

package/src/cli.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { handlePromptSubmit, handleStop } = require("./agent-hooks");
+const { install } = require("./install");
+const { appendCommitTrailer } = require("./git-trailer");
+const {
+  AI_DIFF_CACHE_FILE,
+  PENDING_COMMIT_FILE,
+  getCacheDir,
+  getProjectIds,
+  readLineIdCache
+} = require("./cache");
+const { getGitDiffLineIds } = require("./diff-lines");
+
+async function runCli(argv) {
+  const [command, ...rest] = argv;
+
+  switch (command) {
+    case "install":
+      return install(parseInstallOptions(rest));
+    case "prompt-submit":
+    case "cursor-before-submit-prompt":
+    case "codex-user-prompt-submit":
+      return handlePromptSubmit();
+    case "stop":
+    case "cursor-stop":
+    case "codex-stop":
+      return handleStop();
+    case "git-pre-commit":
+      return runGitPreCommit();
+    case "git-commit-msg":
+      return runGitCommitMsg(rest);
+    case "-h":
+    case "--help":
+    case undefined:
+      return printHelp();
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+
+function parseInstallOptions(args) {
+  const options = {
+    targetDirs: [],
+    configPath: undefined
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--config" || arg === "-c") {
+      options.configPath = requireValue(args, (index += 1), arg);
+    } else if (arg === "--dir" || arg === "-d") {
+      options.targetDirs.push(requireValue(args, (index += 1), arg));
+    } else if (arg === "--dirs") {
+      options.targetDirs.push(...requireValue(args, (index += 1), arg).split(","));
+    } else {
+      options.targetDirs.push(arg);
+    }
+  }
+
+  return options;
+}
+
+function requireValue(args, index, flag) {
+  const value = args[index];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+
+async function runGitPreCommit() {
+  const baseDir = getBaseDir();
+  const projectDir = process.cwd();
+  const aiCache = readLineIdCache(baseDir, AI_DIFF_CACHE_FILE);
+  const aiIds = getProjectIds(aiCache, projectDir);
+  const stagedIds = getGitDiffLineIds(projectDir, { staged: true });
+  const aiLineCount = stagedIds.filter((id) => aiIds.has(id)).length;
+  const pendingPath = path.join(getCacheDir(baseDir), PENDING_COMMIT_FILE);
+  fs.writeFileSync(
+    pendingPath,
+    `${JSON.stringify({ projects: { [path.resolve(projectDir)]: { aiLineCount } } }, null, 2)}\n`
+  );
+
+  if (process.env.X7_CODE_LINE_DEBUG === "1") {
+    console.error(`[x7-code-line] git pre-commit ai lines: ${aiLineCount}`);
+  }
+}
+
+async function runGitCommitMsg(args) {
+  const commitMsgPath = args[0];
+  if (!commitMsgPath) {
+    throw new Error("git-commit-msg requires a commit message file path");
+  }
+
+  appendCommitTrailer(path.resolve(commitMsgPath), readPendingAiLineCount(getBaseDir(), process.cwd()));
+}
+
+function getBaseDir() {
+  return process.env.X7_CODE_LINE_BASE || process.env.INIT_CWD || process.cwd();
+}
+
+function readPendingAiLineCount(baseDir, projectDir) {
+  const pendingPath = path.join(getCacheDir(baseDir), PENDING_COMMIT_FILE);
+  try {
+    const pending = JSON.parse(fs.readFileSync(pendingPath, "utf8"));
+    const project = pending.projects && pending.projects[path.resolve(projectDir)];
+    return Number.isInteger(project && project.aiLineCount) ? project.aiLineCount : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function printHelp() {
+  const text = [
+    "Usage:",
+    "  x7-code-line install [--config path] [--dir path ...]",
+    "  x7-code-line prompt-submit",
+    "  x7-code-line stop",
+    "  x7-code-line git-pre-commit",
+    "  x7-code-line git-commit-msg <commit-msg-file>"
+  ].join("\n");
+  fs.writeSync(process.stdout.fd, `${text}\n`);
+}
+
+module.exports = {
+  runCli
+};

package/src/diff-lines.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const crypto = require("node:crypto");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+function getGitDiffLineIds(projectDir, options = {}) {
+  const args = ["diff", "--no-ext-diff", "--unified=0", "--no-color"];
+  if (options.staged) {
+    args.splice(1, 0, "--cached");
+  }
+
+  const diff = execFileSync("git", args, {
+    cwd: projectDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+
+  return parseDiffLineIds(projectDir, diff);
+}
+
+function parseDiffLineIds(projectDir, diff) {
+  const ids = [];
+  let currentFile = "";
+  let oldLine = 0;
+  let newLine = 0;
+
+  for (const line of diff.split(/\r?\n/u)) {
+    if (line.startsWith("+++ b/")) {
+      currentFile = line.slice("+++ b/".length);
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      currentFile = line.slice("+++ ".length);
+      continue;
+    }
+
+    const hunk = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/u.exec(line);
+    if (hunk) {
+      oldLine = Number(hunk[1]);
+      newLine = Number(hunk[2]);
+      continue;
+    }
+
+    if (!currentFile || line.startsWith("diff --git") || line.startsWith("index ")) {
+      continue;
+    }
+
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      ids.push(makeLineId(projectDir, currentFile, "add", newLine, line.slice(1)));
+      newLine += 1;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      ids.push(makeLineId(projectDir, currentFile, "delete", oldLine, line.slice(1)));
+      oldLine += 1;
+    } else if (line.startsWith(" ")) {
+      oldLine += 1;
+      newLine += 1;
+    }
+  }
+
+  return ids;
+}
+
+function makeLineId(projectDir, filePath, changeType, lineNumber, content) {
+  return crypto
+    .createHash("sha256")
+    .update(
+      JSON.stringify({
+        project: path.resolve(projectDir),
+        file: filePath,
+        changeType,
+        lineNumber,
+        content
+      })
+    )
+    .digest("hex");
+}
+
+module.exports = {
+  getGitDiffLineIds,
+  makeLineId,
+  parseDiffLineIds
+};

package/src/git-trailer.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const { execFileSync } = require("node:child_process");
+
+const TRAILER_TOKEN = "x7-ai-lines";
+
+function appendCommitTrailer(commitMsgPath, aiLineCount = 0) {
+  const original = fs.readFileSync(commitMsgPath, "utf8");
+  const withTrailer = addTrailerWithGit(original, aiLineCount) || addTrailer(original, aiLineCount);
+  fs.writeFileSync(commitMsgPath, withTrailer);
+}
+
+function addTrailerWithGit(message, aiLineCount) {
+  try {
+    return execFileSync(
+      "git",
+      ["interpret-trailers", "--if-exists=replace", `--trailer=${TRAILER_TOKEN}=${aiLineCount}`],
+      {
+        input: message,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function addTrailer(message, aiLineCount) {
+  const normalized = message.replace(/\s+$/u, "");
+  const trailerPattern = new RegExp(`^${TRAILER_TOKEN}:`, "imu");
+  const withoutExisting = normalized
+    .split(/\r?\n/u)
+    .filter((line) => !trailerPattern.test(line))
+    .join(os.EOL)
+    .replace(/\s+$/u, "");
+
+  return `${withoutExisting}${os.EOL}${os.EOL}${TRAILER_TOKEN}: ${aiLineCount}${os.EOL}`;
+}
+
+module.exports = {
+  TRAILER_TOKEN,
+  appendCommitTrailer
+};

package/src/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+const { install } = require("./install");
+
+module.exports = {
+  install
+};

package/src/install.js

@@ -0,0 +1,171 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { CACHE_DIR_NAME, ensureCacheFiles, writeProjects } = require("./cache");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+
+function install(options = {}) {
+  const config = readConfig(options.configPath || process.env.X7_CODE_LINE_CONFIG);
+  const targetDirs = normalizeTargetDirs(options.targetDirs, config);
+  const cacheBaseDir = path.resolve(options.cacheBaseDir || process.env.INIT_CWD || process.cwd());
+
+  installCurrentProjectFiles(cacheBaseDir);
+  for (const targetDir of targetDirs) {
+    installGitHooksInto(targetDir, config, cacheBaseDir);
+  }
+  writeProjects(cacheBaseDir, targetDirs);
+
+  return targetDirs;
+}
+
+function installFromPostinstall() {
+  const envDirs = splitList(process.env.X7_CODE_LINE_DIRS);
+  const targetDirs = envDirs.length > 0 ? envDirs : [process.env.INIT_CWD || process.cwd()];
+
+  return install({
+    configPath: process.env.X7_CODE_LINE_CONFIG,
+    targetDirs
+  });
+}
+
+function installCurrentProjectFiles(cacheBaseDir) {
+  const resolvedTarget = path.resolve(cacheBaseDir);
+  ensureDirectory(resolvedTarget);
+
+  const cacheDir = path.join(resolvedTarget, CACHE_DIR_NAME);
+  ensureCacheFiles(resolvedTarget);
+  writeJson(path.join(cacheDir, "install.json"), {
+    packageName: "x7-code-line",
+    installedAt: new Date().toISOString(),
+    moduleRoot: PACKAGE_ROOT
+  });
+
+  copyFile(
+    path.join(PACKAGE_ROOT, "templates", ".cursor", "hooks.json"),
+    path.join(resolvedTarget, ".cursor", "hooks.json")
+  );
+  copyFile(
+    path.join(PACKAGE_ROOT, "templates", ".codex", "hooks.json"),
+    path.join(resolvedTarget, ".codex", "hooks.json")
+  );
+}
+
+function installGitHooksInto(targetDir, config = {}, cacheBaseDir = process.cwd()) {
+  const resolvedTarget = path.resolve(targetDir);
+  ensureDirectory(resolvedTarget);
+  const gitTargets = resolveGitTargets(resolvedTarget, config);
+  for (const gitDir of gitTargets) {
+    installGitHooks(gitDir, cacheBaseDir);
+  }
+}
+
+function installGitHooks(gitDir, cacheBaseDir) {
+  const hooksDir = path.join(gitDir, "hooks");
+  ensureDirectory(hooksDir);
+
+  writeExecutable(path.join(hooksDir, "pre-commit"), makeGitHook("git-pre-commit", cacheBaseDir));
+  writeExecutable(path.join(hooksDir, "commit-msg"), makeGitHook("git-commit-msg \"$1\"", cacheBaseDir));
+}
+
+function resolveGitTargets(targetDir, config = {}) {
+  const configured = Array.isArray(config.gitDirs) ? config.gitDirs : [];
+  const gitDirs = configured.map((gitDir) => path.resolve(targetDir, gitDir));
+  const defaultGitDir = path.join(targetDir, ".git");
+
+  if (fs.existsSync(defaultGitDir)) {
+    gitDirs.unshift(defaultGitDir);
+  }
+
+  return [...new Set(gitDirs)].filter((gitDir) => {
+    try {
+      return fs.statSync(gitDir).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+
+function readConfig(configPath) {
+  if (!configPath) {
+    return {};
+  }
+
+  const resolvedConfigPath = path.resolve(configPath);
+  const raw = fs.readFileSync(resolvedConfigPath, "utf8");
+  const config = JSON.parse(raw);
+
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(`Config must be a JSON object: ${resolvedConfigPath}`);
+  }
+
+  return config;
+}
+
+function normalizeTargetDirs(targetDirs = [], config = {}) {
+  const configuredDirs = Array.isArray(config.dirs) ? config.dirs : [];
+  const dirs = [...targetDirs, ...configuredDirs].map((dir) => String(dir || "").trim()).filter(Boolean);
+
+  if (dirs.length === 0) {
+    return [process.env.INIT_CWD || process.cwd()];
+  }
+
+  return [...new Set(dirs)].map((dir) => path.resolve(dir));
+}
+
+function splitList(value) {
+  return String(value || "")
+    .split(path.delimiter)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function copyFile(source, destination) {
+  ensureDirectory(path.dirname(destination));
+  fs.copyFileSync(source, destination);
+  try {
+    fs.chmodSync(destination, 0o755);
+  } catch {
+    // Windows and some package managers may ignore chmod.
+  }
+}
+
+function writeExecutable(destination, content) {
+  ensureDirectory(path.dirname(destination));
+  fs.writeFileSync(destination, content);
+  try {
+    fs.chmodSync(destination, 0o755);
+  } catch {
+    // Windows and some package managers may ignore chmod.
+  }
+}
+
+function makeGitHook(command, cacheBaseDir) {
+  return [
+    "#!/bin/sh",
+    "set -eu",
+    `X7_CODE_LINE_BASE=${shellQuote(path.resolve(cacheBaseDir))}`,
+    "export X7_CODE_LINE_BASE",
+    `npx --no-install x7-code-line ${command}`,
+    ""
+  ].join("\n");
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function writeJson(destination, value) {
+  fs.writeFileSync(destination, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function ensureDirectory(directory) {
+  fs.mkdirSync(directory, { recursive: true });
+}
+
+module.exports = {
+  CACHE_DIR_NAME,
+  install,
+  installFromPostinstall
+};

package/src/postinstall.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const { installFromPostinstall } = require("./install");
+
+try {
+  const installed = installFromPostinstall();
+  if (process.env.X7_CODE_LINE_DEBUG === "1") {
+    console.error(`[x7-code-line] installed into ${installed.join(", ")}`);
+  }
+} catch (error) {
+  console.error(`[x7-code-line] postinstall failed: ${error.message}`);
+  process.exit(1);
+}

package/templates/.codex/hooks.json

@@ -0,0 +1,14 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "command": "npx --no-install x7-code-line prompt-submit"
+      }
+    ],
+    "Stop": [
+      {
+        "command": "npx --no-install x7-code-line stop"
+      }
+    ]
+  }
+}

package/templates/.cursor/hooks.json

@@ -0,0 +1,14 @@
+{
+  "hooks": {
+    "beforeSubmitPrompt": [
+      {
+        "command": "npx --no-install x7-code-line prompt-submit"
+      }
+    ],
+    "stop": [
+      {
+        "command": "npx --no-install x7-code-line stop"
+      }
+    ]
+  }
+}