@drewpayment/mink 0.1.0

package/src/core/seed.ts

@@ -0,0 +1,239 @@
+import { basename, join } from "path";
+import { readFileSync, existsSync } from "fs";
+import type { LearningMemory, SeedInfo } from "../types/learning-memory";
+import { createEmptyLearningMemory, addEntry } from "./learning-memory";
+
+// ─── Framework detection maps ─────────────────────────────────────────────────
+
+const NPM_FRAMEWORKS: Record<string, string> = {
+  react: "React",
+  "react-dom": "React",
+  next: "Next.js",
+  vue: "Vue",
+  nuxt: "Nuxt",
+  svelte: "Svelte",
+  "@sveltejs/kit": "SvelteKit",
+  angular: "Angular",
+  "@angular/core": "Angular",
+  express: "Express",
+  fastify: "Fastify",
+  hono: "Hono",
+  koa: "Koa",
+  "@nestjs/core": "NestJS",
+  typescript: "TypeScript",
+  jest: "Jest",
+  vitest: "Vitest",
+  mocha: "Mocha",
+  tailwindcss: "Tailwind CSS",
+  prisma: "Prisma",
+  "@prisma/client": "Prisma",
+  "drizzle-orm": "Drizzle",
+};
+
+const PYTHON_FRAMEWORKS: Record<string, string> = {
+  fastapi: "FastAPI",
+  flask: "Flask",
+  django: "Django",
+  sqlalchemy: "SQLAlchemy",
+  pytest: "pytest",
+  pydantic: "Pydantic",
+  celery: "Celery",
+  httpx: "HTTPX",
+  uvicorn: "Uvicorn",
+};
+
+const CARGO_FRAMEWORKS: Record<string, string> = {
+  "actix-web": "Actix Web",
+  axum: "Axum",
+  tokio: "Tokio",
+  serde: "Serde",
+  diesel: "Diesel",
+  sqlx: "SQLx",
+  warp: "Warp",
+  rocket: "Rocket",
+};
+
+const GO_FRAMEWORKS: Record<string, string> = {
+  "github.com/gin-gonic/gin": "Gin",
+  "github.com/gofiber/fiber": "Fiber",
+  "github.com/labstack/echo": "Echo",
+  "gorm.io/gorm": "GORM",
+  "github.com/gorilla/mux": "Gorilla Mux",
+};
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function readFile(filePath: string): string | null {
+  if (!existsSync(filePath)) return null;
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function dedupeOrdered(arr: string[]): string[] {
+  return [...new Set(arr)];
+}
+
+function detectFromKeys(
+  keys: string[],
+  map: Record<string, string>
+): string[] {
+  const found: string[] = [];
+  for (const key of keys) {
+    if (map[key]) found.push(map[key]);
+  }
+  return dedupeOrdered(found);
+}
+
+// ─── Parsers ──────────────────────────────────────────────────────────────────
+
+export function parsePackageJson(filePath: string): SeedInfo | null {
+  const raw = readFile(filePath);
+  if (raw === null) return null;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+
+  if (typeof parsed !== "object" || parsed === null) return null;
+
+  const obj = parsed as Record<string, unknown>;
+  const projectName = typeof obj.name === "string" ? obj.name : "";
+  const description = typeof obj.description === "string" ? obj.description : "";
+
+  const deps: Record<string, unknown> =
+    typeof obj.dependencies === "object" && obj.dependencies !== null
+      ? (obj.dependencies as Record<string, unknown>)
+      : {};
+  const devDeps: Record<string, unknown> =
+    typeof obj.devDependencies === "object" && obj.devDependencies !== null
+      ? (obj.devDependencies as Record<string, unknown>)
+      : {};
+
+  const allKeys = [...Object.keys(deps), ...Object.keys(devDeps)];
+  const frameworks = detectFromKeys(allKeys, NPM_FRAMEWORKS);
+
+  return { projectName, description, frameworks };
+}
+
+export function parsePyprojectToml(filePath: string): SeedInfo | null {
+  const raw = readFile(filePath);
+  if (raw === null) return null;
+
+  // Extract [project] section name
+  const nameMatch = raw.match(/\[project\][^\[]*\bname\s*=\s*"([^"]+)"/s);
+  const descMatch = raw.match(
+    /\[project\][^\[]*\bdescription\s*=\s*"([^"]+)"/s
+  );
+
+  const projectName = nameMatch ? nameMatch[1] : "";
+  const description = descMatch ? descMatch[1] : "";
+
+  // Simple string-match for framework detection across the whole file
+  const frameworks: string[] = [];
+  for (const [key, label] of Object.entries(PYTHON_FRAMEWORKS)) {
+    if (raw.includes(key)) {
+      frameworks.push(label);
+    }
+  }
+
+  return { projectName, description, frameworks: dedupeOrdered(frameworks) };
+}
+
+export function parseCargoToml(filePath: string): SeedInfo | null {
+  const raw = readFile(filePath);
+  if (raw === null) return null;
+
+  // Extract [package] section name and description
+  const nameMatch = raw.match(/\[package\][^\[]*\bname\s*=\s*"([^"]+)"/s);
+  const descMatch = raw.match(
+    /\[package\][^\[]*\bdescription\s*=\s*"([^"]+)"/s
+  );
+
+  const projectName = nameMatch ? nameMatch[1] : "";
+  const description = descMatch ? descMatch[1] : "";
+
+  // Simple string-match across file
+  const frameworks: string[] = [];
+  for (const [key, label] of Object.entries(CARGO_FRAMEWORKS)) {
+    if (raw.includes(key)) {
+      frameworks.push(label);
+    }
+  }
+
+  return { projectName, description, frameworks: dedupeOrdered(frameworks) };
+}
+
+export function parseGoMod(filePath: string): SeedInfo | null {
+  const raw = readFile(filePath);
+  if (raw === null) return null;
+
+  // Extract module path — last path segment is the project name
+  const moduleMatch = raw.match(/^module\s+(\S+)/m);
+  const modulePath = moduleMatch ? moduleMatch[1] : "";
+  const projectName = modulePath ? basename(modulePath) : "";
+
+  // String-match require block for framework detection
+  const frameworks: string[] = [];
+  for (const [key, label] of Object.entries(GO_FRAMEWORKS)) {
+    if (raw.includes(key)) {
+      frameworks.push(label);
+    }
+  }
+
+  return {
+    projectName,
+    description: "",
+    frameworks: dedupeOrdered(frameworks),
+  };
+}
+
+// ─── Seed ─────────────────────────────────────────────────────────────────────
+
+export function seedLearningMemory(projectRoot: string): LearningMemory {
+  const parsers: Array<() => SeedInfo | null> = [
+    () => parsePackageJson(join(projectRoot, "package.json")),
+    () => parsePyprojectToml(join(projectRoot, "pyproject.toml")),
+    () => parseCargoToml(join(projectRoot, "Cargo.toml")),
+    () => parseGoMod(join(projectRoot, "go.mod")),
+  ];
+
+  const infos: SeedInfo[] = parsers
+    .map((fn) => fn())
+    .filter((info): info is SeedInfo => info !== null);
+
+  // Pick first non-empty project name; fallback to directory basename
+  const projectName =
+    infos.find((i) => i.projectName)?.projectName ?? basename(projectRoot);
+
+  const mem = createEmptyLearningMemory(projectName);
+
+  // Add project description if available
+  const infoWithDesc = infos.find((i) => i.description);
+  if (infoWithDesc?.description) {
+    addEntry(
+      mem,
+      "Key Learnings",
+      `Project: ${projectName} — ${infoWithDesc.description}`
+    );
+  } else {
+    addEntry(mem, "Key Learnings", `Project: ${projectName}`);
+  }
+
+  // Collect all detected frameworks across all parsers
+  const allFrameworks = dedupeOrdered(infos.flatMap((i) => i.frameworks));
+  if (allFrameworks.length > 0) {
+    addEntry(
+      mem,
+      "Key Learnings",
+      `Detected frameworks: ${allFrameworks.join(", ")}`
+    );
+  }
+
+  return mem;
+}

package/src/core/session.ts

@@ -0,0 +1,128 @@
+import { randomBytes } from "crypto";
+import type {
+  SessionState,
+  SessionSummary,
+} from "../types/session";
+
+export function createSessionState(): SessionState {
+  const now = new Date().toISOString();
+  const suffix = randomBytes(2).toString("hex");
+  return {
+    sessionId: `${now}-${suffix}`,
+    startTimestamp: now,
+    stopCount: 0,
+    reads: {},
+    writes: [],
+    counters: {
+      fileIndexHits: 0,
+      fileIndexMisses: 0,
+      repeatedReadWarnings: 0,
+      learnedRuleWarnings: 0,
+    },
+  };
+}
+
+export function recordRead(
+  state: SessionState,
+  filePath: string,
+  estimatedTokens: number,
+  indexHit: boolean
+): void {
+  const existing = state.reads[filePath];
+  if (existing) {
+    existing.readCount++;
+  } else {
+    state.reads[filePath] = {
+      readCount: 1,
+      estimatedTokens,
+      firstReadAt: new Date().toISOString(),
+    };
+  }
+
+  if (indexHit) {
+    state.counters.fileIndexHits++;
+  } else {
+    state.counters.fileIndexMisses++;
+  }
+}
+
+export function recordWrite(
+  state: SessionState,
+  filePath: string,
+  action: "create" | "edit",
+  estimatedTokens: number
+): void {
+  state.writes.push({
+    filePath,
+    action,
+    estimatedTokens,
+    timestamp: new Date().toISOString(),
+  });
+}
+
+export function calculateSavings(state: SessionState): number {
+  const indexSavings = state.counters.fileIndexHits * 200;
+
+  let repeatedReadSavings = 0;
+  for (const read of Object.values(state.reads)) {
+    if (read.readCount > 1) {
+      repeatedReadSavings += (read.readCount - 1) * read.estimatedTokens;
+    }
+  }
+
+  return indexSavings + repeatedReadSavings;
+}
+
+export function buildSummary(state: SessionState): SessionSummary {
+  const reads = Object.entries(state.reads).map(([filePath, read]) => ({
+    filePath,
+    ...read,
+  }));
+
+  let totalTokens = 0;
+  for (const read of Object.values(state.reads)) {
+    totalTokens += read.estimatedTokens;
+  }
+  for (const write of state.writes) {
+    totalTokens += write.estimatedTokens;
+  }
+
+  let repeatedReads = 0;
+  for (const read of Object.values(state.reads)) {
+    if (read.readCount > 1) {
+      repeatedReads += read.readCount - 1;
+    }
+  }
+
+  return {
+    sessionId: state.sessionId,
+    startTimestamp: state.startTimestamp,
+    endTimestamp: new Date().toISOString(),
+    reads,
+    writes: state.writes,
+    totals: {
+      readCount: Object.keys(state.reads).length,
+      writeCount: state.writes.length,
+      estimatedTokens: totalTokens,
+      repeatedReads,
+      fileIndexHits: state.counters.fileIndexHits,
+      fileIndexMisses: state.counters.fileIndexMisses,
+    },
+    estimatedSavings: calculateSavings(state),
+  };
+}
+
+export function isSessionState(value: unknown): value is SessionState {
+  if (value === null || typeof value !== "object") return false;
+  const obj = value as Record<string, unknown>;
+  return (
+    typeof obj.sessionId === "string" &&
+    typeof obj.startTimestamp === "string" &&
+    typeof obj.stopCount === "number" &&
+    typeof obj.reads === "object" &&
+    obj.reads !== null &&
+    Array.isArray(obj.writes) &&
+    typeof obj.counters === "object" &&
+    obj.counters !== null
+  );
+}

package/src/core/stdin.ts

@@ -0,0 +1,13 @@
+export async function readStdinJson(): Promise<unknown | null> {
+  try {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const text = Buffer.concat(chunks).toString("utf-8");
+    if (!text.trim()) return null;
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}

package/src/core/task-registry.ts

@@ -0,0 +1,202 @@
+import type { TaskDefinition } from "../types/scheduler";
+
+// ── Built-in Task Definitions ───────────────────────────────────────────────
+
+const BUILT_IN_TASKS: TaskDefinition[] = [
+  {
+    id: "file-index-rescan",
+    name: "File Index Rescan",
+    description: "Full project scan to update the file index",
+    schedule: "0 */6 * * *",
+    actionType: "function",
+    enabled: true,
+    retryPolicy: { maxAttempts: 3, baseDelayMs: 60_000 },
+    timeoutMs: 120_000,
+  },
+  {
+    id: "action-log-consolidation",
+    name: "Action Log Consolidation",
+    description: "Compress old sessions in the action log",
+    schedule: "0 2 * * *",
+    actionType: "function",
+    enabled: true,
+    retryPolicy: { maxAttempts: 3, baseDelayMs: 60_000 },
+    timeoutMs: 60_000,
+  },
+  {
+    id: "waste-detection",
+    name: "Waste Detection",
+    description: "Analyze token usage for waste patterns",
+    schedule: "0 0 * * 1",
+    actionType: "function",
+    enabled: true,
+    retryPolicy: { maxAttempts: 3, baseDelayMs: 60_000 },
+    timeoutMs: 120_000,
+  },
+  {
+    id: "learning-memory-reflection",
+    name: "Learning Memory Reflection",
+    description: "AI-assisted review and pruning of the learning memory",
+    schedule: "0 3 * * 0",
+    actionType: "ai-cli",
+    enabled: true,
+    retryPolicy: { maxAttempts: 3, baseDelayMs: 60_000 },
+    timeoutMs: 300_000,
+  },
+  {
+    id: "project-suggestions",
+    name: "Project Suggestions",
+    description: "AI-assisted analysis generating improvement suggestions",
+    schedule: "0 4 * * 1",
+    actionType: "ai-cli",
+    enabled: true,
+    retryPolicy: { maxAttempts: 3, baseDelayMs: 60_000 },
+    timeoutMs: 300_000,
+  },
+];
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+export function getBuiltInTasks(): TaskDefinition[] {
+  return BUILT_IN_TASKS;
+}
+
+export function getTaskById(id: string): TaskDefinition | undefined {
+  return BUILT_IN_TASKS.find((t) => t.id === id);
+}
+
+// ── AI CLI Execution ────────────────────────────────────────────────────────
+
+const API_KEY_ENV_VARS = [
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_API_KEY",
+  "OPENAI_API_KEY",
+  "OPENAI_KEY",
+  "AI_API_KEY",
+];
+
+async function executeAiCli(
+  prompt: string,
+  timeoutMs: number
+): Promise<string> {
+  const env: Record<string, string> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined && !API_KEY_ENV_VARS.includes(key)) {
+      env[key] = value;
+    }
+  }
+
+  const proc = Bun.spawn(["claude", "--print", prompt], {
+    env,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const timer = setTimeout(() => {
+    proc.kill();
+  }, timeoutMs);
+
+  try {
+    const exitCode = await proc.exited;
+    clearTimeout(timer);
+
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      throw new Error(`AI CLI exited with code ${exitCode}: ${stderr}`);
+    }
+
+    return await new Response(proc.stdout).text();
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.message.includes("ENOENT")) {
+      throw new Error(
+        "AI CLI (claude) is not available. Install it or ensure it is on PATH."
+      );
+    }
+    throw err;
+  }
+}
+
+// ── Task Execution ──────────────────────────────────────────────────────────
+
+export async function executeTask(
+  taskId: string,
+  projectCwd: string
+): Promise<void> {
+  const task = getTaskById(taskId);
+  if (!task) {
+    throw new Error(`Unknown task: ${taskId}`);
+  }
+
+  switch (taskId) {
+    case "file-index-rescan": {
+      const { scan } = await import("../commands/scan");
+      scan(projectCwd, { check: false });
+      break;
+    }
+
+    case "action-log-consolidation": {
+      const { actionLogPath, configPath } = await import("./paths");
+      const { consolidateLog } = await import("./action-log");
+      const { safeReadJson } = await import("./fs-utils");
+      const config = safeReadJson(configPath(projectCwd)) as {
+        actionLogMaxEntries?: number;
+        actionLogRetentionDays?: number;
+      } | null;
+      consolidateLog(actionLogPath(projectCwd), {
+        maxEntries: config?.actionLogMaxEntries ?? 200,
+        retentionDays: config?.actionLogRetentionDays ?? 7,
+      });
+      break;
+    }
+
+    case "waste-detection": {
+      const { detectWaste } = await import("../commands/detect-waste");
+      detectWaste(projectCwd);
+      break;
+    }
+
+    case "learning-memory-reflection": {
+      if (task.actionType === "ai-cli") {
+        try {
+          const { learningMemoryPath } = await import("./paths");
+          const { readFileSync } = await import("fs");
+          let memoryContent: string;
+          try {
+            memoryContent = readFileSync(
+              learningMemoryPath(projectCwd),
+              "utf-8"
+            );
+          } catch {
+            console.log("[mink] no learning memory found, skipping reflection");
+            return;
+          }
+          const prompt = `Review and suggest pruning for this learning memory. Remove duplicates and outdated entries. Return the cleaned markdown:\n\n${memoryContent}`;
+          await executeAiCli(prompt, task.timeoutMs);
+        } catch {
+          // Fall back to local reflection
+          console.log(
+            "[mink] AI CLI unavailable, falling back to local reflection"
+          );
+        }
+      }
+      // Always run local reflection (either as primary or fallback)
+      const { reflect } = await import("../commands/reflect");
+      const { learningMemoryPath, configPath, projectDir } = await import(
+        "./paths"
+      );
+      reflect(projectDir(projectCwd), learningMemoryPath(projectCwd), configPath(projectCwd));
+      break;
+    }
+
+    case "project-suggestions": {
+      console.log(
+        "[mink] project-suggestions: not yet implemented — skipping"
+      );
+      break;
+    }
+
+    default:
+      throw new Error(`No executor defined for task: ${taskId}`);
+  }
+}

package/src/core/token-estimate.ts

@@ -0,0 +1,36 @@
+const CODE_EXTENSIONS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java",
+  ".c", ".cpp", ".h", ".hpp", ".cs", ".rb", ".php", ".swift",
+  ".kt", ".scala", ".sh", ".bash", ".zsh", ".sql", ".graphql",
+]);
+
+const PROSE_EXTENSIONS = new Set([
+  ".md", ".mdx", ".txt", ".rst", ".adoc", ".tex",
+]);
+
+const BINARY_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico",
+  ".woff", ".woff2", ".ttf", ".eot",
+  ".mp3", ".mp4", ".webm", ".zip", ".tar", ".gz",
+  ".pdf", ".exe", ".dll", ".so", ".dylib",
+]);
+
+export function isBinaryFile(filePath: string, content?: string): boolean {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext)) return true;
+  if (content && content.includes("\0")) return true;
+  return false;
+}
+
+export function estimateTokens(content: string, filePath: string): number {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  let ratio: number;
+  if (CODE_EXTENSIONS.has(ext)) {
+    ratio = 3.5;
+  } else if (PROSE_EXTENSIONS.has(ext)) {
+    ratio = 4.0;
+  } else {
+    ratio = 3.75;
+  }
+  return Math.ceil(content.length / ratio);
+}