@drewpayment/mink 0.1.0 → 0.2.1

package/src/commands/session-stop.ts

@@ -1,11 +1,19 @@
-import { statSync, existsSync } from "fs";
+import { statSync, existsSync, readFileSync } from "fs";
 import { join, dirname } from "path";
-import { safeReadJson, atomicWriteJson } from "../core/fs-utils";
+import { execSync } from "child_process";
+import { safeReadJson, atomicWriteJson, atomicWriteText } from "../core/fs-utils";
 import { isSessionState, buildSummary } from "../core/session";
 import { reflect } from "./reflect";
 import { createLedgerFinalizer } from "../core/token-ledger";
 import { loadBugMemory, hasBugForFileInSession } from "../core/bug-memory";
 import { createActionLogWriter, consolidateLog } from "../core/action-log";
+import {
+  isWikiEnabled,
+  isVaultInitialized,
+  resolveVaultPath,
+  vaultProjects,
+} from "../core/vault";
+import { resolveConfigValue } from "../core/global-config";
 import type { SessionState, SessionFinalizer } from "../types/session";
 import type { ProjectConfig } from "../types/file-index";
 
@@ -111,5 +119,143 @@ export function sessionStop(
     );
   }
 
+  // Write session summary to wiki vault
+  try {
+    if (isWikiEnabled() && isVaultInitialized() && hasActivity(state)) {
+      writeSessionToWiki(state, projDir);
+    }
+  } catch {
+    // Never crash hooks
+  }
+
+  // Git backup for wiki vault
+  try {
+    if (isWikiEnabled() && isVaultInitialized()) {
+      const gitBackup = resolveConfigValue("wiki.git-backup");
+      if (gitBackup.value === "true") {
+        gitBackupVault(onReminder);
+      }
+    }
+  } catch {
+    // Never crash hooks
+  }
+
   atomicWriteJson(sessionFile, state);
 }
+
+function writeSessionToWiki(
+  state: SessionState,
+  projDir: string
+): void {
+  const metaRaw = safeReadJson(join(projDir, "project-meta.json")) as Record<
+    string,
+    unknown
+  > | null;
+  const projectName = (metaRaw?.name as string) ?? "unknown";
+
+  const date = new Date().toISOString().split("T")[0];
+  const readCount = Object.keys(state.reads).length;
+  const writeCount = state.writes.length;
+
+  const sessionDir = join(vaultProjects(projectName), "sessions");
+  const sessionFile = join(sessionDir, `${date}.md`);
+
+  const timestamp = new Date().toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  });
+
+  const entry = [
+    ``,
+    `### Session ${timestamp}`,
+    ``,
+    `- Reads: ${readCount}`,
+    `- Writes: ${writeCount}`,
+  ];
+
+  // Top edited files
+  const editCounts: Record<string, number> = {};
+  for (const w of state.writes) {
+    editCounts[w.filePath] = (editCounts[w.filePath] || 0) + 1;
+  }
+  const topEdits = Object.entries(editCounts)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5);
+  if (topEdits.length > 0) {
+    entry.push(`- Key files:`);
+    for (const [file, count] of topEdits) {
+      entry.push(`  - \`${file}\` (${count} edits)`);
+    }
+  }
+
+  entry.push("");
+
+  if (existsSync(sessionFile)) {
+    const existing = readFileSync(sessionFile, "utf-8");
+    atomicWriteText(sessionFile, existing.trimEnd() + "\n" + entry.join("\n"));
+  } else {
+    const header = [
+      `---`,
+      `created: "${new Date().toISOString()}"`,
+      `updated: "${new Date().toISOString()}"`,
+      `tags: [session, ${projectName}]`,
+      `category: projects`,
+      `---`,
+      ``,
+      `# Sessions — ${projectName} — ${date}`,
+    ].join("\n");
+    atomicWriteText(sessionFile, header + "\n" + entry.join("\n"));
+  }
+}
+
+function gitBackupVault(
+  onReminder: (msg: string) => void
+): void {
+  const vaultPath = resolveVaultPath();
+
+  // Check if vault is a git repo
+  const gitDir = join(vaultPath, ".git");
+  if (!existsSync(gitDir)) {
+    onReminder(
+      "[mink] wiki git-backup enabled but vault is not a git repo — run 'git init' in " +
+        vaultPath
+    );
+    return;
+  }
+
+  try {
+    // Check for changes
+    const status = execSync("git status --porcelain", {
+      cwd: vaultPath,
+      timeout: 5000,
+    }).toString();
+
+    if (!status.trim()) return; // Nothing to commit
+
+    // Stage and commit
+    execSync("git add -A", { cwd: vaultPath, timeout: 5000 });
+    const msg = `mink: vault update ${new Date().toISOString().split("T")[0]}`;
+    execSync(`git commit -m "${msg}"`, {
+      cwd: vaultPath,
+      timeout: 5000,
+    });
+
+    // Push (best-effort with timeout)
+    const remote = resolveConfigValue("wiki.git-remote").value;
+    try {
+      execSync(`git push ${remote}`, {
+        cwd: vaultPath,
+        timeout: 10000,
+      });
+    } catch {
+      onReminder(
+        `[mink] wiki git push to '${remote}' failed — local commit preserved, will retry next session`
+      );
+    }
+  } catch (err) {
+    onReminder(
+      `[mink] wiki git backup error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}

package/src/commands/skill.ts

@@ -0,0 +1,186 @@
+import { join, resolve, dirname } from "path";
+import { homedir } from "os";
+import {
+  existsSync,
+  mkdirSync,
+  copyFileSync,
+  unlinkSync,
+  readdirSync,
+  rmSync,
+  symlinkSync,
+  lstatSync,
+} from "fs";
+
+// Standard skills directory used by the skills CLI ecosystem
+const AGENTS_SKILLS_DIR = join(homedir(), ".agents", "skills");
+// Claude Code looks for skills via symlinks here
+const CLAUDE_SKILLS_DIR = join(homedir(), ".claude", "skills");
+
+function getSkillsSourceDir(): string {
+  // Skills live at repo-root/skills/ (the standard skills/{name}/SKILL.md layout)
+  return resolve(
+    dirname(new URL(import.meta.url).pathname),
+    "../../skills"
+  );
+}
+
+function getAvailableSkills(): string[] {
+  const dir = getSkillsSourceDir();
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true })
+    .filter(
+      (d) => d.isDirectory() && existsSync(join(dir, d.name, "SKILL.md"))
+    )
+    .map((d) => d.name);
+}
+
+function isInstalled(skillName: string): boolean {
+  return existsSync(join(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
+}
+
+export async function skill(args: string[]): Promise<void> {
+  const sub = args[0];
+
+  switch (sub) {
+    case "install":
+      skillInstall(args[1]);
+      break;
+    case "uninstall":
+      skillUninstall(args[1]);
+      break;
+    case "list":
+      skillList();
+      break;
+    default:
+      console.log("Usage: mink skill <install|uninstall|list> [name]");
+      console.log();
+      console.log("  install [name]    Install Mink skills to ~/.agents/skills/");
+      console.log("  uninstall [name]  Remove installed Mink skills");
+      console.log("  list              Show available and installed skills");
+      console.log();
+      console.log("Or install via the skills CLI:");
+      console.log("  npx skills add drewpayment/mink");
+      break;
+  }
+}
+
+function skillInstall(name?: string): void {
+  const sourceDir = getSkillsSourceDir();
+  const skills = name ? [name] : getAvailableSkills();
+
+  if (skills.length === 0) {
+    console.error("[mink] no skills found to install");
+    console.error("  Expected skills at: " + sourceDir);
+    return;
+  }
+
+  mkdirSync(AGENTS_SKILLS_DIR, { recursive: true });
+
+  for (const skillName of skills) {
+    const srcDir = join(sourceDir, skillName);
+    const srcFile = join(srcDir, "SKILL.md");
+    const destDir = join(AGENTS_SKILLS_DIR, skillName);
+
+    if (!existsSync(srcFile)) {
+      console.error(`[mink] skill not found: ${skillName}`);
+      continue;
+    }
+
+    // Copy the entire skill directory (SKILL.md + any reference files)
+    mkdirSync(destDir, { recursive: true });
+    copyDirRecursive(srcDir, destDir);
+
+    // Create symlink in ~/.claude/skills/ (how Claude Code discovers skills)
+    mkdirSync(CLAUDE_SKILLS_DIR, { recursive: true });
+    const symlink = join(CLAUDE_SKILLS_DIR, skillName);
+    try {
+      if (existsSync(symlink)) {
+        // Remove old file or symlink
+        if (lstatSync(symlink).isSymbolicLink() || lstatSync(symlink).isFile()) {
+          unlinkSync(symlink);
+        } else {
+          rmSync(symlink, { recursive: true, force: true });
+        }
+      }
+      const relativeTarget = join("..", "..", ".agents", "skills", skillName);
+      symlinkSync(relativeTarget, symlink);
+    } catch {
+      // Non-critical — skill still works from ~/.agents/skills/
+    }
+
+    console.log(`[mink] installed: ${skillName} -> ${destDir}`);
+  }
+
+  console.log();
+  console.log("  Restart your Claude Code session to use the new skills.");
+}
+
+function skillUninstall(name?: string): void {
+  const skills = name ? [name] : getAvailableSkills();
+
+  for (const skillName of skills) {
+    const destDir = join(AGENTS_SKILLS_DIR, skillName);
+
+    if (!existsSync(destDir)) {
+      console.log(`[mink] not installed: ${skillName}`);
+      continue;
+    }
+
+    rmSync(destDir, { recursive: true, force: true });
+
+    // Remove symlink from ~/.claude/skills/
+    const symlink = join(CLAUDE_SKILLS_DIR, skillName);
+    try {
+      if (existsSync(symlink)) unlinkSync(symlink);
+    } catch {
+      // Non-critical
+    }
+
+    console.log(`[mink] uninstalled: ${skillName}`);
+  }
+}
+
+function skillList(): void {
+  const available = getAvailableSkills();
+  const installed = available.filter(isInstalled);
+  const notInstalled = available.filter((s) => !installed.includes(s));
+
+  console.log("[mink] skills:");
+  console.log();
+
+  if (installed.length > 0) {
+    console.log("  Installed:");
+    for (const s of installed) {
+      console.log(`    ${s}  (${join(AGENTS_SKILLS_DIR, s)})`);
+    }
+  }
+
+  if (notInstalled.length > 0) {
+    console.log("  Available:");
+    for (const s of notInstalled) {
+      console.log(`    ${s}`);
+    }
+  }
+
+  if (available.length === 0) {
+    console.log("  No skills available.");
+  }
+
+  console.log();
+  console.log("  Install with: mink skill install");
+  console.log("  Or via skills CLI: npx skills add drewpayment/mink");
+}
+
+function copyDirRecursive(src: string, dest: string): void {
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}

package/src/commands/wiki.ts

@@ -0,0 +1,250 @@
+import { existsSync, statSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+import {
+  resolveVaultPath,
+  ensureVaultStructure,
+  isVaultInitialized,
+  vaultManifestPath,
+  vaultTemplates,
+} from "../core/vault";
+import { atomicWriteJson } from "../core/fs-utils";
+import { setConfigValue } from "../core/global-config";
+import { seedTemplates } from "../core/vault-templates";
+import { rebuildVaultIndex, loadVaultIndex } from "../core/note-index";
+import { updateMasterIndex } from "../core/note-linker";
+import type { VaultManifest, NoteCategory } from "../types/note";
+
+export async function wiki(
+  _cwd: string,
+  args: string[]
+): Promise<void> {
+  const sub = args[0];
+
+  switch (sub) {
+    case "init":
+      await wikiInit(args.slice(1));
+      break;
+    case "status":
+      wikiStatus();
+      break;
+    case "rebuild-index":
+      wikiRebuildIndex();
+      break;
+    case "organize":
+      wikiOrganize();
+      break;
+    default:
+      console.log("Usage: mink wiki <init|status|rebuild-index|organize>");
+      console.log();
+      console.log("  init                Initialize the notes/wiki vault");
+      console.log("  status              Show vault statistics");
+      console.log("  rebuild-index       Full rescan and reindex of vault");
+      console.log("  organize            List inbox notes needing categorization");
+      break;
+  }
+}
+
+async function wikiInit(args: string[]): Promise<void> {
+  const pathArg = args[0];
+
+  if (isVaultInitialized()) {
+    const vaultPath = resolveVaultPath();
+    console.log(`[mink] vault already initialized at ${vaultPath}`);
+    console.log("  Run 'mink wiki rebuild-index' to refresh the index.");
+    return;
+  }
+
+  let targetPath: string;
+
+  if (pathArg) {
+    targetPath = expandPath(pathArg);
+  } else {
+    targetPath = resolveVaultPath();
+    console.log(`[mink] initializing vault at ${targetPath}`);
+    console.log(
+      "  (set a custom path with: mink wiki init /path/to/vault)"
+    );
+  }
+
+  const isExisting =
+    existsSync(targetPath) && statSync(targetPath).isDirectory();
+
+  // Set the config value
+  setConfigValue("wiki.path", targetPath);
+
+  // Create vault structure
+  ensureVaultStructure();
+
+  // Seed templates
+  seedTemplates(vaultTemplates());
+
+  // Create vault manifest
+  const manifest: VaultManifest = {
+    version: 1,
+    createdAt: new Date().toISOString(),
+    totalNotes: 0,
+    categories: {
+      inbox: 0,
+      projects: 0,
+      areas: 0,
+      resources: 0,
+      archives: 0,
+    },
+    lastOrganized: "",
+  };
+
+  if (isExisting) {
+    console.log(`[mink] scanning existing directory: ${targetPath}`);
+    const index = rebuildVaultIndex();
+    manifest.totalNotes = index.totalNotes;
+
+    // Count by category
+    for (const entry of Object.values(index.entries)) {
+      if (manifest.categories[entry.category] !== undefined) {
+        manifest.categories[entry.category]++;
+      }
+    }
+
+    // Flag potential garbage
+    const suspicious = Object.values(index.entries).filter((e) => {
+      const name = e.filePath.split("/").pop() ?? "";
+      return (
+        e.estimatedTokens < 15 ||
+        name.length > 30 && /[A-Za-z0-9_-]{20,}/.test(name.replace(/\.md$/, ""))
+      );
+    });
+
+    if (suspicious.length > 0) {
+      console.log();
+      console.log(
+        `  [review] ${suspicious.length} files may need attention:`
+      );
+      for (const s of suspicious.slice(0, 10)) {
+        console.log(`    - ${s.filePath} (${s.estimatedTokens} tokens)`);
+      }
+      if (suspicious.length > 10) {
+        console.log(`    ... and ${suspicious.length - 10} more`);
+      }
+    }
+
+    console.log();
+    console.log(
+      `  indexed ${index.totalNotes} notes across the vault`
+    );
+  } else {
+    console.log(`[mink] created new vault at ${targetPath}`);
+  }
+
+  atomicWriteJson(vaultManifestPath(), manifest);
+  updateMasterIndex(targetPath);
+
+  console.log();
+  console.log(`[mink] vault initialized`);
+  console.log(`  path:      ${targetPath}`);
+  console.log(`  templates: ${vaultTemplates()}`);
+  console.log(`  manifest:  ${vaultManifestPath()}`);
+  console.log();
+  console.log("  Next steps:");
+  console.log("    mink note \"your first note\"");
+  console.log("    mink note --daily");
+  console.log("    mink skill install     # install /mink:note skill for Claude Code");
+}
+
+function wikiStatus(): void {
+  if (!isVaultInitialized()) {
+    console.log("[mink] no vault initialized");
+    console.log("  Run 'mink wiki init' to get started.");
+    return;
+  }
+
+  const vaultPath = resolveVaultPath();
+  const index = loadVaultIndex();
+
+  const categoryCounts: Record<string, number> = {
+    inbox: 0,
+    projects: 0,
+    areas: 0,
+    resources: 0,
+    archives: 0,
+  };
+
+  for (const entry of Object.values(index.entries)) {
+    if (categoryCounts[entry.category] !== undefined) {
+      categoryCounts[entry.category]++;
+    }
+  }
+
+  console.log("[mink] vault status");
+  console.log(`  path:    ${vaultPath}`);
+  console.log(`  notes:   ${index.totalNotes}`);
+  console.log();
+  console.log("  Categories:");
+  for (const [cat, count] of Object.entries(categoryCounts)) {
+    console.log(`    ${cat.padEnd(12)} ${count}`);
+  }
+  console.log();
+  console.log(
+    `  last indexed: ${index.lastScanTimestamp || "never"}`
+  );
+
+  if (categoryCounts.inbox > 0) {
+    console.log();
+    console.log(
+      `  ${categoryCounts.inbox} notes in inbox need categorization`
+    );
+  }
+}
+
+function wikiRebuildIndex(): void {
+  if (!isVaultInitialized()) {
+    console.log("[mink] no vault initialized");
+    return;
+  }
+
+  console.log("[mink] rebuilding vault index...");
+  const index = rebuildVaultIndex();
+  updateMasterIndex(resolveVaultPath());
+  console.log(`  indexed ${index.totalNotes} notes`);
+}
+
+function wikiOrganize(): void {
+  if (!isVaultInitialized()) {
+    console.log("[mink] no vault initialized");
+    return;
+  }
+
+  const index = loadVaultIndex();
+  const inboxNotes = Object.values(index.entries).filter(
+    (e) => e.category === "inbox"
+  );
+
+  if (inboxNotes.length === 0) {
+    console.log("[mink] inbox is empty — nothing to organize");
+    return;
+  }
+
+  console.log(`[mink] ${inboxNotes.length} notes in inbox:`);
+  console.log();
+
+  for (const note of inboxNotes) {
+    const tags = note.tags.length > 0 ? ` [${note.tags.join(", ")}]` : "";
+    console.log(`  ${note.filePath}`);
+    console.log(`    ${note.title}${tags}`);
+    if (note.description) {
+      console.log(`    ${note.description}`);
+    }
+    console.log();
+  }
+
+  console.log(
+    "Use '/mink:note' in Claude Code to intelligently categorize these notes."
+  );
+}
+
+function expandPath(raw: string): string {
+  if (raw.startsWith("~/")) {
+    return resolve(homedir(), raw.slice(2));
+  }
+  return resolve(raw);
+}

package/src/core/daemon.ts

@@ -64,7 +64,8 @@ export function startDaemon(cwd: string): void {
   }
 
   // Resolve the CLI entry point
-  const cliPath = resolve(import.meta.dir, "../cli.ts");
+  const __dir = dirname(new URL(import.meta.url).pathname);
+  const cliPath = resolve(__dir, "../cli.ts");
 
   // Ensure log directory exists
   const logPath = schedulerLogPath();