@drewpayment/mink 0.2.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drewpayment/mink",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "A hidden presence that moves alongside the developer — token efficiency and cross-project wiki for AI coding assistants",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -137,6 +137,18 @@ switch (command) {
     break;
   }
 
+  case "sync": {
+    const { sync } = await import("./commands/sync");
+    await sync(process.argv.slice(3));
+    break;
+  }
+
+  case "device": {
+    const { device } = await import("./commands/device");
+    device(process.argv.slice(3));
+    break;
+  }
+
   case "bug-search": {
     const { bugSearch } = await import("./commands/bug-search");
     bugSearch(cwd, process.argv.slice(3).join(" "));
@@ -189,13 +201,25 @@ switch (command) {
     console.log("  config [key] [value]    Manage global user settings");
     console.log();
     console.log("Notes & Wiki:");
-    console.log("  wiki <cmd>              Manage the notes/wiki vault (init|status|rebuild-index|organize)");
+    console.log("  wiki <cmd>              Manage the notes/wiki vault (init|status|link|unlink|links|rebuild-index|organize)");
     console.log("  note \"text\"             Capture a note to the vault");
     console.log("  note --daily [text]     Create or append to today's daily note");
     console.log("  note list [filters]     List notes (--category, --tag, --recent)");
     console.log("  note search <term>      Full-text search across the vault");
     console.log("  skill install           Install /mink:note skill for Claude Code");
     console.log();
+    console.log("Devices & Sync:");
+    console.log("  device                  Show current device info");
+    console.log("  device list             List all registered devices");
+    console.log("  device rename <name>    Set a friendly name for this device");
+    console.log("  sync                    Full manual sync (pull then push)");
+    console.log("  sync init <remote-url>  Connect ~/.mink to a git remote for cross-device sync");
+    console.log("  sync status             Show sync state (remote, last sync, pending changes)");
+    console.log("  sync push               Manually push local changes");
+    console.log("  sync pull               Manually pull remote changes");
+    console.log("  sync pause / resume     Temporarily disable/enable auto-sync");
+    console.log("  sync disconnect         Remove git tracking (data preserved)");
+    console.log();
     console.log("Automation & Analysis:");
     console.log("  dashboard [--port=N]    Open the real-time web dashboard");
     console.log("  daemon <cmd>            Manage the background daemon (start|stop|restart|logs)");

package/src/commands/config.ts

@@ -69,7 +69,7 @@ export async function config(args: string[]): Promise<void> {
     const all = resolveAllConfig();
     console.log("[mink] configuration:");
     for (const entry of all) {
-      let line = `  ${entry.key} = ${entry.value} (source: ${entry.source})`;
+      let line = `  ${entry.key} = ${entry.value} (${entry.scope}, source: ${entry.source})`;
       if (
         entry.source === "environment variable" &&
         entry.configFileValue !== undefined

package/src/commands/device.ts

@@ -0,0 +1,65 @@
+import {
+  getOrCreateDeviceId,
+  listDevices,
+  setDeviceName,
+} from "../core/device";
+import { hostname, platform } from "os";
+
+export function device(args: string[]): void {
+  const sub = args[0] ?? "status";
+
+  switch (sub) {
+    case "status": {
+      const id = getOrCreateDeviceId();
+      const devices = listDevices();
+      const current = devices.find((d) => d.id === id);
+      console.log("[mink] device info:");
+      console.log(`  id:        ${id}`);
+      console.log(`  name:      ${current?.name ?? hostname()}`);
+      console.log(`  hostname:  ${hostname()}`);
+      console.log(`  platform:  ${platform()}`);
+      if (current?.firstSeen) {
+        console.log(`  first seen: ${current.firstSeen}`);
+      }
+      if (current?.lastSeen) {
+        console.log(`  last seen:  ${current.lastSeen}`);
+      }
+      break;
+    }
+
+    case "list": {
+      const devices = listDevices();
+      const currentId = getOrCreateDeviceId();
+      if (devices.length === 0) {
+        console.log("[mink] no devices registered yet");
+        return;
+      }
+      console.log("[mink] registered devices:");
+      for (const d of devices) {
+        const marker = d.id === currentId ? " (this device)" : "";
+        console.log(`  ${d.name}${marker}`);
+        console.log(`    id:       ${d.id}`);
+        console.log(`    hostname: ${d.hostname}`);
+        console.log(`    platform: ${d.platform}`);
+        console.log(`    last seen: ${d.lastSeen}`);
+      }
+      break;
+    }
+
+    case "rename": {
+      const name = args.slice(1).join(" ");
+      if (!name) {
+        console.error("Usage: mink device rename <name>");
+        process.exit(1);
+      }
+      setDeviceName(name);
+      console.log(`[mink] device renamed to "${name}"`);
+      break;
+    }
+
+    default:
+      console.error(`[mink] unknown device subcommand: ${sub}`);
+      console.error("Usage: mink device [status|list|rename <name>]");
+      process.exit(1);
+  }
+}

package/src/commands/session-start.ts

@@ -7,6 +7,32 @@ import { isWikiEnabled, isVaultInitialized, isInsideVault } from "../core/vault"
 import { loadVaultIndex } from "../core/note-index";
 
 export function sessionStart(cwd: string): void {
+  // Migrate config to shared/local split if needed (before sync pull)
+  try {
+    const { migrateConfigIfNeeded } = require("../core/global-config");
+    migrateConfigIfNeeded();
+  } catch {
+    // Never crash hooks
+  }
+
+  // Register/update this device in the registry
+  try {
+    const { updateDeviceHeartbeat } = require("../core/device");
+    updateDeviceHeartbeat();
+  } catch {
+    // Never crash hooks
+  }
+
+  // Sync pull before session begins (if enabled)
+  try {
+    const { isSyncInitialized, syncPull } = require("../core/sync");
+    if (isSyncInitialized()) {
+      syncPull((msg: string) => console.error(msg));
+    }
+  } catch {
+    // Never crash hooks
+  }
+
   const dir = projectDir(cwd);
   mkdirSync(dir, { recursive: true });
 

package/src/commands/session-stop.ts

@@ -1,6 +1,5 @@
 import { statSync, existsSync, readFileSync } from "fs";
 import { join, dirname } from "path";
-import { execSync } from "child_process";
 import { safeReadJson, atomicWriteJson, atomicWriteText } from "../core/fs-utils";
 import { isSessionState, buildSummary } from "../core/session";
 import { reflect } from "./reflect";
@@ -10,10 +9,8 @@ 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";
 
@@ -128,13 +125,11 @@ export function sessionStop(
     // Never crash hooks
   }
 
-  // Git backup for wiki vault
+  // Full mink sync (subsumes wiki git-backup)
   try {
-    if (isWikiEnabled() && isVaultInitialized()) {
-      const gitBackup = resolveConfigValue("wiki.git-backup");
-      if (gitBackup.value === "true") {
-        gitBackupVault(onReminder);
-      }
+    const { isSyncInitialized, syncPush } = require("../core/sync");
+    if (isSyncInitialized()) {
+      syncPush(onReminder);
     }
   } catch {
     // Never crash hooks
@@ -209,53 +204,3 @@ function writeSessionToWiki(
   }
 }
 
-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/sync.ts

@@ -0,0 +1,111 @@
+import {
+  initSync,
+  syncPull,
+  syncPush,
+  getSyncStatus,
+  disconnectSync,
+  isSyncInitialized,
+} from "../core/sync";
+import { setConfigValue } from "../core/global-config";
+
+export async function sync(args: string[]): Promise<void> {
+  const subcommand = args[0];
+
+  switch (subcommand) {
+    case undefined:
+      // No args: full manual sync (pull then push)
+      return handleManualSync();
+
+    case "init":
+      return handleInit(args.slice(1));
+
+    case "status":
+      return handleStatus();
+
+    case "push":
+      syncPush((msg) => console.error(msg));
+      return;
+
+    case "pull":
+      syncPull((msg) => console.error(msg));
+      return;
+
+    case "pause":
+      return handlePause();
+
+    case "resume":
+      return handleResume();
+
+    case "disconnect":
+      return handleDisconnect();
+
+    default:
+      console.error(`[mink] unknown sync subcommand: ${subcommand}`);
+      console.error("Usage: mink sync [init|status|push|pull|pause|resume|disconnect]");
+      process.exit(1);
+  }
+}
+
+function handleManualSync(): void {
+  if (!isSyncInitialized()) {
+    console.error("[mink] sync is not initialized");
+    console.error("Run 'mink sync init <remote-url>' to set up sync");
+    return;
+  }
+
+  console.log("[mink] pulling remote changes...");
+  syncPull((msg) => console.error(msg));
+
+  console.log("[mink] pushing local changes...");
+  syncPush((msg) => console.error(msg));
+
+  console.log("[mink] sync complete");
+}
+
+function handleInit(args: string[]): void {
+  const remoteUrl = args[0];
+  if (!remoteUrl) {
+    console.error("[mink] missing remote URL");
+    console.error("Usage: mink sync init <remote-url>");
+    console.error("Example: mink sync init git@github.com:user/mink-data.git");
+    process.exit(1);
+  }
+
+  initSync(remoteUrl);
+}
+
+function handleStatus(): void {
+  const status = getSyncStatus();
+
+  console.log("Mink Sync Status");
+  console.log("─".repeat(40));
+  console.log(`  Enabled:          ${status.enabled ? "yes" : "no"}`);
+  console.log(`  Git initialized:  ${status.gitInitialized ? "yes" : "no"}`);
+  console.log(`  Remote URL:       ${status.remoteUrl || "(not set)"}`);
+  console.log(`  Branch:           ${status.branch || "(none)"}`);
+  console.log(`  Pending changes:  ${status.pendingChanges}`);
+  console.log(`  Last push:        ${status.lastPush || "(never)"}`);
+  console.log(`  Last pull:        ${status.lastPull || "(never)"}`);
+}
+
+function handlePause(): void {
+  setConfigValue("sync.enabled", "false");
+  console.log("[mink] sync paused — auto-sync disabled");
+  console.log("[mink] run 'mink sync resume' to re-enable");
+}
+
+function handleResume(): void {
+  const status = getSyncStatus();
+  if (!status.gitInitialized) {
+    console.error("[mink] sync has not been initialized yet");
+    console.error("Run 'mink sync init <remote-url>' first");
+    return;
+  }
+
+  setConfigValue("sync.enabled", "true");
+  console.log("[mink] sync resumed — auto-sync re-enabled");
+}
+
+function handleDisconnect(): void {
+  disconnectSync();
+}

package/src/commands/wiki.ts

@@ -7,6 +7,9 @@ import {
   isVaultInitialized,
   vaultManifestPath,
   vaultTemplates,
+  linkExternal,
+  unlinkExternal,
+  listLinks,
 } from "../core/vault";
 import { atomicWriteJson } from "../core/fs-utils";
 import { setConfigValue } from "../core/global-config";
@@ -34,13 +37,25 @@ export async function wiki(
     case "organize":
       wikiOrganize();
       break;
+    case "link":
+      wikiLink(args.slice(1));
+      break;
+    case "unlink":
+      wikiUnlink(args.slice(1));
+      break;
+    case "links":
+      wikiLinks();
+      break;
     default:
-      console.log("Usage: mink wiki <init|status|rebuild-index|organize>");
+      console.log("Usage: mink wiki <command>");
       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");
+      console.log("  link <path> [name]  Symlink external notes into the vault");
+      console.log("  unlink <name>       Remove a symlinked directory from the vault");
+      console.log("  links               List all linked directories");
       break;
   }
 }
@@ -188,6 +203,15 @@ function wikiStatus(): void {
     `  last indexed: ${index.lastScanTimestamp || "never"}`
   );
 
+  const links = listLinks();
+  if (links.length > 0) {
+    console.log();
+    console.log("  Linked directories:");
+    for (const link of links) {
+      console.log(`    ${link.name} -> ${link.target}`);
+    }
+  }
+
   if (categoryCounts.inbox > 0) {
     console.log();
     console.log(
@@ -242,6 +266,87 @@ function wikiOrganize(): void {
   );
 }
 
+function wikiLink(args: string[]): void {
+  if (!isVaultInitialized()) {
+    console.log("[mink] no vault initialized");
+    console.log("  Run 'mink wiki init' first.");
+    return;
+  }
+
+  const targetPath = args[0];
+  if (!targetPath) {
+    console.log("Usage: mink wiki link <path> [name]");
+    console.log();
+    console.log("  Symlinks an external directory into the vault so it appears");
+    console.log("  alongside Mink's content in Obsidian.");
+    console.log();
+    console.log("  Examples:");
+    console.log("    mink wiki link ~/dev/notes");
+    console.log("    mink wiki link ~/dev/notes my-notes");
+    return;
+  }
+
+  const name = args[1]; // optional override
+  const result = linkExternal(targetPath, name);
+
+  if (!result.ok) {
+    console.error(`[mink] ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(`[mink] linked: ${result.linkName} -> ${targetPath}`);
+  console.log(`  symlink: ${result.linkPath}`);
+  console.log();
+  console.log("  Open ~/.mink/wiki/ as your Obsidian vault to see everything together.");
+}
+
+function wikiUnlink(args: string[]): void {
+  if (!isVaultInitialized()) {
+    console.log("[mink] no vault initialized");
+    return;
+  }
+
+  const name = args[0];
+  if (!name) {
+    console.log("Usage: mink wiki unlink <name>");
+    console.log();
+    console.log("  Run 'mink wiki links' to see linked directories.");
+    return;
+  }
+
+  const result = unlinkExternal(name);
+
+  if (!result.ok) {
+    console.error(`[mink] ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(`[mink] unlinked: ${name}`);
+  console.log("  (original directory was not modified)");
+}
+
+function wikiLinks(): void {
+  if (!isVaultInitialized()) {
+    console.log("[mink] no vault initialized");
+    return;
+  }
+
+  const links = listLinks();
+
+  if (links.length === 0) {
+    console.log("[mink] no linked directories");
+    console.log("  Use 'mink wiki link <path>' to symlink external notes into the vault.");
+    return;
+  }
+
+  console.log("[mink] linked directories:");
+  console.log();
+  for (const link of links) {
+    console.log(`  ${link.name} -> ${link.target}`);
+    console.log(`    linked: ${link.linkedAt}`);
+  }
+}
+
 function expandPath(raw: string): string {
   if (raw.startsWith("~/")) {
     return resolve(homedir(), raw.slice(2));

package/src/core/device.ts

@@ -0,0 +1,72 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { hostname, platform } from "os";
+import { randomUUID } from "crypto";
+import { deviceIdPath, deviceRegistryPath } from "./paths";
+import { safeReadJson, atomicWriteJson } from "./fs-utils";
+import type { DeviceInfo, DeviceRegistry } from "../types/config";
+
+export function getOrCreateDeviceId(): string {
+  const idPath = deviceIdPath();
+  if (existsSync(idPath)) {
+    return readFileSync(idPath, "utf-8").trim();
+  }
+  const id = randomUUID();
+  mkdirSync(dirname(idPath), { recursive: true });
+  writeFileSync(idPath, id + "\n");
+  return id;
+}
+
+export function loadDeviceRegistry(): DeviceRegistry {
+  const raw = safeReadJson(deviceRegistryPath());
+  if (raw !== null && typeof raw === "object" && !Array.isArray(raw) && "devices" in (raw as object)) {
+    return raw as DeviceRegistry;
+  }
+  return { devices: {} };
+}
+
+export function saveDeviceRegistry(registry: DeviceRegistry): void {
+  atomicWriteJson(deviceRegistryPath(), registry);
+}
+
+export function updateDeviceHeartbeat(): void {
+  const id = getOrCreateDeviceId();
+  const registry = loadDeviceRegistry();
+  const now = new Date().toISOString();
+  const existing = registry.devices[id];
+
+  registry.devices[id] = {
+    name: existing?.name ?? hostname(),
+    hostname: hostname(),
+    platform: platform(),
+    firstSeen: existing?.firstSeen ?? now,
+    lastSeen: now,
+  };
+
+  saveDeviceRegistry(registry);
+}
+
+export function listDevices(): Array<DeviceInfo & { id: string }> {
+  const registry = loadDeviceRegistry();
+  return Object.entries(registry.devices).map(([id, info]) => ({
+    id,
+    ...info,
+  }));
+}
+
+export function setDeviceName(name: string): void {
+  const id = getOrCreateDeviceId();
+  const registry = loadDeviceRegistry();
+  const now = new Date().toISOString();
+  const existing = registry.devices[id];
+
+  registry.devices[id] = {
+    name,
+    hostname: hostname(),
+    platform: platform(),
+    firstSeen: existing?.firstSeen ?? now,
+    lastSeen: now,
+  };
+
+  saveDeviceRegistry(registry);
+}