decision-memory 0.1.2 → 0.1.4

package/dist/{index.js → index.cjs}

@@ -1,20 +1,34 @@
 #!/usr/bin/env node
-import {
-  __commonJS,
-  __require,
-  __toESM,
-  appendDecision,
-  formatContextSummaryAsToon,
-  initDecisionFile,
-  parseDecisionFile,
-  resolveDecisionFilePath,
-  searchDecisions,
-  serializeDecisionRow
-} from "./chunk-5VFZ3YOK.js";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // node_modules/commander/lib/error.js
 var require_error = __commonJS({
-  "node_modules/commander/lib/error.js"(exports) {
+  "node_modules/commander/lib/error.js"(exports2) {
     var CommanderError2 = class extends Error {
       /**
        * Constructs the CommanderError class
@@ -42,14 +56,14 @@ var require_error = __commonJS({
         this.name = this.constructor.name;
       }
     };
-    exports.CommanderError = CommanderError2;
-    exports.InvalidArgumentError = InvalidArgumentError2;
+    exports2.CommanderError = CommanderError2;
+    exports2.InvalidArgumentError = InvalidArgumentError2;
   }
 });
 
 // node_modules/commander/lib/argument.js
 var require_argument = __commonJS({
-  "node_modules/commander/lib/argument.js"(exports) {
+  "node_modules/commander/lib/argument.js"(exports2) {
     var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
     var Argument2 = class {
       /**
@@ -169,14 +183,14 @@ var require_argument = __commonJS({
       const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
       return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
     }
-    exports.Argument = Argument2;
-    exports.humanReadableArgName = humanReadableArgName;
+    exports2.Argument = Argument2;
+    exports2.humanReadableArgName = humanReadableArgName;
   }
 });
 
 // node_modules/commander/lib/help.js
 var require_help = __commonJS({
-  "node_modules/commander/lib/help.js"(exports) {
+  "node_modules/commander/lib/help.js"(exports2) {
     var { humanReadableArgName } = require_argument();
     var Help2 = class {
       constructor() {
@@ -584,13 +598,13 @@ var require_help = __commonJS({
         }).join("\n");
       }
     };
-    exports.Help = Help2;
+    exports2.Help = Help2;
   }
 });
 
 // node_modules/commander/lib/option.js
 var require_option = __commonJS({
-  "node_modules/commander/lib/option.js"(exports) {
+  "node_modules/commander/lib/option.js"(exports2) {
     var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
     var Option2 = class {
       /**
@@ -855,14 +869,14 @@ var require_option = __commonJS({
       }
       return { shortFlag, longFlag };
     }
-    exports.Option = Option2;
-    exports.DualOptions = DualOptions;
+    exports2.Option = Option2;
+    exports2.DualOptions = DualOptions;
   }
 });
 
 // node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS({
-  "node_modules/commander/lib/suggestSimilar.js"(exports) {
+  "node_modules/commander/lib/suggestSimilar.js"(exports2) {
     var maxDistance = 3;
     function editDistance(a, b) {
       if (Math.abs(a.length - b.length) > maxDistance)
@@ -936,18 +950,18 @@ var require_suggestSimilar = __commonJS({
       }
       return "";
     }
-    exports.suggestSimilar = suggestSimilar;
+    exports2.suggestSimilar = suggestSimilar;
   }
 });
 
 // node_modules/commander/lib/command.js
 var require_command = __commonJS({
-  "node_modules/commander/lib/command.js"(exports) {
-    var EventEmitter = __require("events").EventEmitter;
-    var childProcess = __require("child_process");
-    var path2 = __require("path");
-    var fs4 = __require("fs");
-    var process2 = __require("process");
+  "node_modules/commander/lib/command.js"(exports2) {
+    var EventEmitter = require("events").EventEmitter;
+    var childProcess = require("child_process");
+    var path3 = require("path");
+    var fs5 = require("fs");
+    var process2 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
     var { Help: Help2 } = require_help();
@@ -1879,11 +1893,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path2.resolve(baseDir, baseName);
-          if (fs4.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path2.extname(baseName))) return void 0;
+          const localBin = path3.resolve(baseDir, baseName);
+          if (fs5.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path3.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs4.existsSync(`${localBin}${ext}`)
+            (ext) => fs5.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1895,21 +1909,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs4.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path2.resolve(
-            path2.dirname(resolvedScriptPath),
+          executableDir = path3.resolve(
+            path3.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path2.basename(
+            const legacyName = path3.basename(
               this._scriptPath,
-              path2.extname(this._scriptPath)
+              path3.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1920,7 +1934,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path2.extname(executableFile));
+        launchWithNode = sourceExt.includes(path3.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -2762,7 +2776,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path2.basename(filename, path2.extname(filename));
+        this._name = path3.basename(filename, path3.extname(filename));
         return this;
       }
       /**
@@ -2776,9 +2790,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path3) {
-        if (path3 === void 0) return this._executableDir;
-        this._executableDir = path3;
+      executableDir(path4) {
+        if (path4 === void 0) return this._executableDir;
+        this._executableDir = path4;
         return this;
       }
       /**
@@ -2983,29 +2997,29 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return arg;
       });
     }
-    exports.Command = Command2;
+    exports2.Command = Command2;
   }
 });
 
 // node_modules/commander/index.js
 var require_commander = __commonJS({
-  "node_modules/commander/index.js"(exports) {
+  "node_modules/commander/index.js"(exports2) {
     var { Argument: Argument2 } = require_argument();
     var { Command: Command2 } = require_command();
     var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error();
     var { Help: Help2 } = require_help();
     var { Option: Option2 } = require_option();
-    exports.program = new Command2();
-    exports.createCommand = (name) => new Command2(name);
-    exports.createOption = (flags, description) => new Option2(flags, description);
-    exports.createArgument = (name, description) => new Argument2(name, description);
-    exports.Command = Command2;
-    exports.Option = Option2;
-    exports.Argument = Argument2;
-    exports.Help = Help2;
-    exports.CommanderError = CommanderError2;
-    exports.InvalidArgumentError = InvalidArgumentError2;
-    exports.InvalidOptionArgumentError = InvalidArgumentError2;
+    exports2.program = new Command2();
+    exports2.createCommand = (name) => new Command2(name);
+    exports2.createOption = (flags, description) => new Option2(flags, description);
+    exports2.createArgument = (name, description) => new Argument2(name, description);
+    exports2.Command = Command2;
+    exports2.Option = Option2;
+    exports2.Argument = Argument2;
+    exports2.Help = Help2;
+    exports2.CommanderError = CommanderError2;
+    exports2.InvalidArgumentError = InvalidArgumentError2;
+    exports2.InvalidOptionArgumentError = InvalidArgumentError2;
   }
 });
 
@@ -3027,26 +3041,404 @@ var {
 } = import_index.default;
 
 // packages/cli/src/commands/init.ts
-import * as fs from "fs";
-import * as path from "path";
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// packages/core/src/idgen.ts
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+function encodeBase36(n) {
+  if (n === 0) return "0";
+  let result = "";
+  while (n > 0) {
+    result = ALPHABET[n % 36] + result;
+    n = Math.floor(n / 36);
+  }
+  return result;
+}
+function generateNextId(currentCount) {
+  const next = currentCount + 1;
+  if (next <= 999) {
+    return `D${String(next).padStart(3, "0")}`;
+  }
+  const encoded = encodeBase36(next).padStart(4, "0");
+  return `D${encoded}`;
+}
+
+// packages/core/src/parser.ts
+function splitCsvRow(line) {
+  const fields = [];
+  let current = "";
+  let inQuote = false;
+  let i = 0;
+  while (i < line.length) {
+    const ch = line[i];
+    if (inQuote) {
+      if (ch === "\\") {
+        const next = line[i + 1];
+        if (next === '"') {
+          current += '"';
+          i += 2;
+          continue;
+        } else if (next === "n") {
+          current += "\n";
+          i += 2;
+          continue;
+        } else if (next === "\\") {
+          current += "\\";
+          i += 2;
+          continue;
+        }
+        current += ch;
+      } else if (ch === '"') {
+        inQuote = false;
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuote = true;
+      } else if (ch === ",") {
+        fields.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+    i++;
+  }
+  fields.push(current);
+  return fields;
+}
+function parseTableHeader(line) {
+  const match = line.match(/^decisions\[(\d+)\]\{([^}]+)\}:$/);
+  if (!match) return null;
+  return {
+    count: parseInt(match[1], 10),
+    fields: match[2].split(",")
+  };
+}
+function isSummaryLine(line) {
+  return line.startsWith("summary{");
+}
+function parseDecisionRow(fields, values) {
+  const get = (name) => {
+    const idx = fields.indexOf(name);
+    return idx >= 0 ? values[idx] ?? "" : "";
+  };
+  const impactRaw = get("impact");
+  const validImpacts = ["low", "medium", "high", "critical"];
+  const impact = validImpacts.includes(impactRaw) ? impactRaw : "medium";
+  const tagsRaw = get("tags");
+  const tags = tagsRaw ? tagsRaw.split("|").filter(Boolean) : [];
+  return {
+    id: get("id"),
+    ts: get("ts"),
+    topic: get("topic"),
+    decision: get("decision"),
+    rationale: get("rationale"),
+    impact,
+    tags
+  };
+}
+function parseDecisionFile(content) {
+  const lines = content.split("\n");
+  const meta = {
+    project: "unknown",
+    version: "1",
+    created: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    updated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+  };
+  const decisions = [];
+  let tableFields = [];
+  let inTable = false;
+  let inSummary = false;
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    if (!line || line.startsWith("#")) continue;
+    if (isSummaryLine(line)) {
+      inTable = false;
+      inSummary = true;
+      continue;
+    }
+    if (inSummary) continue;
+    const tableHeader = parseTableHeader(line);
+    if (tableHeader) {
+      tableFields = tableHeader.fields;
+      inTable = true;
+      continue;
+    }
+    if (inTable && tableFields.length > 0) {
+      const values = splitCsvRow(line);
+      if (values.length >= tableFields.length) {
+        decisions.push(parseDecisionRow(tableFields, values));
+      }
+      continue;
+    }
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      if (key === "project") meta.project = value;
+      else if (key === "version") meta.version = value;
+      else if (key === "created") meta.created = value;
+      else if (key === "updated") meta.updated = value;
+    }
+  }
+  return { meta, decisions };
+}
+function serializeDecisionRow(d) {
+  const escapeField = (s) => {
+    if (s.includes(",") || s.includes('"') || s.includes("\n")) {
+      return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n") + '"';
+    }
+    return s;
+  };
+  const tags = d.tags.join("|");
+  return [
+    d.id,
+    d.ts,
+    d.topic,
+    escapeField(d.decision),
+    escapeField(d.rationale),
+    d.impact,
+    tags
+  ].join(",");
+}
+
+// packages/core/src/searcher.ts
+var IMPACT_WEIGHT = {
+  critical: 4,
+  high: 3,
+  medium: 2,
+  low: 1
+};
+function computeMatchedFields(d, keywords, tags) {
+  const matched = [];
+  const kws = keywords.map((k) => k.toLowerCase());
+  if (tags.length > 0 && tags.some((t) => d.tags.map((dt) => dt.toLowerCase()).includes(t))) {
+    matched.push("tags");
+  }
+  if (kws.some((k) => d.topic.toLowerCase().includes(k))) matched.push("topic");
+  if (kws.some((k) => d.decision.toLowerCase().includes(k))) matched.push("decision");
+  if (kws.some((k) => d.rationale.toLowerCase().includes(k))) matched.push("rationale");
+  return matched;
+}
+function searchDecisions(file, query) {
+  const keywords = (query.keywords ?? []).map((k) => k.toLowerCase());
+  const tags = (query.tags ?? []).map((t) => t.toLowerCase());
+  const impactFilter = query.impact;
+  const limit = query.limit ?? 5;
+  if (keywords.length === 0 && tags.length === 0 && !impactFilter) {
+    return file.decisions.slice(-limit).reverse().map((d) => ({ decision: d, matchedFields: [] }));
+  }
+  const results = [];
+  for (const d of file.decisions) {
+    if (impactFilter && d.impact !== impactFilter) continue;
+    const decisionLower = d.decision.toLowerCase();
+    const rationaleLower = d.rationale.toLowerCase();
+    const topicLower = d.topic.toLowerCase();
+    const tagsLower = d.tags.map((t) => t.toLowerCase());
+    const matchesTag = tags.length === 0 || tags.some((t) => tagsLower.includes(t));
+    const matchesKeyword = keywords.length === 0 || keywords.some(
+      (k) => topicLower.includes(k) || decisionLower.includes(k) || rationaleLower.includes(k) || tagsLower.some((t) => t.includes(k))
+    );
+    if (matchesTag && matchesKeyword) {
+      results.push({
+        decision: d,
+        matchedFields: computeMatchedFields(d, keywords, tags)
+      });
+    }
+  }
+  results.sort((a, b) => {
+    const weightDiff = IMPACT_WEIGHT[b.decision.impact] - IMPACT_WEIGHT[a.decision.impact];
+    if (weightDiff !== 0) return weightDiff;
+    return b.decision.ts.localeCompare(a.decision.ts);
+  });
+  return results.slice(0, limit);
+}
+
+// packages/core/src/summary.ts
+var HIGH_IMPACT = ["high", "critical"];
+function topTopics(decisions, n = 5) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const d of decisions) {
+    counts.set(d.topic, (counts.get(d.topic) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, n).map(([topic]) => topic);
+}
+function buildContextSummary(file, options = {}) {
+  const { includeRecent = true } = options;
+  const { decisions } = file;
+  const highImpactCount = decisions.filter(
+    (d) => HIGH_IMPACT.includes(d.impact)
+  ).length;
+  const lastUpdated = decisions.length > 0 ? decisions[decisions.length - 1].ts.slice(0, 10) : file.meta.updated;
+  const recentDecisions = includeRecent ? decisions.filter((d) => HIGH_IMPACT.includes(d.impact)).slice(-5).reverse() : [];
+  return {
+    total: decisions.length,
+    highImpactCount,
+    lastUpdated,
+    topTopics: topTopics(decisions),
+    recentDecisions
+  };
+}
+function buildSummaryBlock(file) {
+  const summary = buildContextSummary(file, { includeRecent: false });
+  const topics = summary.topTopics.join("|");
+  return `summary{total,high_impact,last_updated,top_topics}:
+${summary.total},${summary.highImpactCount},${summary.lastUpdated},${topics}`;
+}
+function formatContextSummaryAsToon(file, includeRecent = true) {
+  const summary = buildContextSummary(file, { includeRecent });
+  const topics = summary.topTopics.join("|");
+  let output2 = `summary{total,high_impact,last_updated,top_topics}:
+`;
+  output2 += `${summary.total},${summary.highImpactCount},${summary.lastUpdated},${topics}`;
+  if (includeRecent && summary.recentDecisions.length > 0) {
+    output2 += `
+
+recent_high_impact[${summary.recentDecisions.length}]{id,ts,topic,decision,impact}:
+`;
+    for (const d of summary.recentDecisions) {
+      const decisionField = d.decision.includes(",") ? `"${d.decision}"` : d.decision;
+      output2 += `${d.id},${d.ts},${d.topic},${decisionField},${d.impact}
+`;
+    }
+  }
+  return output2.trimEnd();
+}
+
+// packages/core/src/writer.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+function initDecisionFile(filePath, projectName) {
+  if (fs.existsSync(filePath)) {
+    throw new Error(`Dosya zaten var: ${filePath}`);
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const content = `# decision-memory v1
+project: ${projectName}
+version: 1
+created: ${today}
+updated: ${today}
+
+decisions[0]{id,ts,topic,decision,rationale,impact,tags}:
+
+summary{total,high_impact,last_updated,top_topics}:
+0,0,${today},
+`;
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+function updateDecisionCount(filePath, newCount) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const updated = content.replace(
+    /^decisions\[(\d+)\]\{/m,
+    `decisions[${newCount}]{`
+  );
+  const tmpPath = filePath + ".tmp";
+  fs.writeFileSync(tmpPath, updated, "utf-8");
+  fs.renameSync(tmpPath, filePath);
+}
+function updateSummaryBlock(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const file = parseDecisionFile(content);
+  const summaryBlock = buildSummaryBlock(file);
+  const summaryStart = content.indexOf("\nsummary{");
+  let base;
+  if (summaryStart >= 0) {
+    base = content.slice(0, summaryStart);
+  } else {
+    base = content.trimEnd();
+  }
+  const newContent = base + "\n" + summaryBlock + "\n";
+  const tmpPath = filePath + ".tmp";
+  fs.writeFileSync(tmpPath, newContent, "utf-8");
+  fs.renameSync(tmpPath, filePath);
+}
+function appendDecision(filePath, input2) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`DECISIONS.toon dosyas\u0131 bulunamad\u0131: ${filePath}
+\xD6nce 'decision-memory init' komutunu \xE7al\u0131\u015Ft\u0131r\u0131n.`);
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  const countMatch = content.match(/^decisions\[(\d+)\]/m);
+  const currentCount = countMatch ? parseInt(countMatch[1], 10) : 0;
+  const id = generateNextId(currentCount);
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z").replace(/:\d{2}Z$/, "Z");
+  const decision = {
+    id,
+    ts,
+    topic: input2.topic,
+    decision: input2.decision,
+    rationale: input2.rationale,
+    impact: input2.impact,
+    tags: input2.tags
+  };
+  const row = serializeDecisionRow(decision);
+  const lines = content.split("\n");
+  let tableEnd = -1;
+  let inTable = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^decisions\[\d+\]\{/.test(lines[i])) {
+      inTable = true;
+      tableEnd = i;
+      continue;
+    }
+    if (inTable) {
+      if (lines[i].startsWith("summary{") || lines[i] === "" && tableEnd >= 0) {
+        if (lines[i].startsWith("summary{")) {
+          tableEnd = i - 1;
+        } else {
+          tableEnd = i - 1;
+        }
+        break;
+      }
+      if (lines[i] !== "") {
+        tableEnd = i;
+      }
+    }
+  }
+  lines.splice(tableEnd + 1, 0, row);
+  const newContent = lines.join("\n");
+  const tmpPath = filePath + ".tmp";
+  fs.writeFileSync(tmpPath, newContent, "utf-8");
+  fs.renameSync(tmpPath, filePath);
+  updateDecisionCount(filePath, currentCount + 1);
+  updateSummaryBlock(filePath);
+  return decision;
+}
+function resolveDecisionFilePath(cwd) {
+  if (process.env.DECISION_MEMORY_FILE) {
+    return process.env.DECISION_MEMORY_FILE;
+  }
+  const dir = cwd ?? process.cwd();
+  const local = path.join(dir, "DECISIONS.toon");
+  if (fs.existsSync(local)) return local;
+  const globalDir = path.join(os.homedir(), ".decision-memory");
+  fs.mkdirSync(globalDir, { recursive: true });
+  return path.join(globalDir, "global.toon");
+}
+
+// packages/cli/src/commands/init.ts
 function initCommand(options) {
   const dir = options.dir ?? process.cwd();
-  const filePath = path.join(dir, "DECISIONS.toon");
-  if (fs.existsSync(filePath)) {
+  const filePath = path2.join(dir, "DECISIONS.toon");
+  if (fs2.existsSync(filePath)) {
     console.error(`Hata: ${filePath} zaten mevcut.`);
     process.exit(1);
   }
-  const projectName = options.project ?? path.basename(dir);
+  const projectName = options.project ?? path2.basename(dir);
   initDecisionFile(filePath, projectName);
-  const gitattributes = path.join(dir, ".gitattributes");
+  const gitattributes = path2.join(dir, ".gitattributes");
   const entry = "DECISIONS.toon text eol=lf\n";
-  if (fs.existsSync(gitattributes)) {
-    const content = fs.readFileSync(gitattributes, "utf-8");
+  if (fs2.existsSync(gitattributes)) {
+    const content = fs2.readFileSync(gitattributes, "utf-8");
     if (!content.includes("DECISIONS.toon")) {
-      fs.appendFileSync(gitattributes, entry);
+      fs2.appendFileSync(gitattributes, entry);
     }
   } else {
-    fs.writeFileSync(gitattributes, entry);
+    fs2.writeFileSync(gitattributes, entry);
   }
   console.log(`\u2713 ${filePath} olu\u015Fturuldu.`);
   console.log(`\u2713 .gitattributes g\xFCncellendi.`);
@@ -3057,8 +3449,8 @@ Ba\u015Flamak i\xE7in:`);
 }
 
 // packages/cli/src/commands/log.ts
-import * as readline from "readline/promises";
-import { stdin as input, stdout as output } from "process";
+var readline = __toESM(require("readline/promises"));
+var import_node_process = require("process");
 async function logCommand(options) {
   if (options.topic && options.decision && options.rationale && options.impact) {
     const inp = buildInput(options);
@@ -3067,7 +3459,7 @@ async function logCommand(options) {
     console.log(`\u2713 Karar kaydedildi: ${entry.id} \u2014 ${entry.decision}`);
     return;
   }
-  const rl = readline.createInterface({ input, output });
+  const rl = readline.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
   try {
     const topic = options.topic ?? await rl.question("Konu (\xF6rn: auth, database): ");
     const decision = options.decision ?? await rl.question("Al\u0131nan karar: ");
@@ -3108,14 +3500,14 @@ function buildInput(options) {
 }
 
 // packages/cli/src/commands/search.ts
-import * as fs2 from "fs";
+var fs3 = __toESM(require("fs"));
 function searchCommand(options) {
   const filePath = options.file ?? resolveDecisionFilePath();
-  if (!fs2.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     console.error(`Hata: ${filePath} bulunamad\u0131. \xD6nce 'decision-memory init' \xE7al\u0131\u015Ft\u0131r\u0131n.`);
     process.exit(1);
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs3.readFileSync(filePath, "utf-8");
   const file = parseDecisionFile(content);
   const keywords = options.keywords ? options.keywords.split(",").map((k) => k.trim()).filter(Boolean) : [];
   const tags = options.tags ? options.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
@@ -3134,14 +3526,14 @@ function searchCommand(options) {
 }
 
 // packages/cli/src/commands/summary.ts
-import * as fs3 from "fs";
+var fs4 = __toESM(require("fs"));
 function summaryCommand(options) {
   const filePath = options.file ?? resolveDecisionFilePath();
-  if (!fs3.existsSync(filePath)) {
+  if (!fs4.existsSync(filePath)) {
     console.error(`Hata: ${filePath} bulunamad\u0131. \xD6nce 'decision-memory init' \xE7al\u0131\u015Ft\u0131r\u0131n.`);
     process.exit(1);
   }
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs4.readFileSync(filePath, "utf-8");
   const file = parseDecisionFile(content);
   const output2 = formatContextSummaryAsToon(file, !options.noRecent);
   console.log(output2);