hypercore-cli 1.1.0

package/dist/chunk-KRPOPWGA.js

@@ -0,0 +1,251 @@
+import {
+  HYPERCORE_DIR
+} from "./chunk-V5UHPPSY.js";
+
+// src/memory/store.ts
+import { randomBytes } from "crypto";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+
+// src/memory/types.ts
+var DEFAULT_EXTRACTION_CONFIG = {
+  extractEveryNRounds: 3,
+  maxMemoriesPerExtraction: 5,
+  minConfidence: 0.6,
+  maxPersonalMemories: 100,
+  maxProjectMemories: 150,
+  maxSystemPromptChars: 3e3
+};
+function createEmptyStore(layer) {
+  return {
+    version: "1",
+    layer,
+    records: [],
+    totalExtractions: 0,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var CATEGORY_LABELS = {
+  preference: "\u504F\u597D",
+  decision: "\u51B3\u7B56",
+  entity: "\u5B9E\u4F53",
+  pattern: "\u6A21\u5F0F",
+  fact: "\u4E8B\u5B9E",
+  convention: "\u7EA6\u5B9A",
+  insight: "\u6D1E\u5BDF",
+  manual: "\u624B\u52A8"
+};
+var CATEGORY_MD_HEADERS = {
+  preference: "User Preferences",
+  decision: "Key Decisions",
+  entity: "Named Entities",
+  pattern: "Patterns & Solutions",
+  fact: "Known Facts",
+  convention: "Conventions",
+  insight: "Team Insights",
+  manual: "User Notes"
+};
+
+// src/memory/store.ts
+function memoryDir(layer, opts) {
+  switch (layer) {
+    case "personal":
+      return join(HYPERCORE_DIR, "memory");
+    case "project":
+      return join(opts?.projectPath || process.cwd(), ".hypercore", "memory");
+    case "team":
+      if (!opts?.teamId) throw new Error("team layer requires teamId");
+      return join(HYPERCORE_DIR, "teams", opts.teamId, "memory");
+  }
+}
+function jsonPath(layer, opts) {
+  return join(memoryDir(layer, opts), `${layer}.json`);
+}
+function mdPath(layer, opts) {
+  return join(memoryDir(layer, opts), `${layer}.md`);
+}
+function generateMemoryId() {
+  const ts = Date.now();
+  const rand = randomBytes(2).toString("hex");
+  return `mem_${ts}_${rand}`;
+}
+async function loadStore(layer, opts) {
+  const fp = jsonPath(layer, opts);
+  if (!existsSync(fp)) return createEmptyStore(layer);
+  try {
+    const raw = await readFile(fp, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return createEmptyStore(layer);
+  }
+}
+async function saveStore(store, opts) {
+  const dir = memoryDir(store.layer, opts);
+  await mkdir(dir, { recursive: true });
+  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(jsonPath(store.layer, opts), JSON.stringify(store, null, 2), "utf-8");
+  await rebuildMarkdown(store, opts);
+}
+async function addMemory(layer, record, opts) {
+  const store = await loadStore(layer, opts);
+  const config = DEFAULT_EXTRACTION_CONFIG;
+  const maxRecords = layer === "personal" ? config.maxPersonalMemories : config.maxProjectMemories;
+  const existingIdx = findDuplicate(store.records, record.content);
+  if (existingIdx >= 0) {
+    const existing = store.records[existingIdx];
+    existing.content = record.content;
+    existing.tags = record.tags;
+    existing.confidence = Math.max(existing.confidence, record.confidence);
+    existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    existing.accessCount++;
+    await saveStore(store, opts);
+    return existing;
+  }
+  if (store.records.length >= maxRecords) {
+    store.records.sort((a, b) => a.confidence - b.confidence || a.updatedAt.localeCompare(b.updatedAt));
+    store.records.shift();
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newRecord = {
+    ...record,
+    id: generateMemoryId(),
+    layer,
+    createdAt: now,
+    updatedAt: now,
+    accessCount: 0
+  };
+  store.records.push(newRecord);
+  await saveStore(store, opts);
+  return newRecord;
+}
+async function removeMemory(layer, memoryId, opts) {
+  const store = await loadStore(layer, opts);
+  const idx = store.records.findIndex((r) => r.id === memoryId);
+  if (idx < 0) return false;
+  store.records.splice(idx, 1);
+  await saveStore(store, opts);
+  return true;
+}
+async function searchMemories(layer, query, opts) {
+  const store = await loadStore(layer, opts);
+  let records = store.records;
+  if (opts?.category) {
+    records = records.filter((r) => r.category === opts.category);
+  }
+  const queryLower = query.toLowerCase();
+  const queryTerms = queryLower.split(/\s+/).filter(Boolean);
+  const scored = records.map((record) => {
+    const contentLower = record.content.toLowerCase();
+    const tagsLower = record.tags.join(" ").toLowerCase();
+    const combined = contentLower + " " + tagsLower;
+    let matchedTerms = 0;
+    for (const term of queryTerms) {
+      if (combined.includes(term)) matchedTerms++;
+    }
+    const score = queryTerms.length > 0 ? matchedTerms / queryTerms.length : 0;
+    return { record, score };
+  });
+  const results = scored.filter((r) => r.score > 0).sort((a, b) => b.score - a.score || b.record.confidence - a.record.confidence);
+  for (const r of results) {
+    r.record.accessCount++;
+    r.record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  if (results.length > 0) {
+    await saveStore(store, opts);
+  }
+  return results.slice(0, opts?.limit || 20);
+}
+async function listMemories(layer, opts) {
+  const store = await loadStore(layer, opts);
+  return [...store.records].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+async function getMemoryStats(layer, opts) {
+  const store = await loadStore(layer, opts);
+  const byCategory = {};
+  for (const r of store.records) {
+    byCategory[r.category] = (byCategory[r.category] || 0) + 1;
+  }
+  return {
+    total: store.records.length,
+    byCategory,
+    lastExtractionAt: store.lastExtractionAt,
+    totalExtractions: store.totalExtractions
+  };
+}
+async function markExtraction(layer, opts) {
+  const store = await loadStore(layer, opts);
+  store.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.totalExtractions++;
+  await saveStore(store, opts);
+}
+function findDuplicate(records, content) {
+  const normalized = content.toLowerCase().replace(/\s+/g, " ").trim();
+  for (let i = 0; i < records.length; i++) {
+    const existing = records[i].content.toLowerCase().replace(/\s+/g, " ").trim();
+    if (similarityRatio(existing, normalized) > 0.8) return i;
+  }
+  return -1;
+}
+function similarityRatio(a, b) {
+  if (a === b) return 1;
+  if (!a || !b) return 0;
+  const bigramsA = /* @__PURE__ */ new Set();
+  for (let i = 0; i < a.length - 1; i++) bigramsA.add(a.slice(i, i + 2));
+  const bigramsB = /* @__PURE__ */ new Set();
+  for (let i = 0; i < b.length - 1; i++) bigramsB.add(b.slice(i, i + 2));
+  let intersection = 0;
+  for (const bg of bigramsA) {
+    if (bigramsB.has(bg)) intersection++;
+  }
+  const union = bigramsA.size + bigramsB.size - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+async function rebuildMarkdown(store, opts) {
+  const lines = [
+    `--- Memory Context (${store.layer}) ---`,
+    ""
+  ];
+  const grouped = {};
+  for (const r of store.records) {
+    if (!grouped[r.category]) grouped[r.category] = [];
+    grouped[r.category].push(r);
+  }
+  for (const [category, records] of Object.entries(grouped)) {
+    const header = CATEGORY_MD_HEADERS[category] || category;
+    lines.push(`[${header}]`);
+    const sorted = records.sort((a, b) => b.confidence - a.confidence);
+    for (const r of sorted) {
+      const tags = r.tags.map((t) => `#${t}`).join(" ");
+      lines.push(`- ${r.content} ${tags}`);
+    }
+    lines.push("");
+  }
+  lines.push(`--- End Memory Context ---`);
+  const fp = mdPath(store.layer, opts);
+  await writeFile(fp, lines.join("\n"), "utf-8");
+}
+async function readMemoryMarkdown(layer, opts) {
+  const fp = mdPath(layer, opts);
+  if (!existsSync(fp)) return "";
+  try {
+    return await readFile(fp, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+export {
+  DEFAULT_EXTRACTION_CONFIG,
+  CATEGORY_LABELS,
+  generateMemoryId,
+  loadStore,
+  saveStore,
+  addMemory,
+  removeMemory,
+  searchMemories,
+  listMemories,
+  getMemoryStats,
+  markExtraction,
+  readMemoryMarkdown
+};

package/dist/chunk-MGLJ53QN.js

@@ -0,0 +1,219 @@
+// src/admin/backlog.ts
+import { join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+var HYPERCORE_DIR = join(process.env.HOME || "~", ".hypercore");
+var ADMIN_DIR = join(HYPERCORE_DIR, "admin");
+var BACKLOG_FILE = join(ADMIN_DIR, "backlog.json");
+var DEFAULT_METRICS = {
+  baselineKey: null,
+  baselineValue: null,
+  baselineDate: null,
+  afterValue: null,
+  afterDate: null,
+  verified: false
+};
+function normalizeMetrics(metrics) {
+  return {
+    baselineKey: typeof metrics?.baselineKey === "string" ? metrics.baselineKey : null,
+    baselineValue: typeof metrics?.baselineValue === "number" && Number.isFinite(metrics.baselineValue) ? metrics.baselineValue : null,
+    baselineDate: typeof metrics?.baselineDate === "string" ? metrics.baselineDate : null,
+    afterValue: typeof metrics?.afterValue === "number" && Number.isFinite(metrics.afterValue) ? metrics.afterValue : null,
+    afterDate: typeof metrics?.afterDate === "string" ? metrics.afterDate : null,
+    verified: typeof metrics?.verified === "boolean" ? metrics.verified : false
+  };
+}
+function normalizeItem(raw, fallbackId) {
+  if (!raw || typeof raw !== "object") return null;
+  const item = raw;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const type = item.type === "feature" || item.type === "improvement" || item.type === "idea" || item.type === "bugfix" ? item.type : "feature";
+  const wuxing = item.wuxing === "\u6728" || item.wuxing === "\u706B" || item.wuxing === "\u6C34" || item.wuxing === "\u91D1" || item.wuxing === "\u571F" ? item.wuxing : "\u6728";
+  const priority = item.priority === "S" || item.priority === "A" || item.priority === "B" || item.priority === "C" ? item.priority : "B";
+  const status = item.status === "idea" || item.status === "planned" || item.status === "developing" || item.status === "done" || item.status === "archived" ? item.status : "idea";
+  const source = item.source === "auto-diagnose" ? "auto-diagnose" : "manual";
+  const createdAt = typeof item.createdAt === "string" ? item.createdAt : now;
+  const id = typeof item.id === "number" && Number.isFinite(item.id) ? Math.floor(item.id) : fallbackId;
+  return {
+    id: id > 0 ? id : fallbackId,
+    title: typeof item.title === "string" ? item.title : `Untitled #${fallbackId}`,
+    description: typeof item.description === "string" ? item.description : "",
+    type,
+    wuxing,
+    priority,
+    status,
+    source,
+    sourceDetail: typeof item.sourceDetail === "string" ? item.sourceDetail : "",
+    evidence: typeof item.evidence === "string" ? item.evidence : "",
+    targetVersion: typeof item.targetVersion === "string" ? item.targetVersion : "",
+    tags: Array.isArray(item.tags) ? item.tags.filter((t) => typeof t === "string") : [],
+    createdAt,
+    updatedAt: typeof item.updatedAt === "string" ? item.updatedAt : createdAt,
+    startedAt: typeof item.startedAt === "string" ? item.startedAt : null,
+    resolvedAt: typeof item.resolvedAt === "string" ? item.resolvedAt : null,
+    metrics: normalizeMetrics(item.metrics)
+  };
+}
+async function ensureDir() {
+  if (!existsSync(ADMIN_DIR)) {
+    await mkdir(ADMIN_DIR, { recursive: true });
+  }
+}
+async function loadStore() {
+  await ensureDir();
+  if (!existsSync(BACKLOG_FILE)) {
+    return { nextId: 1, items: [] };
+  }
+  try {
+    const raw = await readFile(BACKLOG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    const rawItems = Array.isArray(parsed.items) ? parsed.items : [];
+    const items = [];
+    for (let i = 0; i < rawItems.length; i++) {
+      const normalized = normalizeItem(rawItems[i], i + 1);
+      if (normalized) items.push(normalized);
+    }
+    const maxId = items.reduce((max, item) => item.id > max ? item.id : max, 0);
+    const nextIdFromFile = typeof parsed.nextId === "number" && Number.isFinite(parsed.nextId) ? Math.floor(parsed.nextId) : maxId + 1;
+    return {
+      nextId: Math.max(nextIdFromFile, maxId + 1, 1),
+      items
+    };
+  } catch {
+    return { nextId: 1, items: [] };
+  }
+}
+async function saveStore(store) {
+  await ensureDir();
+  await writeFile(BACKLOG_FILE, JSON.stringify(store, null, 2), "utf-8");
+}
+async function addItem(opts) {
+  const store = await loadStore();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const item = {
+    id: store.nextId++,
+    title: opts.title,
+    description: opts.description || "",
+    type: opts.type || "feature",
+    wuxing: opts.wuxing || "\u6728",
+    priority: opts.priority || "B",
+    status: "idea",
+    source: opts.source || "manual",
+    sourceDetail: "",
+    evidence: opts.evidence || "",
+    targetVersion: opts.targetVersion || "",
+    tags: opts.tags || [],
+    createdAt: now,
+    updatedAt: now,
+    startedAt: null,
+    resolvedAt: null,
+    metrics: { ...DEFAULT_METRICS }
+  };
+  store.items.push(item);
+  await saveStore(store);
+  return item;
+}
+async function listItems(filters) {
+  const store = await loadStore();
+  let items = store.items.filter((i) => i.status !== "archived");
+  if (filters) {
+    if (filters.status) items = items.filter((i) => i.status === filters.status);
+    if (filters.wuxing) items = items.filter((i) => i.wuxing === filters.wuxing);
+    if (filters.priority) items = items.filter((i) => i.priority === filters.priority);
+    if (filters.version) items = items.filter((i) => i.targetVersion === filters.version);
+    if (filters.type) items = items.filter((i) => i.type === filters.type);
+  }
+  const priorityOrder = { S: 0, A: 1, B: 2, C: 3 };
+  return items.sort((a, b) => {
+    const pd = priorityOrder[a.priority] - priorityOrder[b.priority];
+    if (pd !== 0) return pd;
+    return a.id - b.id;
+  });
+}
+async function getItem(id) {
+  const store = await loadStore();
+  return store.items.find((i) => i.id === id) || null;
+}
+async function updateItem(id, updates) {
+  const store = await loadStore();
+  const item = store.items.find((i) => i.id === id);
+  if (!item) return null;
+  Object.assign(item, updates);
+  item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveStore(store);
+  return item;
+}
+async function updateItemMetrics(id, metrics) {
+  const store = await loadStore();
+  const item = store.items.find((i) => i.id === id);
+  if (!item) return null;
+  item.metrics = normalizeMetrics(metrics);
+  item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveStore(store);
+  return item;
+}
+async function pickItem(id) {
+  const store = await loadStore();
+  const item = store.items.find((i) => i.id === id);
+  if (!item) return null;
+  item.status = "developing";
+  item.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveStore(store);
+  return item;
+}
+async function doneItem(id) {
+  const store = await loadStore();
+  const item = store.items.find((i) => i.id === id);
+  if (!item) return null;
+  item.status = "done";
+  item.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveStore(store);
+  return item;
+}
+async function archiveItem(id) {
+  const store = await loadStore();
+  const item = store.items.find((i) => i.id === id);
+  if (!item) return null;
+  item.status = "archived";
+  item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveStore(store);
+  return item;
+}
+async function reopenItem(id) {
+  const store = await loadStore();
+  const item = store.items.find((i) => i.id === id);
+  if (!item) return null;
+  item.status = "planned";
+  item.resolvedAt = null;
+  item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveStore(store);
+  return item;
+}
+async function getStats() {
+  const store = await loadStore();
+  const active = store.items.filter((i) => i.status !== "archived");
+  const byStatus = {};
+  const byPriority = {};
+  const byWuxing = {};
+  for (const item of active) {
+    byStatus[item.status] = (byStatus[item.status] || 0) + 1;
+    byPriority[item.priority] = (byPriority[item.priority] || 0) + 1;
+    byWuxing[item.wuxing] = (byWuxing[item.wuxing] || 0) + 1;
+  }
+  return { total: active.length, byStatus, byPriority, byWuxing };
+}
+
+export {
+  addItem,
+  listItems,
+  getItem,
+  updateItem,
+  updateItemMetrics,
+  pickItem,
+  doneItem,
+  archiveItem,
+  reopenItem,
+  getStats
+};