@drewpayment/mink 0.1.0

package/src/core/global-config.ts

@@ -0,0 +1,74 @@
+import { globalConfigPath } from "./paths";
+import { safeReadJson, atomicWriteJson } from "./fs-utils";
+import {
+  CONFIG_KEYS,
+  isValidConfigKey,
+  getConfigKeyMeta,
+  type GlobalConfig,
+  type ConfigKey,
+} from "../types/config";
+
+export function loadGlobalConfig(): GlobalConfig {
+  const raw = safeReadJson(globalConfigPath());
+  if (raw === null) return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    console.warn("[mink] warning: corrupt config file at " + globalConfigPath());
+    return {};
+  }
+  return raw as GlobalConfig;
+}
+
+export function saveGlobalConfig(config: GlobalConfig): void {
+  atomicWriteJson(globalConfigPath(), config);
+}
+
+export interface ResolvedValue {
+  value: string;
+  source: "default" | "config file" | "environment variable";
+  configFileValue?: string;
+}
+
+export function resolveConfigValue(key: ConfigKey): ResolvedValue {
+  const meta = getConfigKeyMeta(key);
+  const config = loadGlobalConfig();
+
+  const envValue = process.env[meta.envVar];
+  const fileValue = config[key];
+
+  if (envValue !== undefined && envValue !== "") {
+    return {
+      value: envValue,
+      source: "environment variable",
+      configFileValue: fileValue,
+    };
+  }
+
+  if (fileValue !== undefined) {
+    return { value: fileValue, source: "config file" };
+  }
+
+  return { value: meta.default, source: "default" };
+}
+
+export function resolveAllConfig(): Array<ResolvedValue & { key: ConfigKey }> {
+  return CONFIG_KEYS.map((meta) => ({
+    key: meta.key,
+    ...resolveConfigValue(meta.key),
+  }));
+}
+
+export function setConfigValue(key: ConfigKey, value: string): void {
+  const config = loadGlobalConfig();
+  config[key] = value;
+  saveGlobalConfig(config);
+}
+
+export function resetConfigKey(key: ConfigKey): void {
+  const config = loadGlobalConfig();
+  delete config[key];
+  saveGlobalConfig(config);
+}
+
+export function resetAllConfig(): void {
+  saveGlobalConfig({});
+}

package/src/core/index-store.ts

@@ -0,0 +1,72 @@
+import type {
+  FileIndex,
+  FileIndexEntry,
+  StalenessReport,
+} from "../types/file-index";
+
+export function createEmptyIndex(): FileIndex {
+  return {
+    header: {
+      lastScanTimestamp: "",
+      totalFiles: 0,
+      lifetimeHits: 0,
+      lifetimeMisses: 0,
+    },
+    entries: {},
+  };
+}
+
+export function isFileIndex(value: unknown): value is FileIndex {
+  if (value === null || typeof value !== "object") return false;
+  const obj = value as Record<string, unknown>;
+  return (
+    typeof obj.header === "object" &&
+    obj.header !== null &&
+    typeof obj.entries === "object" &&
+    obj.entries !== null
+  );
+}
+
+export function upsertEntry(index: FileIndex, entry: FileIndexEntry): void {
+  index.entries[entry.filePath] = entry;
+  index.header.totalFiles = Object.keys(index.entries).length;
+}
+
+export function removeEntry(index: FileIndex, filePath: string): void {
+  delete index.entries[filePath];
+  index.header.totalFiles = Object.keys(index.entries).length;
+}
+
+export function lookupEntry(
+  index: FileIndex,
+  filePath: string
+): FileIndexEntry | null {
+  return index.entries[filePath] ?? null;
+}
+
+export function recordHit(index: FileIndex): void {
+  index.header.lifetimeHits++;
+}
+
+export function recordMiss(index: FileIndex): void {
+  index.header.lifetimeMisses++;
+}
+
+export function checkStaleness(
+  index: FileIndex,
+  scannedFiles: string[]
+): StalenessReport {
+  const scannedSet = new Set(scannedFiles);
+  const indexedSet = new Set(Object.keys(index.entries));
+
+  const missingFromIndex = scannedFiles.filter((f) => !indexedSet.has(f));
+  const orphanedEntries = Object.keys(index.entries).filter(
+    (f) => !scannedSet.has(f)
+  );
+
+  return {
+    missingFromIndex,
+    orphanedEntries,
+    isStale: missingFromIndex.length > 0 || orphanedEntries.length > 0,
+  };
+}

package/src/core/learning-memory.ts

@@ -0,0 +1,120 @@
+import type { LearningMemory, SectionName } from "../types/learning-memory";
+
+const SECTION_ORDER: SectionName[] = [
+  "User Preferences",
+  "Key Learnings",
+  "Do-Not-Repeat",
+  "Decision Log",
+];
+
+const RECOGNIZED_SECTIONS = new Set<string>(SECTION_ORDER);
+
+function emptySections(): Record<SectionName, string[]> {
+  return {
+    "User Preferences": [],
+    "Key Learnings": [],
+    "Do-Not-Repeat": [],
+    "Decision Log": [],
+  };
+}
+
+export function createEmptyLearningMemory(projectName: string): LearningMemory {
+  return {
+    projectName,
+    sections: emptySections(),
+  };
+}
+
+export function parseLearningMemory(markdown: string): LearningMemory {
+  const sections = emptySections();
+  let projectName = "unknown";
+
+  if (!markdown || markdown.trim() === "") {
+    return { projectName, sections };
+  }
+
+  const lines = markdown.split("\n");
+  let currentSection: SectionName | null = null;
+
+  for (const line of lines) {
+    // Check for title line: # Learning Memory — <name>
+    const titleMatch = line.match(/^#\s+Learning Memory\s+[—–-]+\s+(.+)$/);
+    if (titleMatch) {
+      projectName = titleMatch[1].trim();
+      currentSection = null;
+      continue;
+    }
+
+    // Check for section heading: ## Section Name
+    const sectionMatch = line.match(/^##\s+(.+)$/);
+    if (sectionMatch) {
+      const sectionName = sectionMatch[1].trim();
+      if (RECOGNIZED_SECTIONS.has(sectionName)) {
+        currentSection = sectionName as SectionName;
+      } else {
+        currentSection = null;
+      }
+      continue;
+    }
+
+    // Check for entry line: - entry
+    if (currentSection !== null) {
+      const entryMatch = line.match(/^-\s+(.+)$/);
+      if (entryMatch) {
+        sections[currentSection].push(entryMatch[1]);
+      }
+    }
+  }
+
+  return { projectName, sections };
+}
+
+export function serializeLearningMemory(mem: LearningMemory): string {
+  const lines: string[] = [];
+
+  lines.push(`# Learning Memory — ${mem.projectName}`);
+
+  for (const section of SECTION_ORDER) {
+    lines.push("");
+    lines.push(`## ${section}`);
+    for (const entry of mem.sections[section]) {
+      lines.push(`- ${entry}`);
+    }
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+export function addEntry(
+  mem: LearningMemory,
+  section: SectionName,
+  entry: string
+): void {
+  mem.sections[section].push(entry);
+}
+
+export function removeEntry(
+  mem: LearningMemory,
+  section: SectionName,
+  index: number
+): void {
+  const entries = mem.sections[section];
+  if (index < 0 || index >= entries.length) {
+    return;
+  }
+  entries.splice(index, 1);
+}
+
+export function getEntries(
+  mem: LearningMemory,
+  section: SectionName
+): string[] {
+  return [...mem.sections[section]];
+}
+
+export function totalEntryCount(mem: LearningMemory): number {
+  return SECTION_ORDER.reduce(
+    (sum, section) => sum + mem.sections[section].length,
+    0
+  );
+}

package/src/core/paths.ts

@@ -0,0 +1,86 @@
+import { join } from "path";
+import { homedir } from "os";
+import { generateProjectId } from "./project-id";
+
+const MINK_ROOT = join(homedir(), ".mink");
+
+export function minkRoot(): string {
+  return MINK_ROOT;
+}
+
+export function projectDir(cwd: string): string {
+  const id = generateProjectId(cwd);
+  return join(MINK_ROOT, "projects", id);
+}
+
+export function sessionPath(cwd: string): string {
+  return join(projectDir(cwd), "session.json");
+}
+
+export function fileIndexPath(cwd: string): string {
+  return join(projectDir(cwd), "file-index.json");
+}
+
+export function configPath(cwd: string): string {
+  return join(projectDir(cwd), "config.json");
+}
+
+export function learningMemoryPath(cwd: string): string {
+  return join(projectDir(cwd), "learning-memory.md");
+}
+
+export function tokenLedgerPath(cwd: string): string {
+  return join(projectDir(cwd), "token-ledger.json");
+}
+
+export function tokenLedgerArchivePath(cwd: string): string {
+  return join(projectDir(cwd), "token-ledger-archive.json");
+}
+
+export function bugMemoryPath(cwd: string): string {
+  return join(projectDir(cwd), "bug-memory.json");
+}
+
+export function actionLogPath(cwd: string): string {
+  return join(projectDir(cwd), "action-log.md");
+}
+
+export function schedulerPidPath(): string {
+  return join(MINK_ROOT, "scheduler.pid");
+}
+
+export function schedulerLogPath(): string {
+  return join(MINK_ROOT, "scheduler.log");
+}
+
+export function schedulerManifestPath(cwd: string): string {
+  return join(projectDir(cwd), "scheduler-manifest.json");
+}
+
+export function globalConfigPath(): string {
+  return join(MINK_ROOT, "config");
+}
+
+export function projectMetaPath(cwd: string): string {
+  return join(projectDir(cwd), "project-meta.json");
+}
+
+export function backupDirPath(cwd: string): string {
+  return join(projectDir(cwd), "backups");
+}
+
+export function designCapturesDir(cwd: string): string {
+  return join(projectDir(cwd), "design-captures");
+}
+
+export function designReportPath(cwd: string): string {
+  return join(projectDir(cwd), "design-report.json");
+}
+
+export function frameworkAdvisorPath(cwd: string): string {
+  return join(projectDir(cwd), "framework-advisor.md");
+}
+
+export function frameworkAdvisorJsonPath(cwd: string): string {
+  return join(projectDir(cwd), "framework-advisor.json");
+}

package/src/core/pattern-engine.ts

@@ -0,0 +1,108 @@
+import type { ExtractedPattern, PatternMatch } from "../types/learning-memory";
+
+// Triggers for phrase-based word-boundary patterns
+const PHRASE_TRIGGERS = [
+  /never\s+use\s+/i,
+  /\bavoid\s+/i,
+];
+
+// Stop characters/sequences that end a phrase
+const PHRASE_STOP_RE = /[—–\-.]|\s+(?:in|for|with|on|by|from|to|when|if|because|since|after|before|during|until)\s+|$/;
+
+export function extractPatterns(entries: string[]): ExtractedPattern[] {
+  const results: ExtractedPattern[] = [];
+
+  for (const entry of entries) {
+    const quotedPatterns: ExtractedPattern[] = [];
+
+    // 1. Extract quoted strings (double and single quotes)
+    const quoteRe = /["']([^"']+)["']/g;
+    let qMatch: RegExpExecArray | null;
+    while ((qMatch = quoteRe.exec(entry)) !== null) {
+      quotedPatterns.push({
+        type: "literal",
+        pattern: qMatch[1],
+        sourceEntry: entry,
+      });
+    }
+
+    results.push(...quotedPatterns);
+
+    // 2. Extract phrase-based word-boundary patterns
+    for (const triggerRe of PHRASE_TRIGGERS) {
+      // Build a combined regex that finds the trigger and captures the rest
+      const fullRe = new RegExp(triggerRe.source, "gi");
+      let triggerMatch: RegExpExecArray | null;
+
+      while ((triggerMatch = fullRe.exec(entry)) !== null) {
+        const afterTrigger = entry.slice(triggerMatch.index + triggerMatch[0].length);
+
+        // Remove any quoted portions from the remaining text before finding stop
+        let cleaned = afterTrigger;
+        // Replace quoted content with spaces to preserve indices
+        cleaned = cleaned.replace(/["'][^"']*["']/g, (m) => " ".repeat(m.length));
+
+        // Find stop position
+        const stopMatch = PHRASE_STOP_RE.exec(cleaned);
+        const phraseLength = stopMatch && stopMatch.index > 0 ? stopMatch.index : cleaned.length;
+
+        let phrase = afterTrigger.slice(0, phraseLength).trim();
+
+        // Remove quoted substrings from phrase
+        phrase = phrase.replace(/["'][^"']*["']/g, "").trim();
+        // Collapse multiple spaces
+        phrase = phrase.replace(/\s+/g, " ").trim();
+
+        if (phrase.length > 0) {
+          results.push({
+            type: "word-boundary",
+            pattern: phrase,
+            sourceEntry: entry,
+          });
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+export function matchPatterns(
+  patterns: ExtractedPattern[],
+  content: string
+): PatternMatch[] {
+  if (!content || patterns.length === 0) {
+    return [];
+  }
+
+  const matches: PatternMatch[] = [];
+
+  for (const pat of patterns) {
+    if (pat.type === "literal") {
+      // Case-sensitive includes check
+      let idx = content.indexOf(pat.pattern);
+      while (idx !== -1) {
+        matches.push({
+          pattern: pat,
+          matchedText: pat.pattern,
+          index: idx,
+        });
+        idx = content.indexOf(pat.pattern, idx + 1);
+      }
+    } else {
+      // Word-boundary, case-insensitive
+      const escaped = pat.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(`\\b${escaped}\\b`, "gi");
+      let m: RegExpExecArray | null;
+      while ((m = re.exec(content)) !== null) {
+        matches.push({
+          pattern: pat,
+          matchedText: m[0],
+          index: m.index,
+        });
+      }
+    }
+  }
+
+  return matches;
+}

package/src/core/project-id.ts

@@ -0,0 +1,19 @@
+import { createHash } from "crypto";
+import { basename } from "path";
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+export function generateProjectId(absolutePath: string): string {
+  const normalized = absolutePath.replace(/\/+$/, "");
+  const slug = slugify(basename(normalized));
+  const hash = createHash("sha256")
+    .update(normalized)
+    .digest("hex")
+    .slice(0, 6);
+  return `${slug}-${hash}`;
+}

package/src/core/project-registry.ts

@@ -0,0 +1,64 @@
+import { readdirSync, existsSync } from "fs";
+import { join } from "path";
+import { minkRoot } from "./paths";
+import { safeReadJson } from "./fs-utils";
+
+export interface ProjectMeta {
+  cwd: string;
+  name: string;
+  initTimestamp: string;
+  version: string;
+}
+
+export interface RegisteredProject {
+  id: string;
+  cwd: string;
+  name: string;
+  version: string;
+}
+
+export function getProjectMeta(projDir: string): ProjectMeta | null {
+  const metaPath = join(projDir, "project-meta.json");
+  const raw = safeReadJson(metaPath);
+  if (
+    raw === null ||
+    typeof raw !== "object" ||
+    Array.isArray(raw)
+  ) {
+    return null;
+  }
+  const obj = raw as Record<string, unknown>;
+  if (typeof obj.cwd !== "string" || typeof obj.name !== "string") {
+    return null;
+  }
+  return {
+    cwd: obj.cwd as string,
+    name: obj.name as string,
+    initTimestamp: (obj.initTimestamp as string) ?? "",
+    version: (obj.version as string) ?? "0.1.0",
+  };
+}
+
+export function listRegisteredProjects(): RegisteredProject[] {
+  const projectsDir = join(minkRoot(), "projects");
+  if (!existsSync(projectsDir)) return [];
+
+  const entries = readdirSync(projectsDir, { withFileTypes: true });
+  const projects: RegisteredProject[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const projDir = join(projectsDir, entry.name);
+    const meta = getProjectMeta(projDir);
+    if (meta) {
+      projects.push({
+        id: entry.name,
+        cwd: meta.cwd,
+        name: meta.name,
+        version: meta.version,
+      });
+    }
+  }
+
+  return projects;
+}