open-think 0.1.14 → 0.2.0

package/dist/chunk-K2FT7ZHJ.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+
+// src/lib/git.ts
+import { execFileSync } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+
+// src/lib/paths.ts
+import path from "path";
+import fs from "fs";
+function getHome() {
+  const home = process.env.HOME;
+  if (!home) {
+    throw new Error("HOME environment variable is not set");
+  }
+  return home;
+}
+function sanitizeName(name) {
+  if (!name || /[\/\\\.]{2}/.test(name) || /[^a-zA-Z0-9_-]/.test(name)) {
+    throw new Error(`Invalid cortex name: "${name}". Use only alphanumeric characters, hyphens, and underscores.`);
+  }
+  return name;
+}
+function getThinkHome() {
+  const thinkHome = process.env.THINK_HOME;
+  if (thinkHome === void 0 || thinkHome === "") return null;
+  return thinkHome;
+}
+function getThinkDir() {
+  return getThinkHome() ?? path.join(getHome(), ".think");
+}
+function getThinkConfigDir() {
+  const thinkHome = getThinkHome();
+  if (thinkHome) return path.join(thinkHome, "config");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(getHome(), ".config");
+  return path.join(xdgConfig, "think");
+}
+function getThinkDataDir() {
+  const thinkHome = getThinkHome();
+  if (thinkHome) return path.join(thinkHome, "data");
+  const xdgData = process.env.XDG_DATA_HOME || path.join(getHome(), ".local", "share");
+  return path.join(xdgData, "think");
+}
+function getEngramsDir() {
+  return path.join(getThinkDir(), "engrams");
+}
+function getEngramDbPath(cortexName) {
+  return path.join(getEngramsDir(), `${sanitizeName(cortexName)}.db`);
+}
+function getRepoPath() {
+  return path.join(getThinkDir(), "repo");
+}
+function getLongtermDir() {
+  return path.join(getThinkDir(), "longterm");
+}
+function getLongtermPath(cortexName) {
+  return path.join(getLongtermDir(), `${sanitizeName(cortexName)}.md`);
+}
+function getCuratorMdPath() {
+  return path.join(getThinkDir(), "curator.md");
+}
+function ensureThinkDirs() {
+  fs.mkdirSync(getEngramsDir(), { recursive: true });
+  fs.mkdirSync(getLongtermDir(), { recursive: true });
+}
+
+// src/lib/config.ts
+import path2 from "path";
+import fs2 from "fs";
+import { v4 as uuidv4 } from "uuid";
+function getConfigDir() {
+  return getThinkConfigDir();
+}
+function configPath() {
+  return path2.join(getConfigDir(), "config.json");
+}
+function saveConfig(config) {
+  const dir = getConfigDir();
+  fs2.mkdirSync(dir, { recursive: true });
+  fs2.writeFileSync(configPath(), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function getConfig() {
+  const fp = configPath();
+  if (fs2.existsSync(fp)) {
+    const raw = fs2.readFileSync(fp, "utf-8");
+    return JSON.parse(raw);
+  }
+  const config = {
+    peerId: uuidv4(),
+    syncPort: 47821
+  };
+  saveConfig(config);
+  return config;
+}
+
+// src/lib/git.ts
+function runGit(args, cwd) {
+  const repoPath = cwd ?? getRepoPath();
+  return execFileSync("git", args, {
+    cwd: repoPath,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function ensureRepoCloned() {
+  const config = getConfig();
+  if (!config.cortex?.repo) {
+    throw new Error("No cortex repo configured. Run: think cortex setup");
+  }
+  const repoPath = getRepoPath();
+  if (fs3.existsSync(path3.join(repoPath, ".git"))) {
+    const remote = runGit(["remote", "get-url", "origin"], repoPath);
+    if (remote !== config.cortex.repo) {
+      throw new Error(`Repo at ${repoPath} points to ${remote}, expected ${config.cortex.repo}`);
+    }
+    return;
+  }
+  fs3.mkdirSync(repoPath, { recursive: true });
+  execFileSync("git", ["clone", "--no-checkout", config.cortex.repo, repoPath], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+function branchExists(branchName) {
+  try {
+    runGit(["ls-remote", "--exit-code", "--heads", "origin", branchName]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createOrphanBranch(branchName) {
+  runGit(["checkout", "--orphan", branchName]);
+  try {
+    runGit(["rm", "-rf", "."]);
+  } catch {
+  }
+  const repoPath = getRepoPath();
+  fs3.writeFileSync(path3.join(repoPath, "memories.jsonl"), "", "utf-8");
+  runGit(["add", "memories.jsonl"]);
+  runGit(["commit", "-m", `init: create cortex ${branchName}`]);
+  runGit(["push", "--set-upstream", "origin", branchName]);
+}
+function fetchBranch(branchName) {
+  runGit(["fetch", "origin", branchName]);
+}
+function readFileFromBranch(branchName, filePath) {
+  try {
+    return runGit(["show", `origin/${branchName}:${filePath}`]);
+  } catch {
+    return null;
+  }
+}
+function appendAndCommit(branchName, newLines, commitMessage, maxRetries = 3) {
+  const repoPath = getRepoPath();
+  const memoriesPath = path3.join(repoPath, "memories.jsonl");
+  try {
+    runGit(["switch", branchName]);
+  } catch {
+    runGit(["switch", "-c", branchName, `origin/${branchName}`]);
+  }
+  try {
+    runGit(["pull", "--rebase", "origin", branchName]);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("CONFLICT") || message.includes("could not apply")) {
+      try {
+        runGit(["rebase", "--abort"]);
+      } catch {
+      }
+      throw new Error(`Rebase conflict on ${branchName}. This should not happen with append-only files \u2014 check for manual edits to memories.jsonl.`);
+    }
+  }
+  const content = newLines.join("\n") + "\n";
+  fs3.appendFileSync(memoriesPath, content, "utf-8");
+  runGit(["add", "memories.jsonl"]);
+  runGit(["commit", "-m", commitMessage]);
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      runGit(["push", "origin", branchName]);
+      return;
+    } catch {
+      if (attempt === maxRetries) {
+        throw new Error(`Push failed after ${maxRetries} attempts. Run 'think curate' again.`);
+      }
+      runGit(["pull", "--rebase", "origin", branchName]);
+    }
+  }
+}
+function getFileLog(branchName, filePath) {
+  return runGit(["log", "--oneline", `origin/${branchName}`, "--", filePath]);
+}
+function listRemoteBranches() {
+  const output = runGit(["ls-remote", "--heads", "origin"]);
+  return output.trim().split("\n").filter(Boolean).map((line) => line.split("	")[1]?.replace("refs/heads/", "")).filter(Boolean);
+}
+
+export {
+  getThinkDataDir,
+  getEngramsDir,
+  getEngramDbPath,
+  getLongtermPath,
+  getCuratorMdPath,
+  ensureThinkDirs,
+  getConfigDir,
+  saveConfig,
+  getConfig,
+  ensureRepoCloned,
+  branchExists,
+  createOrphanBranch,
+  fetchBranch,
+  readFileFromBranch,
+  appendAndCommit,
+  getFileLog,
+  listRemoteBranches
+};

package/dist/git-Y3N244VA.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import {
+  appendAndCommit,
+  branchExists,
+  createOrphanBranch,
+  ensureRepoCloned,
+  fetchBranch,
+  getFileLog,
+  listRemoteBranches,
+  readFileFromBranch
+} from "./chunk-K2FT7ZHJ.js";
+export {
+  appendAndCommit,
+  branchExists,
+  createOrphanBranch,
+  ensureRepoCloned,
+  fetchBranch,
+  getFileLog,
+  listRemoteBranches,
+  readFileFromBranch
+};